/// <summary> /// Maximizes the given function. /// </summary> /// /// <param name="function">The function to be maximized.</param> /// /// <returns>The maximum value found at the <see cref="Solution"/>.</returns> /// public double Maximize(NonlinearObjectiveFunction function) { if (function.NumberOfVariables != numberOfVariables) { throw new ArgumentOutOfRangeException("function", "Incorrect number of variables in the objective function. " + "The number of variables must match the number of variables set in the solver."); } this.Function = x => - function.Function(x); this.Gradient = x => function.Gradient(x).Multiply(-1); minimize(); return(-Function(Solution)); }
public void ConstructorTest4() { var function = new NonlinearObjectiveFunction(2, x => Math.Pow(x[0] * x[0] - x[1], 2.0) + Math.Pow(1.0 + x[0], 2.0)); NelderMead solver = new NelderMead(function); Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; Assert.AreEqual(0, minimum, 1e-10); Assert.AreEqual(-1, solution[0], 1e-5); Assert.AreEqual(1, solution[1], 1e-4); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest5() { var function = new NonlinearObjectiveFunction(2, x => 10.0 * Math.Pow(x[0] * x[0] - x[1], 2.0) + Math.Pow(1.0 + x[0], 2.0)); Subplex solver = new Subplex(function); Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; Assert.AreEqual(-0, minimum, 1e-6); Assert.AreEqual(-1, solution[0], 1e-3); Assert.AreEqual(+1, solution[1], 1e-3); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest3() { // minimize f(x) = x*y*z, // s.t. // // 1 - x² - 2y² - 3z² > 0 // x > 0, // y > 0 // // Easy three dimensional minimization in ellipsoid. var function = new NonlinearObjectiveFunction(3, function: x => x[0] * x[1] * x[2], gradient: x => new[] { x[1] * x[2], x[0] * x[2], x[0] * x[1] }); NonlinearConstraint[] constraints = { new NonlinearConstraint(3, function: x => 1.0 - x[0] * x[0] - 2.0 * x[1] * x[1] - 3.0 * x[2] * x[2], gradient: x => new[] { -2.0 * x[0], -4.0 * x[1], -6.0 * x[2] }), new NonlinearConstraint(3, function: x => x[0], gradient: x => new[] { 1.0, 0, 0 }), new NonlinearConstraint(3, function: x => x[1], gradient: x => new[] { 0, 1.0, 0 }), new NonlinearConstraint(3, function: x => -x[2], gradient: x => new[] { 0, 0, -1.0 }), }; for (int i = 0; i < constraints.Length; i++) { Assert.AreEqual(ConstraintType.GreaterThanOrEqualTo, constraints[i].ShouldBe); Assert.AreEqual(0, constraints[i].Value); } var inner = new BroydenFletcherGoldfarbShanno(3); inner.LineSearch = LineSearch.BacktrackingArmijo; inner.Corrections = 10; var solver = new AugmentedLagrangian(inner, function, constraints); Assert.AreEqual(inner, solver.Optimizer); Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; double[] expected = { 1.0 / Math.Sqrt(3.0), 1.0 / Math.Sqrt(6.0), -1.0 / 3.0 }; for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], solver.Solution[i], 1e-3); Assert.AreEqual(-0.078567420132031968, minimum, 1e-4); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest4() { // Weak version of Rosenbrock's problem. var function = new NonlinearObjectiveFunction(2, x => Math.Pow(x[0] * x[0] - x[1], 2.0) + Math.Pow(1.0 + x[0], 2.0)); Subplex solver = new Subplex(function); Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; Assert.AreEqual(2, solution.Length); Assert.AreEqual(0, minimum, 1e-10); Assert.AreEqual(-1, solution[0], 1e-5); Assert.AreEqual(1, solution[1], 1e-4); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
private static void test2(IGradientOptimizationMethod inner) { // maximize 2x + 3y, s.t. 2x² + 2y² <= 50 // // http://www.wolframalpha.com/input/?i=max+2x+%2B+3y%2C+s.t.+2x%C2%B2+%2B+2y%C2%B2+%3C%3D+50 // Max x' * c // x // s.t. x' * A * x <= k // x' * i = 1 // lower_bound < x < upper_bound double[] c = { 2, 3 }; double[,] A = { { 2, 0 }, { 0, 2 } }; double k = 50; // Create the objective function var objective = new NonlinearObjectiveFunction(2, function: (x) => x.InnerProduct(c), gradient: (x) => c ); // Test objective for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * 2 + j * 3; double actual = objective.Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the optimization constraints var constraints = new List<NonlinearConstraint>(); constraints.Add(new QuadraticConstraint(objective, quadraticTerms: A, shouldBe: ConstraintType.LesserThanOrEqualTo, value: k )); // Test first constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { var input = new double[] { i, j }; double expected = i * (2 * i + 0 * j) + j * (0 * i + 2 * j); double actual = constraints[0].Function(input); Assert.AreEqual(expected, actual); } } // Create the solver algorithm AugmentedLagrangian solver = new AugmentedLagrangian(inner, objective, constraints); Assert.AreEqual(inner, solver.Optimizer); Assert.IsTrue(solver.Maximize()); double maxValue = solver.Value; Assert.AreEqual(18.02, maxValue, 1e-2); Assert.AreEqual(2.77, solver.Solution[0], 1e-2); Assert.AreEqual(4.16, solver.Solution[1], 1e-2); }
public void ConstructorTest2() { Accord.Math.Tools.SetupGenerator(0); var function = new NonlinearObjectiveFunction(2, function: x => x[0] * x[1], gradient: x => new[] { x[1], x[0] }); NonlinearConstraint[] constraints = { new NonlinearConstraint(function, function: x => 1.0 - x[0] * x[0] - x[1] * x[1], gradient: x => new [] { -2 * x[0], -2 * x[1]}), new NonlinearConstraint(function, function: x => x[0], gradient: x => new [] { 1.0, 0.0}), }; var target = new ConjugateGradient(2); AugmentedLagrangian solver = new AugmentedLagrangian(target, function, constraints); Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; double sqrthalf = Math.Sqrt(0.5); Assert.AreEqual(-0.5, minimum, 1e-5); Assert.AreEqual(sqrthalf, solution[0], 1e-5); Assert.AreEqual(-sqrthalf, solution[1], 1e-5); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest6_2() { /// This problem is taken from Fletcher's book Practical Methods of /// Optimization and has the equation number (9.1.15). var function = new NonlinearObjectiveFunction(2, x => -x[0] - x[1]); NonlinearConstraint[] constraints = { new NonlinearConstraint(2, x => -(x[1] - x[0] * x[0]) <= 0), new NonlinearConstraint(2, x => -(-x[0] * x[0] - x[1] * x[1]) <= 1.0), }; Cobyla cobyla = new Cobyla(function, constraints); Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double sqrthalf = Math.Sqrt(0.5); Assert.AreEqual(-sqrthalf * 2, minimum, 1e-10); Assert.AreEqual(sqrthalf, solution[0], 1e-5); Assert.AreEqual(sqrthalf, solution[1], 1e-5); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
private static void test1(IGradientOptimizationMethod inner, double tol) { // maximize 2x + 3y, s.t. 2x² + 2y² <= 50 and x+y = 1 // Max x' * c // x // s.t. x' * A * x <= k // x' * i = 1 // lower_bound < x < upper_bound double[] c = { 2, 3 }; double[,] A = { { 2, 0 }, { 0, 2 } }; double k = 50; // Create the objective function var objective = new NonlinearObjectiveFunction(2, function: (x) => x.InnerProduct(c), gradient: (x) => c ); // Test objective for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * 2 + j * 3; double actual = objective.Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the optimization constraints var constraints = new List<NonlinearConstraint>(); constraints.Add(new QuadraticConstraint(objective, quadraticTerms: A, shouldBe: ConstraintType.LesserThanOrEqualTo, value: k )); constraints.Add(new NonlinearConstraint(objective, function: (x) => x.Sum(), gradient: (x) => new[] { 1.0, 1.0 }, shouldBe: ConstraintType.EqualTo, value: 1, withinTolerance: 1e-10 )); // Test first constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * (2 * i + 0 * j) + j * (0 * i + 2 * j); double actual = constraints[0].Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Test second constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i + j; double actual = constraints[1].Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } AugmentedLagrangian solver = new AugmentedLagrangian(inner, objective, constraints); Assert.AreEqual(inner, solver.Optimizer); Assert.IsTrue(solver.Maximize()); double maxValue = solver.Value; Assert.AreEqual(6, maxValue, tol); Assert.AreEqual(-3, solver.Solution[0], tol); Assert.AreEqual(4, solver.Solution[1], tol); }
public void SubspaceTest1() { var function = new NonlinearObjectiveFunction(5, x => 10.0 * Math.Pow(x[0] * x[0] - x[1], 2.0) + Math.Pow(1.0 + x[0], 2.0)); NelderMead solver = new NelderMead(function); solver.NumberOfVariables = 2; Assert.IsTrue(solver.Minimize()); double minimum = solver.Value; double[] solution = solver.Solution; Assert.AreEqual(5, solution.Length); Assert.AreEqual(-0, minimum, 1e-6); Assert.AreEqual(-1, solution[0], 1e-3); Assert.AreEqual(+1, solution[1], 1e-3); double expectedMinimum = function.Function(solver.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest3() { // Easy three dimensional minimization in ellipsoid. var function = new NonlinearObjectiveFunction(3, x => x[0] * x[1] * x[2]); NonlinearConstraint[] constraints = { new NonlinearConstraint(3, x => 1.0 - x[0] * x[0] - 2.0 * x[1] * x[1] - 3.0 * x[2] * x[2]) }; Cobyla cobyla = new Cobyla(function, constraints); for (int i = 0; i < cobyla.Solution.Length; i++) cobyla.Solution[i] = 1; Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double sqrthalf = Math.Sqrt(0.5); double[] expected = { 1.0 / Math.Sqrt(3.0), 1.0 / Math.Sqrt(6.0), -1.0 / 3.0 }; for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], cobyla.Solution[i], 1e-4); Assert.AreEqual(-0.078567420132031968, minimum, 1e-10); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest10() { /// This problem is taken from page 415 of Luenberger's book Applied /// Nonlinear Programming. It is to maximize the area of a hexagon of /// unit diameter. /// var function = new NonlinearObjectiveFunction(9, x => -0.5 * (x[0] * x[3] - x[1] * x[2] + x[2] * x[8] - x[4] * x[8] + x[4] * x[7] - x[5] * x[6])); NonlinearConstraint[] constraints = { new NonlinearConstraint(9, x => 1.0 - x[2] * x[2] - x[3] * x[3]), new NonlinearConstraint(9, x => 1.0 - x[8] * x[8]), new NonlinearConstraint(9, x => 1.0 - x[4] * x[4] - x[5] * x[5]), new NonlinearConstraint(9, x => 1.0 - x[0] * x[0] - Math.Pow(x[1] - x[8], 2.0)), new NonlinearConstraint(9, x => 1.0 - Math.Pow(x[0] - x[4], 2.0) - Math.Pow(x[1] - x[5], 2.0)), new NonlinearConstraint(9, x => 1.0 - Math.Pow(x[0] - x[6], 2.0) - Math.Pow(x[1] - x[7], 2.0)), new NonlinearConstraint(9, x => 1.0 - Math.Pow(x[2] - x[4], 2.0) - Math.Pow(x[3] - x[5], 2.0)), new NonlinearConstraint(9, x => 1.0 - Math.Pow(x[2] - x[6], 2.0) - Math.Pow(x[3] - x[7], 2.0)), new NonlinearConstraint(9, x => 1.0 - x[6] * x[6] - Math.Pow(x[7] - x[8], 2.0)), new NonlinearConstraint(9, x => x[0] * x[3] - x[1] * x[2]), new NonlinearConstraint(9, x => x[2] * x[8]), new NonlinearConstraint(9, x => -x[4] * x[8]), new NonlinearConstraint(9, x => x[4] * x[7] - x[5] * x[6]), new NonlinearConstraint(9, x => x[8]), }; Cobyla cobyla = new Cobyla(function, constraints); for (int i = 0; i < cobyla.Solution.Length; i++) cobyla.Solution[i] = 1; Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double[] expected = { 0.688341, 0.725387, -0.284033, 0.958814, 0.688341, 0.725387, -0.284033, 0.958814, 0.0 }; for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], cobyla.Solution[i], 1e-2); Assert.AreEqual(-0.86602540378486847, minimum, 1e-10); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest2() { var function = new NonlinearObjectiveFunction(2, x => x[0] * x[1]); NonlinearConstraint[] constraints = { new NonlinearConstraint(function, x => 1.0 - x[0] * x[0] - x[1] * x[1]) }; Cobyla cobyla = new Cobyla(function, constraints); for (int i = 0; i < cobyla.Solution.Length; i++) cobyla.Solution[i] = 1; Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double sqrthalf = Math.Sqrt(0.5); Assert.AreEqual(-0.5, minimum, 1e-10); Assert.AreEqual(sqrthalf, solution[0], 1e-5); Assert.AreEqual(-sqrthalf, solution[1], 1e-5); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest9() { /// This problem is taken from page 111 of Hock and Schittkowski's /// book Test Examples for Nonlinear Programming Codes. It is their /// test problem Number 100. /// var function = new NonlinearObjectiveFunction(7, x => Math.Pow(x[0] - 10.0, 2.0) + 5.0 * Math.Pow(x[1] - 12.0, 2.0) + Math.Pow(x[2], 4.0) + 3.0 * Math.Pow(x[3] - 11.0, 2.0) + 10.0 * Math.Pow(x[4], 6.0) + 7.0 * x[5] * x[5] + Math.Pow(x[6], 4.0) - 4.0 * x[5] * x[6] - 10.0 * x[5] - 8.0 * x[6]); NonlinearConstraint[] constraints = { new NonlinearConstraint(7, x => 127.0 - 2.0 * x[0] * x[0] - 3.0 * Math.Pow(x[1], 4.0) - x[2] - 4.0 * x[3] * x[3] - 5.0 * x[4]), new NonlinearConstraint(7, x => 282.0 - 7.0 * x[0] - 3.0 * x[1] - 10.0 * x[2] * x[2] - x[3] + x[4]), new NonlinearConstraint(7, x => 196.0 - 23.0 * x[0] - x[1] * x[1] - 6.0 * x[5] * x[5] + 8.0 * x[6]), new NonlinearConstraint(7, x => -4.0 * x[0] * x[0] - x[1] * x[1] + 3.0 * x[0] * x[1] - 2.0 * x[2] * x[2] - 5.0 * x[5] + 11.0 * x[6]) }; Cobyla cobyla = new Cobyla(function, constraints); Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double[] expected = { 2.330499, 1.951372, -0.4775414, 4.365726, -0.624487, 1.038131, 1.594227 }; for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], cobyla.Solution[i], 1e-4); Assert.AreEqual(680.63005737443393, minimum, 1e-6); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest8() { /// This problem is taken from page 66 of Hock and Schittkowski's book Test /// Examples for Nonlinear Programming Codes. It is their test problem Number /// 43, and has the name Rosen-Suzuki. var function = new NonlinearObjectiveFunction(4, x => x[0] * x[0] + x[1] * x[1] + 2.0 * x[2] * x[2] + x[3] * x[3] - 5.0 * x[0] - 5.0 * x[1] - 21.0 * x[2] + 7.0 * x[3]); NonlinearConstraint[] constraints = { new NonlinearConstraint(4, x=> 8.0 - x[0] * x[0] - x[1] * x[1] - x[2] * x[2] - x[3] * x[3] - x[0] + x[1] - x[2] + x[3]), new NonlinearConstraint(4, x => 10.0 - x[0] * x[0] - 2.0 * x[1] * x[1] - x[2] * x[2] - 2.0 * x[3] * x[3] + x[0] + x[3]), new NonlinearConstraint(4, x => 5.0 - 2.0 * x[0] * x[0] - x[1] * x[1] - x[2] * x[2] - 2.0 * x[0] + x[1] + x[3]) }; Cobyla cobyla = new Cobyla(function, constraints); Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; double[] expected = { 0.0, 1.0, 2.0, -1.0 }; for (int i = 0; i < expected.Length; i++) Assert.AreEqual(expected[i], cobyla.Solution[i], 1e-4); Assert.AreEqual(-44, minimum, 1e-10); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
public void ConstructorTest7() { /// This problem is taken from Fletcher's book Practical Methods of /// Optimization and has the equation number (14.4.2). var function = new NonlinearObjectiveFunction(3, x => x[2]); NonlinearConstraint[] constraints = { new NonlinearConstraint(3, x=> 5.0 * x[0] - x[1] + x[2]), new NonlinearConstraint(3, x => x[2] - x[0] * x[0] - x[1] * x[1] - 4.0 * x[1]), new NonlinearConstraint(3, x => x[2] - 5.0 * x[0] - x[1]), }; Cobyla cobyla = new Cobyla(function, constraints); Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; Assert.AreEqual(-3, minimum, 1e-5); Assert.AreEqual(0.0, solution[0], 1e-5); Assert.AreEqual(-3.0, solution[1], 1e-5); Assert.AreEqual(-3.0, solution[2], 1e-5); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }
/// <summary> /// Maximizes the given function. /// </summary> /// /// <param name="function">The function to be maximized.</param> /// /// <returns>The maximum value found at the <see cref="Solution"/>.</returns> /// public double Maximize(NonlinearObjectiveFunction function) { if (function.NumberOfVariables != numberOfVariables) throw new ArgumentOutOfRangeException("function", "Incorrect number of variables in the objective function. " + "The number of variables must match the number of variables set in the solver."); this.Function = x => -function.Function(x); this.Gradient = x => function.Gradient(x).Multiply(-1); minimize(); return -Function(Solution); }
public void AugmentedLagrangianSolverConstructorTest7() { // maximize 2x + 3y, s.t. 2x² + 2y² <= 50 // Max x' * c // x // s.t. x' * A * x <= k // x' * i = 1 // lower_bound < x < upper_bound double[] c = { 2, 3 }; double[,] A = { { 2, 0 }, { 0, 2 } }; double k = 50; // Create the objective function var objective = new NonlinearObjectiveFunction(2, function: (x) => x.InnerProduct(c), gradient: (x) => c ); // Test objective for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * 2 + j * 3; double actual = objective.Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the optimization constraints var constraints = new List<NonlinearConstraint>(); constraints.Add(new QuadraticConstraint(objective, quadraticTerms: A, shouldBe: ConstraintType.LesserThanOrEqualTo, value: k )); // Test first constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * (2 * i + 0 * j) + j * (0 * i + 2 * j); double actual = constraints[0].Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the solver algorithm AugmentedLagrangianSolver solver = new AugmentedLagrangianSolver(2, constraints); double maxValue = solver.Maximize(objective); Assert.AreEqual(18.02, maxValue, 0.01); Assert.AreEqual(2.77, solver.Solution[0], 1e-2); Assert.AreEqual(4.16, solver.Solution[1], 1e-2); }
public void AugmentedLagrangianSolverConstructorTest6() { // Max x' * c // x // s.t. x' * A * x <= k // x' * i = 1 // lower_bound < x < upper_bound double[] c = { 2, 3 }; double[,] A = { { 2, 0 }, { 0, 2 } }; double k = 50; // Create the objective function var objective = new NonlinearObjectiveFunction(2, function: (x) => x.InnerProduct(c), gradient: (x) => c ); // Test objective for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * 2 + j * 3; double actual = objective.Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the optimization constraints var constraints = new List<NonlinearConstraint>(); constraints.Add(new QuadraticConstraint(objective, quadraticTerms: A, shouldBe: ConstraintType.LesserThanOrEqualTo, value: k )); constraints.Add(new NonlinearConstraint(objective, function: (x) => x.Sum(), gradient: (x) => new[] { 1.0, 1.0 }, shouldBe: ConstraintType.EqualTo, value: 1, withinTolerance: 1e-3 )); // Test first constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i * (2 * i + 0 * j) + j * (0 * i + 2 * j); double actual = constraints[0].Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Test second constraint for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { double expected = i + j; double actual = constraints[1].Function(new double[] { i, j }); Assert.AreEqual(expected, actual); } } // Create the solver algorithm AugmentedLagrangianSolver solver = new AugmentedLagrangianSolver(2, constraints); double minValue = solver.Maximize(objective); Assert.AreEqual(7.42443, minValue, 1e-5); Assert.AreEqual(-4.42433, solver.Solution[0], 1e-5); Assert.AreEqual(5.42433, solver.Solution[1], 1e-5); }
public void ConstructorTest5() { // Intermediate version of Rosenbrock's problem. var function = new NonlinearObjectiveFunction(2, x => 10.0 * Math.Pow(x[0] * x[0] - x[1], 2.0) + Math.Pow(1.0 + x[0], 2.0)); Cobyla cobyla = new Cobyla(function); Assert.IsTrue(cobyla.Minimize()); double minimum = cobyla.Value; double[] solution = cobyla.Solution; Assert.AreEqual(-0, minimum, 1e-6); Assert.AreEqual(-1, solution[0], 1e-3); Assert.AreEqual(+1, solution[1], 1e-3); double expectedMinimum = function.Function(cobyla.Solution); Assert.AreEqual(expectedMinimum, minimum); }