public void QuadraticConstructorTest()
{
double[,] quadraticTerms =
{
{ 1, 2, 3 },
{ 2, 5, 6 },
{ 3, 6, 9 },
};
double[] linearTerms = { 1, 2, 3 };
var target = new QuadraticObjectiveFunction(quadraticTerms, linearTerms);
var function = target.Function;
var gradient = target.Gradient;
FiniteDifferences fd = new FiniteDifferences(3, function);
double[][] x =
{
new double[] { 1, 2, 3 },
new double[] { 3, 1, 4 },
new double[] { -6 , 5, 9 },
new double[] { 31, 25, 246 },
new double[] { -0.102, 0, 10 },
};
{ // Function test
for (int i = 0; i < x.Length; i++)
{
double expected = 0.5 *
(x[i].Multiply(quadraticTerms)).InnerProduct(x[i])
+ linearTerms.InnerProduct(x[i]);
double actual = function(x[i]);
Assert.AreEqual(expected, actual, 1e-8);
}
}
{ // Gradient test
for (int i = 0; i < x.Length; i++)
{
double[] expected = fd.Compute(x[i]);
double[] actual = gradient(x[i]);
for (int j = 0; j < actual.Length; j++)
Assert.AreEqual(expected[j], actual[j], 1e-8);
}
}
}
public void ConstructorTest1()
{
var f = new QuadraticObjectiveFunction("a + b = 0");
var constraints1 = new[]
{
new LinearConstraint(f, "0.0732 * a + 0.0799 * b = 0.098"),
new LinearConstraint(f, "a + b = 1"),
new LinearConstraint(f, "a >= 0"),
new LinearConstraint(f, "b >= 0"),
new LinearConstraint(f, "a >= 0.5")
};
var constraints2 = new[]
{
new LinearConstraint(f, "0.0732 * a + 0.0799 * b - 0.098 = 0"),
new LinearConstraint(f, "a + b -2 = -1"),
new LinearConstraint(f, "-a <= 0"),
new LinearConstraint(f, "-b <= 0"),
new LinearConstraint(f, "-a + 0.5 <= 0")
};
for (int i = 0; i < constraints1.Length; i++)
{
var c1 = constraints1[i];
var c2 = constraints2[i];
for (double a = -10; a < 10; a += 0.1)
{
for (double b = -10; b < 10; b += 0.1)
{
double[] x = { a, b };
double actual = c1.GetViolation(x);
double expected = c2.GetViolation(x);
Assert.AreEqual(expected, actual);
}
}
}
}
/// <summary>
/// Constructs a new instance of the <see cref="GoldfarbIdnani"/> class.
/// </summary>
///
/// <param name="function">The objective function to be optimized.</param>
/// <param name="constraintMatrix">The constraints matrix <c>A</c>.</param>
/// <param name="constraintValues">The constraints values <c>b</c>.</param>
/// <param name="numberOfEqualities">The number of equalities in the constraints.</param>
///
public GoldfarbIdnani(QuadraticObjectiveFunction function, double[,] constraintMatrix,
double[] constraintValues, int numberOfEqualities = 0)
: base(function.NumberOfVariables, function.Function, function.Gradient)
{
if (function.NumberOfVariables != constraintMatrix.GetLength(1))
{
throw new ArgumentException("The number of columns in the constraint matrix A "
+ "should equal the number of variables in the problem.", "constraintMatrix");
}
if (constraintValues.Length != constraintMatrix.GetLength(0))
{
throw new DimensionMismatchException("constraintValues");
}
if (numberOfEqualities < 0 || numberOfEqualities > constraintValues.Length)
{
throw new ArgumentOutOfRangeException("numberOfEqualities");
}
initialize(function.NumberOfVariables, function.QuadraticTerms,
function.LinearTerms, constraintMatrix, constraintValues, numberOfEqualities);
}
/// <summary>
/// Attempts to create a <see cref="QuadraticObjectiveFunction"/>
/// from a <see cref="System.String"/> representation.
/// </summary>
///
/// <param name="str">The string containing the function in textual form.</param>
/// <param name="function">The resulting function, if it could be parsed.</param>
///
/// <returns><c>true</c> if the function could be parsed
/// from the string, <c>false</c> otherwise.</returns>
///
public static bool TryParse(string str, out QuadraticObjectiveFunction function)
{
return TryParse(str, CultureInfo.InvariantCulture, out function);
}
public void GoldfarbIdnaniMinimizeTest1()
{
// This test reproduces Issue #33 at Google Code Tracker
// https://code.google.com/p/accord/issues/detail?id=33
// Create objective function using the
// Hessian Q and linear terms vector d.
double[,] Q =
{
{ 0.12264004, 0.011579293, 0.103326825, 0.064073439 },
{ 0.011579293, 0.033856, 0.014311947, 0.014732381 },
{ 0.103326825, 0.014311947, 0.17715681, 0.067615114 },
{ 0.064073439, 0.014732381, 0.067615114, 0.11539609 }
};
Assert.IsTrue(Q.IsPositiveDefinite());
double[] d = { 0, 0, 0, 0 };
var f = new QuadraticObjectiveFunction(Q, d, "a", "b", "c", "d");
// Now, create the constraints
var constraints = new LinearConstraintCollection();
constraints.Add(new LinearConstraint(f, "0.0732 * a + 0.0799 * b + 0.1926 * c + 0.0047 * d = 0.098"));
constraints.Add(new LinearConstraint(f, "a + b + c + d = 1"));
constraints.Add(new LinearConstraint(f, "a >= 0"));
constraints.Add(new LinearConstraint(f, "b >= 0"));
constraints.Add(new LinearConstraint(f, "c >= 0"));
constraints.Add(new LinearConstraint(f, "d >= 0"));
constraints.Add(new LinearConstraint(f, "a >= 0.5"));
double[] b;
int eq;
double[,] A = constraints.CreateMatrix(4, out b, out eq);
// Now we create the quadratic programming solver for 2 variables, using the constraints.
GoldfarbIdnaniQuadraticSolver solver = new GoldfarbIdnaniQuadraticSolver(4, constraints);
// And attempt to solve it.
double minValue = solver.Minimize(f);
double[] expected = { 0.5, 0.336259542, 0.163740458, 0 };
double[] actual = solver.Solution;
for (int i = 0; i < expected.Length; i++)
{
double e = expected[i];
double a = actual[i];
Assert.AreEqual(e, a);
}
}
public void GoldfarbIdnaniConstructorTest9()
{
// Solve the following optimization problem:
//
// min f(x) = 2x² + xy + y² - 5y
//
// s.t. -x - 3y >= -2
// -x - y >= 0
// x >= 0
// y >= 0
//
double x = 0, y = 0;
var f = new QuadraticObjectiveFunction(() => 2 * (x * x) + (x * y) + (y * y) - 5 * y);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => -x - 3 * y >= -2));
constraints.Add(new LinearConstraint(f, () => -x - y >= 0));
constraints.Add(new LinearConstraint(f, () => x >= 0));
constraints.Add(new LinearConstraint(f, () => y >= 0));
GoldfarbIdnaniQuadraticSolver target = new GoldfarbIdnaniQuadraticSolver(2, constraints);
double[,] expectedA =
{
{ -1, -3 },
{ -1, -1 },
{ 1, 0 },
{ 0, 1 },
};
double[] expectedb =
{
-2, 0, 0, 0
};
double[,] expectedQ =
{
{ 4, 1 },
{ 1, 2 },
};
double[] expectedd =
{
0, -5
};
// Tested against R's QuadProg package
/*
Qmat = matrix(c(4,1,1,2),2,2)
dvec = -c(0, -5)
Amat = matrix(c(-1, -3, -1, -1, 1, 0, 0, 1), 2,4)
bvec = c(-2, 0, 0, 0)
solve.QP(Qmat, dvec, Amat, bvec)
*/
var actualA = target.ConstraintMatrix;
var actualb = target.ConstraintValues;
var actualQ = f.GetQuadraticTermsMatrix();
var actuald = f.GetLinearTermsVector();
Assert.IsTrue(expectedA.IsEqual(actualA));
Assert.IsTrue(expectedb.IsEqual(actualb));
Assert.IsTrue(expectedQ.IsEqual(actualQ));
Assert.IsTrue(expectedd.IsEqual(actuald));
double min = target.Minimize(f);
double[] solution = target.Solution;
Assert.AreEqual(0, solution[0], 1e-10);
Assert.AreEqual(0, solution[1], 1e-10);
Assert.AreEqual(0.0, min, 1e-10);
Assert.AreEqual(0, target.Lagrangian[0], 1e-10);
Assert.AreEqual(5, target.Lagrangian[1], 1e-10);
Assert.AreEqual(5, target.Lagrangian[2], 1e-10);
Assert.AreEqual(0, target.Lagrangian[3], 1e-10);
Assert.IsFalse(Double.IsNaN(min));
foreach (double v in target.Solution)
Assert.IsFalse(double.IsNaN(v));
foreach (double v in target.Lagrangian)
Assert.IsFalse(double.IsNaN(v));
}
public void GoldfarbIdnaniConstructorTest7()
{
// Solve the following optimization problem:
//
// min f(x) = 3x² + 2xy + 3y² - y
//
// s.t. x >= 1
// y >= 1
//
double x = 0, y = 0;
// http://www.wolframalpha.com/input/?i=min+x%C2%B2+%2B+2xy+%2B+y%C2%B2+-+y%2C+x+%3E%3D+1%2C+y+%3E%3D+1
var f = new QuadraticObjectiveFunction(() => 3 * (x * x) + 2 * (x * y) + 3 * (y * y) - y);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x >= 1));
constraints.Add(new LinearConstraint(f, () => y >= 1));
GoldfarbIdnaniQuadraticSolver target = new GoldfarbIdnaniQuadraticSolver(2, constraints);
double[,] A =
{
{ 1, 0 },
{ 0, 1 },
};
double[] b =
{
1,
1,
};
Assert.IsTrue(A.IsEqual(target.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(target.ConstraintValues));
double[,] Q =
{
{ 6, 2 },
{ 2, 6 },
};
double[] d = { 0, -1 };
var actualQ = f.GetQuadraticTermsMatrix();
var actuald = f.GetLinearTermsVector();
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
double minValue = target.Minimize(f);
double[] solution = target.Solution;
Assert.AreEqual(7, minValue);
Assert.AreEqual(1, solution[0]);
Assert.AreEqual(1, solution[1]);
Assert.AreEqual(8, target.Lagrangian[0], 1e-5);
Assert.AreEqual(7, target.Lagrangian[1], 1e-5);
foreach (double v in target.Solution)
Assert.IsFalse(double.IsNaN(v));
foreach (double v in target.Lagrangian)
Assert.IsFalse(double.IsNaN(v));
}
public void GoldfarbIdnaniConstructorTest4()
{
// Solve the following optimization problem:
//
// min f(x) = 2x² - xy + 4y² - 5x - 6y
//
// s.t. x - y == 5 (x minus y should be equal to 5)
// x >= 10 (x should be greater than or equal to 10)
//
var f = new QuadraticObjectiveFunction("2x² - xy + 4y² - 5x - 6y");
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, "x-y = 5"));
constraints.Add(new LinearConstraint(f, "x >= 10"));
GoldfarbIdnaniQuadraticSolver target = new GoldfarbIdnaniQuadraticSolver(2, constraints);
double[,] A =
{
{ 1, -1 },
{ 1, 0 },
};
double[] b =
{
5,
10,
};
Assert.IsTrue(A.IsEqual(target.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(target.ConstraintValues));
double[,] Q =
{
{ +2*2, -1 },
{ -1, +4*2 },
};
double[] d = { -5, -6 };
var actualQ = f.GetQuadraticTermsMatrix();
var actuald = f.GetLinearTermsVector();
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
}
public void HomogeneousTest2()
{
double[,] quadraticTerms =
{
{ 1, 0, 1 },
{ 0, 2, 0 },
{ 1, 0, 1 },
};
double[] linearTerms = { 0, 0, 0 };
var target = new QuadraticObjectiveFunction(quadraticTerms, linearTerms);
var function = target.Function;
var gradient = target.Gradient;
FiniteDifferences fd = new FiniteDifferences(3, function);
double[][] x =
{
new double[] { 1, 2, 3 },
new double[] { 3, 1, 4 },
new double[] { -6 , 5, 9 },
new double[] { 31, 25, 246 },
new double[] { -0.102, 0, 10 },
};
{ // Gradient test
for (int i = 0; i < x.Length; i++)
{
double[] expected = fd.Compute(x[i]);
double[] actual = gradient(x[i]);
for (int j = 0; j < actual.Length; j++)
Assert.AreEqual(expected[j], actual[j], 1e-8);
}
}
}
public void GoldfarbIdnaniParseGlobalizationTest2()
{
String strObjective = 0.5.ToString(CultureInfo.InvariantCulture)
+ "x² +" + 0.2.ToString(CultureInfo.InvariantCulture) + "y² +"
+ 0.3.ToString(CultureInfo.InvariantCulture) + "xy";
String[] strConstraints =
{
0.01.ToString(CultureInfo.InvariantCulture) + "x" + " + " +
0.02.ToString(CultureInfo.InvariantCulture) + "y - " +
0.03.ToString(CultureInfo.InvariantCulture) + " = 0",
"x + y = 100"
};
QuadraticObjectiveFunction function = new QuadraticObjectiveFunction(strObjective);
LinearConstraintCollection cst = new LinearConstraintCollection();
foreach (var tmpCst in strConstraints)
cst.Add(new LinearConstraint(function, tmpCst));
var classSolver = new Accord.Math.Optimization.GoldfarbIdnani(function, cst);
bool status = classSolver.Minimize();
double result = classSolver.Value;
Assert.IsTrue(status);
Assert.AreEqual(15553.60, result, 1e-10);
}
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.";
}
}
/// <summary>
/// Attempts to create a <see cref="QuadraticObjectiveFunction"/>
/// from a <see cref="System.String"/> representation.
/// </summary>
///
/// <param name="str">The string containing the function in textual form.</param>
/// <param name="function">The resulting function, if it could be parsed.</param>
/// <param name="culture">The culture information specifying how
/// numbers written in the <paramref name="function"/> should
/// be parsed. Default is CultureInfo.InvariantCulture.</param>
///
/// <returns><c>true</c> if the function could be parsed
/// from the string, <c>false</c> otherwise.</returns>
///
public static bool TryParse(string str, System.Globalization.CultureInfo culture, out QuadraticObjectiveFunction function)
{
// TODO: implement this method without the try-catch block.
try
{
function = new QuadraticObjectiveFunction(str, culture);
}
catch (FormatException)
{
function = null;
return(false);
}
return(true);
}
/// <summary>
/// Maximizes the function.
/// </summary>
///
/// <param name="function">The function to be maximized.</param>
/// <returns>The maximum value at the solution found.</returns>
///
public double Maximize(QuadraticObjectiveFunction function)
{
if (function == null)
throw new ArgumentNullException("function");
return Maximize(function.GetQuadraticTermsMatrix(), function.GetLinearTermsVector());
}
public void ConstructorTest2()
{
double a = 0, b = 0;
var f = new QuadraticObjectiveFunction(() => a + b);
Assert.AreEqual(2, f.NumberOfVariables);
Assert.AreEqual(0, f.Variables["a"]);
Assert.AreEqual(1, f.Variables["b"]);
Assert.AreEqual(1, f.LinearTerms[0]);
Assert.AreEqual(1, f.LinearTerms[1]);
var constraints1 = new[]
{
new LinearConstraint(f, () => 0.0732 * a + 0.0799 * b == 0.098),
new LinearConstraint(f, () => a + b == 1),
new LinearConstraint(f, () => a >= 0),
new LinearConstraint(f, () => b >= 0),
new LinearConstraint(f, () => a >= 0.5),
new LinearConstraint(f, () => 1 + a >= -5),
new LinearConstraint(f, () => -1 + a <= -5)
};
var constraints2 = new[]
{
new LinearConstraint(f, () => 0.0732 * a + 0.0799 * b - 0.098 == 0),
new LinearConstraint(f, () => a + b -2 == -1),
new LinearConstraint(f, () => -a + 1 <= +1),
new LinearConstraint(f, () => -b <= 0),
new LinearConstraint(f, () => -a + 0.5 <= 0),
new LinearConstraint(f, () => a + 1 >= -5),
new LinearConstraint(f, () => a - 1 <= -5)
};
Assert.AreEqual(0.098, constraints1[0].Value);
Assert.AreEqual(0.098, constraints2[0].Value);
Assert.AreEqual(0, constraints1[2].Value);
Assert.AreEqual(0, constraints2[2].Value);
Assert.AreEqual(1, constraints1[1].Value);
Assert.AreEqual(1, constraints2[1].Value);
for (int i = 0; i < constraints1.Length; i++)
{
var c1 = constraints1[i];
var c2 = constraints2[i];
for (a = -10; a < 10; a += 0.1)
{
for (b = -10; b < 10; b += 0.1)
{
double[] x = { a, b };
double actual = c1.GetViolation(x);
double expected = c2.GetViolation(x);
Assert.AreEqual(expected, actual);
}
}
}
}
public void FunctionTest5()
{
var f1 = new QuadraticObjectiveFunction("x² + 1");
var f2 = new QuadraticObjectiveFunction("-x*y + y*z");
var f3 = new QuadraticObjectiveFunction("-2x² + xy - y² - 10xz + z²");
var f4 = new QuadraticObjectiveFunction("-2x² + xy - y² + 5y");
var f5 = new QuadraticObjectiveFunction("2x² -5");
double x = 0, y = 0, z = 0;
var g1 = new QuadraticObjectiveFunction(() => x * x + 1);
var g2 = new QuadraticObjectiveFunction(() => -x * y + y * z);
var g3 = new QuadraticObjectiveFunction(() => -2 * x * x + x * y - y * y - 10 * x * z + z * z);
var g4 = new QuadraticObjectiveFunction(() => -2 * x * x + x * y - y * y + 5 * y);
var g5 = new QuadraticObjectiveFunction(() => 2 * x * x - 5);
QuadraticObjectiveFunction[] f = { f1, f2, f3, f4, f5 };
QuadraticObjectiveFunction[] g = { g1, g2, g3, g4, g5 };
for (int l = 0; l < f.Length; l++)
{
var fl = f[l];
var gl = g[l];
Assert.AreEqual(fl.NumberOfVariables, gl.NumberOfVariables);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
for (int k = 0; k < 10; k++)
{
x = (i - 5) / 10.0;
y = (j - 5) / 10.0;
z = (k - 5) / 10.0;
double a = fl.Function(new[] { x, y, z }.First(fl.NumberOfVariables));
double e = gl.Function(new[] { x, y, z }.First(fl.NumberOfVariables));
Assert.AreEqual(e, a, 1e-10);
Assert.IsFalse(Double.IsNaN(a));
Assert.IsFalse(Double.IsNaN(e));
}
}
}
}
}
/// <summary>
/// Constructs a new <see cref="GoldfarbIdnani"/> class.
/// </summary>
///
/// <param name="function">The objective function to be optimized.</param>
/// <param name="constraints">The problem's constraints.</param>
///
public GoldfarbIdnani(QuadraticObjectiveFunction function, IEnumerable <LinearConstraint> constraints)
: this(function, new LinearConstraintCollection(constraints))
{
}
public void LambdaFunctionTest4()
{
double x = 0;
double y = 0;
double z = 0;
Func<double> expected = () => -x * y + y * z;
var actual = new QuadraticObjectiveFunction(() => -x * y + y * z);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
for (int k = 0; k < 10; k++)
{
x = (i - 5) / 10.0;
y = (j - 5) / 10.0;
z = (k - 5) / 10.0;
double a = actual.Function(new[] { x, y, z });
double e = expected();
Assert.AreEqual(e, a, 1e-10);
Assert.IsFalse(Double.IsNaN(a));
Assert.IsFalse(Double.IsNaN(e));
}
}
}
}
public void GoldfarbIdnaniParseTest()
{
var s = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
String strObjective = "0" + s + "5x² + 0" + s + "2y² + 0" + s + "3xy";
String[] strConstraints =
{
"0" + s + "01x + 0" + s + "02y - 0" + s + "03 = 0",
"x + y = 100"
};
// Now we can start creating our function:
QuadraticObjectiveFunction function = new QuadraticObjectiveFunction(strObjective, CultureInfo.CurrentCulture);
LinearConstraintCollection cst = new LinearConstraintCollection();
foreach (var tmpCst in strConstraints)
cst.Add(new LinearConstraint(function, tmpCst, CultureInfo.CurrentCulture));
var classSolver = new Accord.Math.Optimization.GoldfarbIdnani(function, cst);
bool status = classSolver.Minimize();
double result = classSolver.Value;
Assert.IsTrue(status);
Assert.AreEqual(15553.60, result, 1e-10);
}
public void FunctionTest()
{
double x = 0;
double y = 0;
Func<double> expected = () => -2 * x * x + x * y - y * y + 5 * y;
var actual = new QuadraticObjectiveFunction("-2x² + xy - y² + 5y");
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
x = (i - 5) / 10.0;
y = (j - 5) / 10.0;
double a = actual.Function(new[] { x, y });
double e = expected();
Assert.AreEqual(e, a, 1e-10);
Assert.IsFalse(Double.IsNaN(a));
Assert.IsFalse(Double.IsNaN(e));
}
}
}
public void GoldfarbIdnaniMinimizeLessThanWithEqualityTest()
{
// This test reproduces Issue #33 at Google Code Tracker
// https://code.google.com/p/accord/issues/detail?id=33
// Create objective function using the
// Hessian Q and linear terms vector d.
double[,] Q =
{
{ 0.12264004, 0.011579293, 0.103326825, 0.064073439 },
{ 0.011579293, 0.033856, 0.014311947, 0.014732381 },
{ 0.103326825, 0.014311947, 0.17715681, 0.067615114 },
{ 0.064073439, 0.014732381, 0.067615114, 0.11539609 }
};
Assert.IsTrue(Q.IsPositiveDefinite());
double[] d = { 0, 0, 0, 0 };
var f = new QuadraticObjectiveFunction(Q, d, "a", "b", "c", "d");
// Now, create the constraints
var constraints = new LinearConstraintCollection();
constraints.Add(new LinearConstraint(f, "0.0732 * a + 0.0799 * b + 0.1926 * c + 0.0047 * d = 0.098"));
constraints.Add(new LinearConstraint(f, "a + b + c + d = 1"));
constraints.Add(new LinearConstraint(f, "-a <= 0"));
constraints.Add(new LinearConstraint(f, "-b <= 0"));
constraints.Add(new LinearConstraint(f, "-c <= 0"));
constraints.Add(new LinearConstraint(f, "-d <= 0"));
constraints.Add(new LinearConstraint(f, "-a + 0.5 <= 0.0"));
Assert.AreEqual(-1, constraints[6].CombinedAs[0]);
Assert.AreEqual(-0.5, constraints[6].Value);
Assert.AreEqual(0.1, constraints[6].GetViolation(new double[] { 0.6 }), 1e-10);
Assert.AreEqual(-0.1, constraints[6].GetViolation(new double[] { 0.4 }), 1e-10);
bool psd = Q.IsPositiveDefinite();
double[] b;
int eq;
double[,] A = constraints.CreateMatrix(4, out b, out eq);
// Now we create the quadratic programming solver for 2 variables, using the constraints.
GoldfarbIdnani solver = new GoldfarbIdnani(f, constraints);
// And attempt to solve it.
Assert.IsTrue(solver.Minimize());
double minValue = solver.Value;
double[] expected = { 0.50000000000000, 0.30967169476486, 0.19032830523514, 0 };
double[] actual = solver.Solution;
for (int i = 0; i < constraints.Count; i++)
{
double error = constraints[i].GetViolation(actual);
Assert.IsTrue(error >= 0);
}
for (int i = 0; i < expected.Length; i++)
{
double e = expected[i];
double a = actual[i];
Assert.AreEqual(e, a, 1e-10);
}
}
public void GoldfarbIdnaniConstructorTest3()
{
// Solve the following optimization problem:
//
// min f(x) = 2x² - xy + 4y² - 5x - 6y
//
// s.t. x - y == 5 (x minus y should be equal to 5)
// x >= 10 (x should be greater than or equal to 10)
//
// In this example we will be using some symbolic processing.
// The following variables could be initialized to any value.
double x = 0, y = 0;
// Create our objective function using a lambda expression
var f = new QuadraticObjectiveFunction(() => 2 * (x * x) - (x * y) + 4 * (y * y) - 5 * x - 6 * y);
// Now, create the constraints
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x - y == 5));
constraints.Add(new LinearConstraint(f, () => x >= 10));
// Now we create the quadratic programming solver for 2 variables, using the constraints.
GoldfarbIdnaniQuadraticSolver solver = new GoldfarbIdnaniQuadraticSolver(2, constraints);
double[,] A =
{
{ 1, -1 },
{ 1, 0 },
};
double[] b =
{
5,
10,
};
Assert.IsTrue(A.IsEqual(solver.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(solver.ConstraintValues));
double[,] Q =
{
{ +2*2, -1 },
{ -1, +4*2 },
};
double[] d = { -5, -6 };
var actualQ = f.GetQuadraticTermsMatrix();
var actuald = f.GetLinearTermsVector();
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
// And attempt to solve it.
double minimumValue = solver.Minimize(f);
}
public void GoldfarbIdnaniConstructorTest1()
{
double[,] D = Matrix.Identity(3);
double[] d = { 0, 5, 0 };
double[,] A =
{
{ -4, -3, 0 },
{ 2, 1, 0 },
{ 0, -2, 1 },
};
double[] b = { -8, 2, 0 };
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(-4, -3, +0) { Value = -8 });
constraints.Add(new LinearConstraint(+2, +1, +0) { Value = +2 });
constraints.Add(new LinearConstraint(+0, -2, +1) { Value = +0 });
QuadraticObjectiveFunction f = new QuadraticObjectiveFunction("2x² + y - z + 2");
GoldfarbIdnani target = new GoldfarbIdnani(f, constraints);
Assert.IsTrue(A.IsEqual(target.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(target.ConstraintValues));
}
public void GoldfarbIdnaniConstructorTest6()
{
// min 1x² - 2xy + 3y² +z² - 4x - 5y -z, 6x-7y <= 8, 9x + 1y <= 11, 9x-y <= 11, -z-y = 12
// http://www.wolframalpha.com/input/?i=min+1x%C2%B2+-+2xy+%2B+3y%C2%B2+%2Bz%C2%B2+-+4x+-+5y+-z%2C+6x-7y+%3C%3D+8%2C+9x+%2B+1y+%3C%3D+11%2C+9x-y+%3C%3D+11%2C+-z-y+%3D+12
var f = new QuadraticObjectiveFunction("1x² - 2xy + 3y² + z² - 4x - 5y -z");
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, "6x-7y <= 8"));
constraints.Add(new LinearConstraint(f, "9x + 1y <= 11"));
constraints.Add(new LinearConstraint(f, "9x-y <= 11"));
constraints.Add(new LinearConstraint(f, "-z-y = 12"));
GoldfarbIdnaniQuadraticSolver target = new GoldfarbIdnaniQuadraticSolver(f.NumberOfVariables, constraints);
double value = target.Minimize(f);
Assert.AreEqual(14376 / 109.0, value, 1e-10);
Assert.AreEqual(-186 / 109.0, target.Solution[0], 1e-10);
Assert.AreEqual(-284 / 109.0, target.Solution[1], 1e-10);
Assert.AreEqual(-1024 / 109.0, target.Solution[2], 1e-10);
foreach (double v in target.Solution)
Assert.IsFalse(double.IsNaN(v));
}
public void GoldfarbIdnaniConstructorTest3()
{
// http://www.wolframalpha.com/input/?i=min+2x%C2%B2+-+xy+%2B+4y%C2%B2+-+5x+-+6y+s.t.+x+-+y++%3D%3D+++5%2C+x++%3E%3D++10
// Solve the following optimization problem:
//
// min f(x) = 2x² - xy + 4y² - 5x - 6y
//
// s.t. x - y == 5 (x minus y should be equal to 5)
// x >= 10 (x should be greater than or equal to 10)
//
// In this example we will be using some symbolic processing.
// The following variables could be initialized to any value.
double x = 0, y = 0;
// Create our objective function using a lambda expression
var f = new QuadraticObjectiveFunction(() => 2 * (x * x) - (x * y) + 4 * (y * y) - 5 * x - 6 * y);
// Now, create the constraints
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x - y == 5));
constraints.Add(new LinearConstraint(f, () => x >= 10));
// Now we create the quadratic programming solver for 2 variables, using the constraints.
GoldfarbIdnani solver = new GoldfarbIdnani(f, constraints);
double[,] A =
{
{ 1, -1 },
{ 1, 0 },
};
double[] b =
{
5,
10,
};
Assert.IsTrue(A.IsEqual(solver.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(solver.ConstraintValues));
double[,] Q =
{
{ +2*2, -1 },
{ -1, +4*2 },
};
double[] d = { -5, -6 };
var actualQ = f.QuadraticTerms;
var actuald = f.LinearTerms;
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
// And attempt to solve it.
bool success = solver.Minimize();
Assert.AreEqual(170, solver.Value);
Assert.IsTrue(success);
}
public void GoldfarbIdnaniConstructorTest8()
{
// Solve the following optimization problem:
//
// min f(x) = x² + 2xy + y² - y
//
// s.t. x >= 1
// y >= 1
//
double x = 0, y = 0;
// http://www.wolframalpha.com/input/?i=min+x%C2%B2+%2B+2xy+%2B+y%C2%B2+-+y%2C+x+%3E%3D+1%2C+y+%3E%3D+1
var f = new QuadraticObjectiveFunction(() => (x * x) + 2 * (x * y) + (y * y) - y);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x >= 1));
constraints.Add(new LinearConstraint(f, () => y >= 1));
GoldfarbIdnaniQuadraticSolver target = new GoldfarbIdnaniQuadraticSolver(2, constraints);
double[,] A =
{
{ 1, 0 },
{ 0, 1 },
};
double[] b =
{
1,
1,
};
Assert.IsTrue(A.IsEqual(target.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(target.ConstraintValues));
double[,] Q =
{
{ 2, 2 },
{ 2, 2 },
};
double[] d = { 0, -1 };
var actualQ = f.GetQuadraticTermsMatrix();
var actuald = f.GetLinearTermsVector();
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
bool thrown = false;
try
{
target.Minimize(f);
}
catch (NonPositiveDefiniteMatrixException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
public void GoldfarbIdnaniConstructorTest11()
{
// http://www.wolframalpha.com/input/?i=minimize+f%28x%2Cy%29+%3D+2x%5E2+-+xy+%2B+4y%5E2+-+5x+-+6y+-+100%2C+s.t.+x+-+y++%3D+++5%2C+x++%3E%3D++10
double x = 0, y = 0;
var f = new QuadraticObjectiveFunction(() => 2 * (x * x) - (x * y) + 4 * (y * y) - 5 * x - 6 * y + 100);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x - y == 5));
constraints.Add(new LinearConstraint(f, () => x >= 10));
GoldfarbIdnani solver = new GoldfarbIdnani(f, constraints);
double[,] Q =
{
{ +2*2, -1 },
{ -1, +4*2 },
};
double[] d = { -5, -6 };
var actualQ = f.QuadraticTerms;
var actuald = f.LinearTerms;
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
Assert.AreEqual(100, f.ConstantTerm);
bool success = solver.Minimize();
Assert.AreEqual(270, solver.Value);
Assert.IsTrue(success);
}
public void GoldfarbIdnaniMaximizeTest1()
{
// Solve the following optimization problem:
//
// max f(x) = -2x² + xy - y² + 5y
//
// s.t. x + y <= 0
// y >= 0
//
// Create our objective function using a text string
var f = new QuadraticObjectiveFunction("-2x² + xy - y² + 5y");
// Now, create the constraints
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, "x + y <= 0"));
constraints.Add(new LinearConstraint(f, " y >= 0"));
// Now we create the quadratic programming solver for 2 variables, using the constraints.
GoldfarbIdnaniQuadraticSolver solver = new GoldfarbIdnaniQuadraticSolver(2, constraints);
// And attempt to solve it.
double maxValue = solver.Maximize(f);
Assert.AreEqual(25 / 16.0, maxValue);
Assert.AreEqual(-5 / 8.0, solver.Solution[0]);
Assert.AreEqual(5 / 8.0, solver.Solution[1]);
}
public void GoldfarbIdnaniConstructorTest5()
{
// min 1x² - 2xy + 3y² +z² - 4x - 5y -z, 6x-7y <= 8, 9x + 1y <= 11, 9x-y <= 11, -z-y = 12
// http://www.wolframalpha.com/input/?i=min+1x%C2%B2+-+2xy+%2B+3y%C2%B2+%2Bz%C2%B2+-+4x+-+5y+-z%2C+6x-7y+%3C%3D+8%2C+9x+%2B+1y+%3C%3D+11%2C+9x-y+%3C%3D+11%2C+-z-y+%3D+12
double x = 0, y = 0, z = 0;
var f = new QuadraticObjectiveFunction(() => x * x - 2 * x * y + 3 * y * y + z * z - 4 * x - 5 * y - z);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => 6 * x - 7 * y <= 8));
constraints.Add(new LinearConstraint(f, () => 9 * x + 1 * y <= 11));
constraints.Add(new LinearConstraint(f, () => 9 * x - y <= 11));
constraints.Add(new LinearConstraint(f, () => -z - y == 12));
GoldfarbIdnani target = new GoldfarbIdnani(f, constraints);
bool success = target.Minimize();
double value = target.Value;
Assert.IsTrue(success);
Assert.AreEqual(14376 / 109.0, value, 1e-10);
Assert.AreEqual(-186 / 109.0, target.Solution[0], 1e-10);
Assert.AreEqual(-284 / 109.0, target.Solution[1], 1e-10);
Assert.AreEqual(-1024 / 109.0, target.Solution[2], 1e-10);
foreach (double v in target.Solution)
Assert.IsFalse(double.IsNaN(v));
}
/// <summary>
/// Minimizes the function.
/// </summary>
///
/// <param name="function">The function to be minimized.</param>
/// <returns>The minimum value at the solution found.</returns>
///
public double Minimize(QuadraticObjectiveFunction function)
{
if (function == null)
throw new ArgumentNullException("function");
double[,] Q = function.GetQuadraticTermsMatrix();
double[] d = function.GetLinearTermsVector();
return Minimize(Q, d);
}
public void GoldfarbIdnaniConstructorTest8()
{
// Solve the following optimization problem:
//
// min f(x) = x² + 2xy + y² - y
//
// s.t. x >= 1
// y >= 1
//
double x = 0, y = 0;
// http://www.wolframalpha.com/input/?i=min+x%C2%B2+%2B+2xy+%2B+y%C2%B2+-+y%2C+x+%3E%3D+1%2C+y+%3E%3D+1
var f = new QuadraticObjectiveFunction(() => (x * x) + 2 * (x * y) + (y * y) - y);
List<LinearConstraint> constraints = new List<LinearConstraint>();
constraints.Add(new LinearConstraint(f, () => x >= 1));
constraints.Add(new LinearConstraint(f, () => y >= 1));
GoldfarbIdnani target = new GoldfarbIdnani(f, constraints);
double[,] A =
{
{ 1, 0 },
{ 0, 1 },
};
double[] b =
{
1,
1,
};
Assert.IsTrue(A.IsEqual(target.ConstraintMatrix));
Assert.IsTrue(b.IsEqual(target.ConstraintValues));
double[,] Q =
{
{ 2, 2 },
{ 2, 2 },
};
double[] d = { 0, -1 };
var actualQ = f.QuadraticTerms;
var actuald = f.LinearTerms;
Assert.IsTrue(Q.IsEqual(actualQ));
Assert.IsTrue(d.IsEqual(actuald));
bool success = target.Minimize();
Assert.IsFalse(success);
}
/// <summary>
/// Attempts to create a <see cref="QuadraticObjectiveFunction"/>
/// from a <see cref="System.String"/> representation.
/// </summary>
///
/// <param name="str">The string containing the function in textual form.</param>
/// <param name="function">The resulting function, if it could be parsed.</param>
/// <param name="culture">The culture information specifying how
/// numbers written in the <paramref name="function"/> should
/// be parsed. Default is CultureInfo.InvariantCulture.</param>
///
/// <returns><c>true</c> if the function could be parsed
/// from the string, <c>false</c> otherwise.</returns>
///
public static bool TryParse(string str, CultureInfo culture, out QuadraticObjectiveFunction function)
{
// TODO: implement this method without the try-catch block.
try
{
function = new QuadraticObjectiveFunction(str, culture);
}
catch (FormatException)
{
function = null;
return false;
}
return true;
}
public void GoldfarbIdnaniParseGlobalizationTestBase()
{
// minimize 0.5x² + 0.2y² + 0.3xy s.t. 0.01x + 0.02y - 0.03 = 0 AND x + y = 100
// http://www.wolframalpha.com/input/?i=minimize+0.5x%C2%B2+%2B+0.2y%C2%B2+%2B+0.3xy+s.t.+0.01x+%2B+0.02y+-+0.03+%3D+0+AND+x+%2B+y+%3D+100
String strObjective = "0.5x² + 0.2y² + 0.3xy";
String[] strConstraints =
{
"0.01x + 0.02y - 0.03 = 0",
"x + y = 100"
};
QuadraticObjectiveFunction function = new QuadraticObjectiveFunction(strObjective);
LinearConstraintCollection cst = new LinearConstraintCollection();
foreach (var tmpCst in strConstraints)
cst.Add(new LinearConstraint(function, tmpCst));
var classSolver = new Accord.Math.Optimization.GoldfarbIdnani(function, cst);
bool status = classSolver.Minimize();
double result = classSolver.Value;
Assert.IsTrue(status);
Assert.AreEqual(15553.60, result, 1e-10);
}
/// <summary>
/// Attempts to create a <see cref="QuadraticObjectiveFunction"/>
/// from a <see cref="System.String"/> representation.
/// </summary>
///
/// <param name="str">The string containing the function in textual form.</param>
/// <param name="function">The resulting function, if it could be parsed.</param>
///
/// <returns><c>true</c> if the function could be parsed
/// from the string, <c>false</c> otherwise.</returns>
///
public static bool TryParse(string str, out QuadraticObjectiveFunction function)
{
return(TryParse(str, CultureInfo.InvariantCulture, out function));
}
public void LambdaFunctionTest3()
{
double x = 0;
Func<double> expected = () => x * x + 1;
var actual = new QuadraticObjectiveFunction(() => x * x + 1);
for (int i = 0; i < 10; i++)
{
x = (i - 5) / 10.0;
double a = actual.Function(new[] { x });
double e = expected();
Assert.AreEqual(e, a, 1e-10);
Assert.IsFalse(Double.IsNaN(a));
Assert.IsFalse(Double.IsNaN(e));
}
}
