AugmentedLagrangian Class

public class AugmentedLagrangian : BaseGradientOptimizationMethod, 
	IGradientOptimizationMethod, IOptimizationMethod, IOptimizationMethod<double[], double>, 
	IGradientOptimizationMethod<double[], double>, IFunctionOptimizationMethod<double[], double>, 
	IOptimizationMethod<AugmentedLagrangianStatus>, IOptimizationMethod<double[], double, AugmentedLagrangianStatus>

Public Class AugmentedLagrangian
	Inherits BaseGradientOptimizationMethod
	Implements IGradientOptimizationMethod, IOptimizationMethod, IOptimizationMethod(Of Double(), Double), 
	IGradientOptimizationMethod(Of Double(), Double), IFunctionOptimizationMethod(Of Double(), Double), 
	IOptimizationMethod(Of AugmentedLagrangianStatus), IOptimizationMethod(Of Double(), Double, AugmentedLagrangianStatus)

// Suppose we would like to minimize the following function:
// 
//    f(x,y) = min 100(y-x²)²+(1-x)²
// 
// Subject to the constraints
// 
//    x >= 0  (x must be positive)
//    y >= 0  (y must be positive)
// 

// First, let's declare some symbolic variables
double x = 0, y = 0; // (values do not matter)

// Now, we create an objective function
var f = new NonlinearObjectiveFunction(

    // This is the objective function:  f(x,y) = min 100(y-x²)²+(1-x)²
    function: () => 100 * Math.Pow(y - x * x, 2) + Math.Pow(1 - x, 2),

    // And this is the vector gradient for the same function:
    gradient: () => new[]
    {
        2 * (200 * Math.Pow(x, 3) - 200 * x * y + x - 1), // df/dx = 2(200x³-200xy+x-1)
        200 * (y - x*x)                                   // df/dy = 200(y-x²)
    }
);

// Now we can start stating the constraints
var constraints = new List<NonlinearConstraint>()
{
    // Add the non-negativity constraint for x
    new NonlinearConstraint(f,
        // 1st constraint: x should be greater than or equal to 0
        function: () => x,
        shouldBe: ConstraintType.GreaterThanOrEqualTo,
        value: 0,
        gradient: () => new[] { 1.0, 0.0 }
    ),

    // Add the non-negativity constraint for y
    new NonlinearConstraint(f,
        // 2nd constraint: y should be greater than or equal to 0
        function: () => y,
        shouldBe: ConstraintType.GreaterThanOrEqualTo,
        value: 0,
        gradient: () => new[] { 0.0, 1.0 }
    )
};

// Finally, we create the non-linear programming solver
var solver = new AugmentedLagrangian(f, constraints);

// And attempt to find a minimum
bool success = solver.Minimize();

// The solution found was { 1, 1 }
double[] solution = solver.Solution;

// with the minimum value zero.
double minValue = solver.Value;

// Suppose we would like to minimize the following function:
// 
//    f(x,y) = min 100(y-x²)²+(1-x)²
// 
// Subject to the constraints
// 
//    x >= 0  (x must be positive)
//    y >= 0  (y must be positive)
// 

// Now, we can create an objective function using vectors
var f = new NonlinearObjectiveFunction(numberOfVariables: 2,

    // This is the objective function:  f(x,y) = min 100(y-x²)²+(1-x)²
    function: (x) => 100 * Math.Pow(x[1] - x[0] * x[0], 2) + Math.Pow(1 - x[0], 2),

    // And this is the vector gradient for the same function:
    gradient: (x) => new[]
    {
        2 * (200 * Math.Pow(x[0], 3) - 200 * x[0] * x[1] + x[0] - 1), // df/dx = 2(200x³-200xy+x-1)
        200 * (x[1] - x[0]*x[0])                                      // df/dy = 200(y-x²)
    }
);

// As before, we state the constraints. However, to illustrate the flexibility
// of the AugmentedLagrangian, we shall use LinearConstraints to constrain the problem.
double[,] a = Matrix.Identity(2); // Set up the constraint matrix...
double[] b = Vector.Zeros(2);     // ...and the values they must be greater than
int numberOfEqualities = 0;
var linearConstraints = LinearConstraintCollection.Create(a, b, numberOfEqualities);

// Finally, we create the non-linear programming solver
var solver = new AugmentedLagrangian(f, linearConstraints);

// And attempt to find a minimum
bool success = solver.Minimize();

// The solution found was { 1, 1 }
double[] solution = solver.Solution;

// with the minimum value zero.
double minValue = solver.Value;