public static void Sample2()
{
// See IpoptHowTo.txt how to get Ipopt to work. It's quite easy and Ipopt is very powerful.
// Variables.
Variable x1 = new Variable();
Variable x2 = new Variable();
Variable x3 = new Variable();
Variable x4 = new Variable();
// Objective function and non-linear constraints.
Function f = x1 * x4 * (x1 + x2 + x3) + x3;
Function g1 = x1 * x2 * x3 * x4;
Function g2 = Function.Sqr(x1) + Function.Sqr(x2) + Function.Sqr(x3) + Function.Sqr(x4);
// Objective function and constrains may be compiled including first and second derivatives.
//CompiledFunction[] c = Compiler.Compile(new Function[] { f, g1, g2 }, new Variable[] { x1, x2, x3, x4 }, 2);
//f = c[0];
//g1 = c[1];
//g2 = c[2];
// Prepare the optimizer.
IpoptOptimizer o = new IpoptOptimizer();
o.Variables.Add(x1, x2, x3, x4);
o.ObjectiveFunction = f;
o.Constraints.Add(g1 >= 25.0);
o.Constraints.Add(g2 == 40.0);
o.Constraints.Add(1.0 <= x1, x1 <= 5.0);
o.Constraints.Add(1.0 <= x2, x2 <= 5.0);
o.Constraints.Add(1.0 <= x3, x3 <= 5.0);
o.Constraints.Add(1.0 <= x4, x4 <= 5.0);
// Verbose mode. Show Ipopt convergence.
o.PrintLevel = 5;
// Run optimization. Initial point doesn't have to satisfy the constraints.
IpoptOptimizerResult or = o.RunIpopt(x1 | 1.0, x2 | 5.0, x3 | 5.0, x4 | 1.0);
Console.WriteLine(or.ReturnCode);
Console.WriteLine("x1 = " + or.OptimalPoint[x1]);
Console.WriteLine("x2 = " + or.OptimalPoint[x2]);
Console.WriteLine("x3 = " + or.OptimalPoint[x3]);
Console.WriteLine("x4 = " + or.OptimalPoint[x4]);
Console.WriteLine("f = " + or.OptimalValue);
Console.WriteLine("g1 = " + g1.Value(or.OptimalPoint));
Console.WriteLine("g2 = " + g2.Value(or.OptimalPoint));
}
public static VariableAssignment[] Create(Variable[] variables, double[] values)
{
int n = variables.Length;
if (values.Length != n)
{
throw new ArgumentException("Number number of variables and the number of values don't agree.");
}
List<VariableAssignment> assignments = new List<VariableAssignment>();
for (int i = 0; i < n; i++)
{
assignments.Add(new VariableAssignment(variables[i], values[i]));
}
return assignments.ToArray();
}
/// <summary>
/// Computes the partial derivative with respect to a variable.
/// </summary>
public Function Derivative(Variable variable)
{
// It's has proved very important for efficient computation that the same object is returned
// if called repeatably. This is especially true if the function is compiled.
if (derivatives == null)
{
derivatives = new Dictionary<Variable, Function>();
}
Function derivative;
if (!derivatives.TryGetValue(variable, out derivative))
{
derivative = ComputeDerivative(variable);
if (!derivative.IsZero)
{
// Only use memory for saving non-zero derivatives.
derivatives.Add(variable, derivative);
}
}
return derivative;
}
public static void Sample1()
{
// Variables. The string names are added for convenience when printing out the optimal point with Point.ToString().
Variable x = new Variable("x");
Variable y = new Variable("y");
// Rosenbrock function http://en.wikipedia.org/wiki/Rosenbrock_function.
Function f = Function.Sqr(1.0 - x) + 100.0 * Function.Sqr(y - Function.Sqr(x));
// Use the BFGS optimizer.
BfgsOptimizer o = new BfgsOptimizer();
// Specify variables and objective functions and add constraints. Derivatives are computed automatically.
o.Variables.Add(x, y);
o.VariableConstraints.Add(x >= 0.0, y >= 0.0);
o.ObjectiveFunction = f;
// Start optimizer from a random point.
Random r = new Random(1);
IOptimizerResult or = o.Run(x | r.NextDouble(), y | r.NextDouble());
// Show convergence status and optimal point and value.
Console.WriteLine(or.Status);
Console.WriteLine(or.OptimalPoint);
Console.WriteLine(or.OptimalValue);
// The result object also contains BFGS convergence status.
Console.WriteLine(((BfgsOptimizerResult)or).ConvergenceStatus);
// We may use Prepare if we need to run the optimizer from multiple starting points.
PreparedOptimizer o2 = o.Prepare();
for (int i = 0; i < 10; i++)
{
IOptimizerResult or2 = o2.Run(x | r.NextDouble(), y | r.NextDouble());
Console.WriteLine(or2.OptimalPoint);
}
}
protected override Function ComputeDerivative(Variable variable)
{
return variable == this ? 1.0 : 0.0;
}
public VariableNotAssignedException(Variable variable, string message)
: base(message)
{
Variable = variable;
}
protected override Function ComputeDerivative(Variable variable)
{
List<Function> derivatives = new List<Function>();
foreach (Function function in functions)
{
derivatives.Add(function.Derivative(variable));
}
return new SumFunction(derivatives.ToArray());
}
public VariableEqualityConstraint(Variable variable, double value)
: base(variable, value, value)
{
Value = value;
}
protected override Function ComputeDerivative(Variable variable)
{
return (Function.Sqr(z.re) * z.im.Derivative(variable) - z.im * z.re.Derivative(variable)) / (Function.Sqr(z.re) + Function.Sqr(z.im));
}
protected override Function ComputeDerivative(Variable variable)
{
return new StepDerivativeFunction(f);
}
protected override Function ComputeDerivative(Variable variable)
{
return g * Function.Pow(f, g - 1.0) * f.Derivative(variable) + Function.Log(f) * this * g.Derivative(variable);
}
protected override Function ComputeDerivative(Variable variable)
{
if (partialEvaluator.Point.ContainsVariable(variable))
{
// This variable is replaced by a constant.
return 0.0;
}
return innerFunction.Derivative(variable);
}
/// <summary> /// Computes the partial derivative with respect to a variable. Override this to implement. /// </summary> protected abstract Function ComputeDerivative(Variable variable);
protected override Function ComputeDerivative(Variable variable)
{
return 0.0;
}
public VariableFunctionAssignment(Variable variable, Function function)
{
Variable = variable;
Function = function;
}
protected override Function ComputeDerivative(Variable variable)
{
// Same derivative as that of the step function.
return new StepDerivativeFunction(f);
}
protected override Function ComputeDerivative(Variable variable)
{
if (sin == null)
{
sin = new SinFunction(f, this);
}
return -sin * f.Derivative(variable);
}
protected override Function ComputeDerivative(Variable variable)
{
return 2.0 * f * f.Derivative(variable);
}
protected override Function ComputeDerivative(Variable variable)
{
return a * Function.Pow(f, a - 1.0) * f.Derivative(variable);
}
public ComplexFunction Derivative(Variable variable)
{
// Currently no support for anything like a ComplexVariable. How to implement this?
return new ComplexFunction(re.Derivative(variable), im.Derivative(variable));
}
protected override Function ComputeDerivative(Variable variable)
{
if (cos == null)
{
cos = new CosFunction(f, this);
}
return cos * f.Derivative(variable);
}
protected override Function ComputeDerivative(Variable variable)
{
// As far as not being defined at zero, all derivatives are the same.
return this;
}
protected override Function ComputeDerivative(Variable variable)
{
// Reuse the same object here.
return 0.5 / this * f.Derivative(variable);
}
/// <summary>
/// Computes the higher order partial derivative with respect to a variable.
/// </summary>
public Function Derivative(Variable variable, int order)
{
if (order < 0)
{
throw new ArgumentOutOfRangeException("order");
}
Function f = this;
for (int i = 0; i < order; i++)
{
f = f.Derivative(variable);
}
return f;
}
public ComplexFunction Derivative(Variable variable, int order)
{
return new ComplexFunction(re.Derivative(variable, order), im.Derivative(variable, order));
}
//: base(variable, value)
public VariableAssignment(Variable variable, double value)
{
Variable = variable;
Value = value;
}
protected override Function ComputeDerivative(Variable variable)
{
return ComplexFunction.Re(0.5 * new ComplexFunction(ComplexFunction.Re(z).Derivative(variable), ComplexFunction.Im(z).Derivative(variable)) / z05);
}
public VariableNotAssignedException(Variable variable)
: this(variable, null)
{
}
public VariableConstraint(Variable variable, double minValue, double maxValue)
: base(variable, minValue, maxValue)
{
Variable = variable;
}
protected override Function ComputeDerivative(Variable variable)
{
return a * -f.Derivative(variable) / Function.Sqr(f);
}