QuadraticObjectiveFunction Class

public class QuadraticObjectiveFunction : NonlinearObjectiveFunction, 
	IObjectiveFunction

Public Class QuadraticObjectiveFunction
	Inherits NonlinearObjectiveFunction
	Implements IObjectiveFunction

f(x,y,z) = ax² + by² +cz² + dxy + exz + fyz + gx + hy + iz + j

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");

// Declare symbol variables
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 h1 = new QuadraticObjectiveFunction("3x² - 4y² + 6xy + 3x + 2y");

double[,] Q = { { 6, 6 }, { 6, -8 } }; // Note the factor of 2
double[] d = { 3, 2 };

// Equivalently this can be written:
var h2 = new QuadraticObjectiveFunction(Q, d);

f1.Function(new [] { 5.0 }); // x*x+1 = x² + 1 = 25 + 1 = 26

// Declare symbol variables
double x = 0, y = 0, z = 0;

// Create the function to be optimized
var f = new QuadraticObjectiveFunction(() => x * x - 2 * x * y + 3 * y * y + z * z - 4 * x - 5 * y - z);

// Create some constraints for the solution
var 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));

// Create the Quadratic Programming solver
GoldfarbIdnani solver = new GoldfarbIdnani(f, constraints);

// Minimize the function
bool success = solver.Minimize();

double value = solver.Value;
double[] solutions = solver.Solution;

// The quadratic objective function supports the notion
// of vector addition and scalar multiplication. That is,
// QP programs can be linearly combined to create new QP
// problems. This idea can be useful when composing
// objective functions.
var f1 = new QuadraticObjectiveFunction("2x² + 4y² - 2xy + 6");
var f2 = new QuadraticObjectiveFunction("3x² - 4y² + 6xy + 3x + 2y");

// Suppose we have the functions:
//      f₁(x,y) = 2x² - 2xy + 4y² + 6
//      f₂(x,y) = 3x² + 6xy - 4y² + 3x + 2y
// 
// Then we can create a new function - f(x,y) - defined as
// some linear combination of f₁ and f₂. e.g.
//      f(x,y) = {f₁ + 2f₂}(x,y)
// 
// In code, we can write this:
QuadraticObjectiveFunction f = f1 + (2 * f2); // 8x² -4y² +10xy +6x +4y +6

// And now we can test our new objective function:
double[] x = { 1, 2 };

double result1 = f1.Function(x);
double result2 = f2.Function(x);

double result = f.Function(x);          // should be 32
double check = result1 + 2 * result2;   // should be the same