public void AddAllInvestedConstraint()
{
var universe = from instrument in this
select instrument.ID;
Constraints.Add(LinearConstraint.Create(universe, Relational.Equal, 1));
}
public void TestGradientWithoutIndices()
{
// Arrange1
double[] combinedAs1 = { 2, 3, 4, 5, 6 };
double[] combinedAs2 = { 9, 5, 1, 5, 8 };
double[] x = Vector.Random(5);
var linearConstraint = new LinearConstraint(combinedAs1)
{
ShouldBe = ConstraintType.EqualTo,
Value = 42
};
// Act1
double[] gradient = linearConstraint.Gradient(x);
// Assert1
Assert.True(gradient.IsEqual(combinedAs1));
// Arrange2
linearConstraint.CombinedAs = combinedAs2;
// Act2
double[] gradient2 = linearConstraint.Gradient(x);
// Assert2
Assert.True(gradient2.IsEqual(combinedAs2));
}
private void setTargetReturnConstraints(double targetReturn)
{
// Sum of all weighted returns should be equal to the target return
var instList = from mr in _samplePortfolio
select new KeyValuePair <string, double>(mr.ID, mr.Mean);
_samplePortfolio.Constraints.Add(LinearConstraint.Create(instList.ToDictionary(a => a.Key, b => b.Value), Relational.Equal, targetReturn));
}
public void AddLongOnlyConstraint()
{
foreach (var instrument in this)
{
// No short positions allowed -> min = 0
Constraints.Add(LinearConstraint.Create(instrument.ID, Relational.Larger, 0));
}
}
public void AddBoxConstraints(HashSet <string> assets, double lowerlimit, double upperlimit)
{
// check if asset in portfolio
foreach (var asset in assets)
{
Constraints.Add(LinearConstraint.Create(asset, Relational.Smaller, upperlimit));
Constraints.Add(LinearConstraint.Create(asset, Relational.Larger, lowerlimit));
}
}
public void Test_10P1EqualP2()
{
int count = 8;
double[] Ii = { 1, 1, 1, 1, 1, 1, 1, 1 };
double[] w = { 0.2, 0.121, 0.683, 0.04, 0.102, 0.081, 0.02, 0.667 };
double[] d =
{
10.0054919341489,
3.03265795024749,
6.83122010827837,
1.98478460320379,
5.09293357450987,
4.05721328676762,
0.991215230484718,
6.66666666666666
};
double[] b = { 0, 0, 0 };
double[][] A =
{
new double[] { 1, -1, -1, 0, 0, 0, 0, 0 },
new double[] { 0, 0, 1, -1, -1, 0, 0, 0 },
new double[] { 0, 0, 0, 0, 1, -1, -1, 1 }
};
LinearConstraint linear = new LinearConstraint(numberOfVariables: 2)
{
VariablesAtIndices = new int[] { 0, 1 },
CombinedAs = new double[] { 1, -10 },
ShouldBe = ConstraintType.EqualTo,
Value = 0
};
Calculator calculator = new Calculator();
double[] res = calculator.Solving(count, Ii, w, d, b, A, linear);
bool check = true;
for (int i = 0; i < 3; i++)
{
double resultForCheck = 0;
for (int j = 0; j < count; j++)
{
resultForCheck += res[j] * A[i][j];
}
if (Math.Round(resultForCheck) != 0)
{
check = false; break;
}
}
Assert.AreEqual(true, check);
}
public void TestGradientWithIndices()
{
// Arrange1
int[] indices1 = { 2, 4, 6 };
int[] indices2 = { 0, 4, 6 };
double[] combinedAs1 = { 2, 3, 4 };
double[] combinedAs2 = { 9, 5, 1 };
double[] x = Vector.Random(8);
double[] expected1 = { 0, 0, 2, 0, 3, 0, 4, 0 };
double[] expected2 = { 0, 0, 9, 0, 5, 0, 1, 0 };
double[] expected3 = { 9, 0, 0, 0, 5, 0, 1, 0 };
var linearConstraint = new LinearConstraint(indices1.Length)
{
CombinedAs = combinedAs1,
VariablesAtIndices = indices1,
ShouldBe = ConstraintType.EqualTo,
Value = 42
};
// Act1
double[] gradient = linearConstraint.Gradient(x);
// Assert1
Assert.True(gradient.IsEqual(expected1));
// Arrange2
linearConstraint.CombinedAs = combinedAs2;
// Act2
double[] gradient2 = linearConstraint.Gradient(x);
// Assert2
Assert.True(gradient2.IsEqual(expected2));
// Arrange3
linearConstraint.VariablesAtIndices = indices2;
// Act3
double[] gradient3 = linearConstraint.Gradient(x);
// Assert3
Assert.True(gradient3.IsEqual(expected3));
}
public double[] Solve([FromBody] ForSolver data)
{
LinearConstraint linear = null;
if (data.extra != null)
{
linear = new LinearConstraint(numberOfVariables: 2)
{
VariablesAtIndices = new int[] { 0, 1 },
CombinedAs = data.extra,
ShouldBe = ConstraintType.EqualTo,
Value = 0
};
}
Calculator calculator = new Calculator();
double[] res = calculator.Solving(data.count, data.Ii, data.w, data.d, data.b, data.A, linear);
return(res);
}
public void DocumentationTest()
{
#region doc_example
// Linear constraints are common in numerical optimization.
// Constraints can be defined using strings, expressions or
// vectors. Suppose we have a quadratic objective function:
var f = new QuadraticObjectiveFunction("2x² + 4y² - 2xy + 6");
// Then the following three are all equivalent:
var lc1 = new LinearConstraint(f, "3*x + 5*y <= 7");
double x = 0, y = 0; // Define some dummy variables
var lc2 = new LinearConstraint(f, () => 3 * x + 5 * y <= 7);
var lc3 = new LinearConstraint(numberOfVariables: 2)
{
CombinedAs = new double[] { 3, 5 },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = 7
};
// Then, we can check whether a constraint is violated and, if so,
// by how much.
double[] vector = { -2, 3 };
if (lc1.IsViolated(vector))
{
// act on violation...
}
double violation = lc2.GetViolation(vector); // negative if violated
#endregion
double expected = -2;
double v1 = lc1.GetViolation(vector);
double v2 = lc2.GetViolation(vector);
double v3 = lc3.GetViolation(vector);
Assert.AreEqual(expected, v1);
Assert.AreEqual(expected, v2);
Assert.AreEqual(expected, v3);
}
public static Constraint[] GetConstraints(this Solution solution, ExperimentParameters experimentParameters)
{
var numberOfConstraintCoefficients = experimentParameters.NumberOfDimensions + 1;
var numberOfConstraints = experimentParameters.NumberOfConstraints;
var limiter = numberOfConstraintCoefficients * numberOfConstraints;
var constraints = new Constraint[numberOfConstraints];
var j = 0;
for (var i = 0; i < limiter; i += numberOfConstraintCoefficients)
{
var constraintLimitingValue = solution.ObjectCoefficients[i + numberOfConstraintCoefficients - 1];
var constraintCoefficients = new double[numberOfConstraintCoefficients - 1];
Array.Copy(solution.ObjectCoefficients, i, constraintCoefficients, 0, numberOfConstraintCoefficients - 1);
constraints[j++] = new LinearConstraint(constraintCoefficients, constraintLimitingValue);
}
return(constraints);
}
public static IEnumerable <LinearConstraint> GenerateInitialConstraints(Cluster cluster)
{
for (var i = 0; i < cluster.Dimensions; i++)
{
var minConstraint = new LinearConstraint(new Dictionary <int, double>()
{
{ i, 1.0 }
}, cluster.Dimensions, cluster.Minimums[i])
{
Sign = Inequality.GreaterThanOrEqual
};
yield return(minConstraint);
var maxConstraint = new LinearConstraint(new Dictionary <int, double>()
{
{ i, 1.0 }
}, cluster.Dimensions, cluster.Maximums[i]);
yield return(maxConstraint);
}
}
public ConstraintsBuilder(Constraint[] referenceConstraints, ExperimentParameters experimentParameters)
{
var singleReferenceConstraint = referenceConstraints.First();
_constraintsModel = new Constraint[experimentParameters.MaximumNumberOfConstraints];
if (experimentParameters.TypeOfBenchmark == BenchmarkType.Balln && experimentParameters.AllowQuadraticTerms)
{
for (var i = 0; i < _constraintsModel.Length; i++)
{
_constraintsModel[i] = new QuadraticConstraint(singleReferenceConstraint.Terms.DeepCopyByExpressionTree(), 0);
}
}
else
{
var terms = singleReferenceConstraint.Terms.Where(term => term.Type == TermType.Linear).ToArray();
for (var i = 0; i < _constraintsModel.Length; i++)
{
_constraintsModel[i] = new LinearConstraint(terms.DeepCopyByExpressionTree(), 0);
}
}
}
public double[] Solving(int count, double[] Ii, double[] w, double[] d, double[] b, double[][] A, LinearConstraint newConstraints = null)
{
double[,] I = new double[count, count];
double[,] W = new double[count, count];
for (int i = 0; i < w.Length; i++)
{
for (int j = 0; j < w.Length; j++)
{
if (j == i)
{
W[i, j] = 1 / (w[i] * w[i]);
I[i, j] = Ii[i];
}
else
{
W[i, j] = 0;
I[i, j] = 0;
}
}
}
double[,] Q = Accord.Math.Matrix.Dot(W, I);
double[] D = new double[count];
int[] VariablesAtIndices = new int[count];
for (int i = 0; i < count; i++)
{
D[i] = -1 * d[i] * Q[i, i];
VariablesAtIndices[i] = i;
}
List <double[]> combinedAs = new List <double[]>();
for (int i = 0; i < A.Length; i++)
{
double[] a = new double[A[i].Length];
for (int j = 0; j < A[i].Length; j++)
{
a[j] = A[i][j];
}
combinedAs.Add(a);
}
List <LinearConstraint> constraints = new List <LinearConstraint>();
for (int i = 0; i < 3; i++)
{
LinearConstraint linear = new LinearConstraint(numberOfVariables: count)
{
VariablesAtIndices = VariablesAtIndices,
CombinedAs = combinedAs[i],
ShouldBe = ConstraintType.EqualTo,
Value = b[i]
};
constraints.Add(linear);
}
if (newConstraints != null)
{
constraints.Add(newConstraints);
}
var solver = new GoldfarbIdnani(
function: new QuadraticObjectiveFunction(Q, D),
constraints: constraints);
bool success = solver.Minimize();
double[] solution = solver.Solution;
return(solution);
}
/// <summary>
/// Computes the optimization algorithm when the user
/// presses the "Compute" button in the main interface.
/// </summary>
///
private void btnCompute_Click(object sender, EventArgs e)
{
// First, get what the user entered on screen:
String strObjective = tbObjective.Text;
String[] strConstraints = tbConstraints.Lines;
// Check if this is a minimization or maximization task
bool minimize = (string)comboBox1.SelectedItem == "min";
// Now we can start creating our function:
QuadraticObjectiveFunction function;
LinearConstraint[] constraints = new LinearConstraint[strConstraints.Length];
// Attempt to parse the string and create the objective function
if (!QuadraticObjectiveFunction.TryParse(strObjective, out function))
{
tbSolution.Text = "Invalid objective function.";
return;
}
// Create list of constraints
for (int i = 0; i < constraints.Length; i++)
{
if (!LinearConstraint.TryParse(strConstraints[i], function, out constraints[i]))
{
tbSolution.Text = "Invalid constraint at line " + i + ".";
return;
}
}
// After the text has been parsed, create the solver
var solver = new GoldfarbIdnani(function, constraints);
// Solve the optimization problem:
if (minimize)
{
solver.Minimize(); // the user wants to minimize it
}
else
{
solver.Maximize(); // the user wants to maximize it
}
if (solver.Status == GoldfarbIdnaniStatus.NonPositiveDefinite)
{
tbSolution.Text = "Function is not positive definite.";
return;
}
else if (solver.Status == GoldfarbIdnaniStatus.NoPossibleSolution)
{
tbSolution.Text = "No possible solution could be attained.";
return;
}
// Retrieve the computed solution
double[] solution = solver.Solution;
// And let's format and display it:
StringBuilder sb = new StringBuilder();
sb.AppendLine("Solution:");
sb.AppendLine();
sb.AppendLine(" " + strObjective + " = " + solver.Value);
sb.AppendLine();
for (int i = 0; i < solution.Length; i++)
{
string variableName = function.Indices[i];
sb.AppendLine(" " + variableName + " = " + solution[i]);
}
tbSolution.Text = sb.ToString();
}
private void button1_Click(object sender, EventArgs e)
{
String objectiveString = tbObjective.Text;
String[] constraintStrings = tbConstraints.Lines;
bool minimize = (string)comboBox1.SelectedItem == "min";
QuadraticObjectiveFunction function;
LinearConstraint[] constraints = new LinearConstraint[constraintStrings.Length];
try
{
// Create objective function
function = new QuadraticObjectiveFunction(objectiveString);
}
catch (FormatException)
{
tbSolution.Text = "Invalid objective function.";
return;
}
// Create list of constraints
for (int i = 0; i < constraints.Length; i++)
{
try
{
constraints[i] = new LinearConstraint(function, constraintStrings[i]);
}
catch (FormatException)
{
tbSolution.Text = "Invalid constraint at line " + i + ".";
return;
}
}
// Create solver
var solver = new GoldfarbIdnaniQuadraticSolver(function.NumberOfVariables, constraints);
try
{
// Solve the minimization or maximization problem
double value = (minimize) ? solver.Minimize(function) : solver.Maximize(function);
// Grab the solution found
double[] solution = solver.Solution;
// Format and display solution
StringBuilder sb = new StringBuilder();
sb.AppendLine("Solution:");
sb.AppendLine();
sb.AppendLine(" " + objectiveString + " = " + value);
sb.AppendLine();
for (int i = 0; i < solution.Length; i++)
{
string variableName = function.Indices[i];
sb.AppendLine(" " + variableName + " = " + solution[i]);
}
tbSolution.Text = sb.ToString();
}
catch (NonPositiveDefiniteMatrixException)
{
tbSolution.Text = "Function is not positive definite.";
}
catch (ConvergenceException)
{
tbSolution.Text = "No possible solution could be attained.";
}
}
// Unterteilt das jetzige Ergebnic c in Unterzweigen
// Fuer die Variablen, die nicht ganzzahlig sind
private void SolveOne(Node c, CancellationToken cancelToken)
{
if (cancelToken.IsCancellationRequested)
{
IsCompleted = false;
return;
}
if (!c.IsInfeasible)
{
// Falls das jetzige Ergebis schlechter als die Untergrenze,
// dann muss es nicht in Unterzweigen mehr geteilt werden
if (globalLowerBound > c.Upperbound)
{
return;
}
// Falls das Lowerbound des jetizgen Ergebnises besser
// als das Gespeicherte, dann ersetz das Gespeicherte
// durch das Jetzige
if (globalLowerBound < c.Lowerbound)
{
globalLowerBound = c.Lowerbound;
// Und update das jetizge beste Loesung
CurrentSolution = new Dictionary <string, rat>();
foreach (var kvp in c.Answer)
{
CurrentSolution.Add(kvp.Key, kvp.Value.WholePart);
CurrentSolution["P"] = c.Lowerbound;
}
}
// Falls eine ganzzahlige Loesung (alle Variablen ganzzahlig) gefunden
// dann kann man die ganze Suchreihe loeschen
// denn dort wird die Ergebnis nach Upperbound sortiert
// d.h. dieses Ergebnis 'c' hat den hoechstwahrscheinlichen Wert
// innerhalb aller Moeglichkeiten
if (c.Lowerbound.Equal(c.Upperbound))
{
toSearch.Clear();
// Die endgueltige Loesung
BestSolution = new Dictionary <string, rat>();
foreach (var kvp in c.Answer)
{
BestSolution.Add(kvp.Key, kvp.Value.CanonicalForm);
}
return;
}
// Falls das jetizge Ergebnis nicht-ganzzahlige Variablen enthaelt
// werden jede nicht-ganzzahlige Variable in zwei Zweigen unterteilt
// naemlich x_i = 0 oder x_i = 1
foreach (var pair in c.Answer)
{
// der Zielwert 'P' kann uebersprungen werden
if (pair.Key.Equals(objective.LHSVariableNames[0]))
{
continue;
}
if (!(pair.Value.FractionPart == 0))
{
LinearConstraint zero = new LinearConstraint(new string[] { pair.Key }, new rat[] { 1 }, 0, LinearConstraint.InequalityType.SmallerOrEqualTo);
toSearch.Add(new Node(c.Tableau, zero, objective, cancelToken));
LinearConstraint one = new LinearConstraint(new string[] { pair.Key }, new rat[] { -1 }, -1, LinearConstraint.InequalityType.SmallerOrEqualTo);
toSearch.Add(new Node(c.Tableau, one, objective, cancelToken));
}
}
}
}
public void AddBoxConstraint(string asset, double lowerlimit, double upperlimit)
{
// check if asset in portfolio
Constraints.Add(LinearConstraint.Create(asset, Relational.Smaller, upperlimit));
Constraints.Add(LinearConstraint.Create(asset, Relational.Larger, lowerlimit));
}
public void AddGroupConstraints(HashSet <string> assets, double lowerlimit, double upperlimit)
{
Constraints.Add(LinearConstraint.Create(assets, Relational.Smaller, upperlimit));
Constraints.Add(LinearConstraint.Create(assets, Relational.Larger, lowerlimit));
}
private double ConstraintFunctionValue(LinearConstraint constraint, double x) => (-constraint[XIndex] * x + constraint.AbsoluteTerm) / constraint[YIndex];
