C# Nonlinear Programming Example

using System;

using CenterSpace.NMath.Core;


namespace CenterSpace.NMath.Examples.CSharp
{
  class NonlinearProgrammingExample
  {
    static void Main( string[] args )
    {
      DoubleFunctional objective = new ObjectiveFunction();
      var problem = new NonlinearProgrammingProblem( objective );
    
      // Dimensionality of the objective and constraint function domains
      int xDimension = 2;

      // Add constraint x0*x1 - x0 -x1 <= -1.5
      problem.AddUpperBoundConstraint( xDimension, ( DoubleVector x ) => x[0] * x[1] - x[0] - x[1], -1.5 );

      // Add constraint x0*x1 >= -10
      problem.AddLowerBoundConstraint( xDimension, ( DoubleVector x ) => x[0] * x[1], -10.0 );


      // Set some options on the solver by creating an Options object and setting
      // some properties, then use it to construct the solver instance.
      var solverOptions = new ActiveSetLineSearchSQP.Options();
      solverOptions.StepDirectionTolerance = 1e-8;
      solverOptions.FunctionChangeTolerance = 1e-6;

      // Since our constraints are nearly linear (one quadratic term) well
      // use the simpler constant step size.
      solverOptions.StepSizeCalculator = new ConstantSQPStepSize( 1 );

      // Create the solver with the above options and use it to solve the problem.
      var solver = new ActiveSetLineSearchSQP( solverOptions );
      // Initial solution guess
      var x0 = new DoubleVector( -1.0, 1.0 );
      bool success = solver.Solve( problem, x0 );

      Console.WriteLine();

      Console.WriteLine( success ? "Solver was successful" : "Solver encountered a problem." );
      Console.WriteLine( "Termination status = " + solver.SolverTerminationStatus );
      Console.WriteLine( "X = " + solver.OptimalX );
      Console.WriteLine( "f(x) = " + solver.OptimalObjectiveFunctionValue );
      Console.WriteLine( "Iterations = " + solver.Iterations );

      Console.WriteLine();
      Console.WriteLine( "Press Enter Key" );
      Console.Read();
    }

    /// <summary>
    /// f(x) = exp(x0)*(4*x0^2 + 2*x1^2 + 4*x0*x1 + 2*x1 + 1)
    /// </summary>
    class ObjectiveFunction : DoubleFunctional
    {
      /// <summary>
      /// Constructor. Must initialize the base class with dimension
      /// of the domain, 2 in this case.
      /// </summary>
      public ObjectiveFunction()
        : base( 2 )
      {
        ;
      }

      /// <summary>
      /// Evaluate the objective function at a point x.
      /// </summary>
      /// <param name="x">The point at which to evaluate the function.</param>
      /// <returns>The value of the objective function.</returns>
      public override double Evaluate( DoubleVector x )
      {
        double x0 = x[0];
        double x1 = x[1];
        return Math.Exp( x0 ) * ( 4 * x0 * x0 + 2 * x1 * x1 + 4 * x0 * x1 + 2 * x1 + 1 );
      }

      /// <summary>
      /// Returns the gradient of the objective function at a point x.
      /// </summary>
      /// <param name="x">The point at which to evaluate the gradient.</param>
      /// <param name="grad">Vector into which to place the gradient values.</param>
      public override void Gradient( DoubleVector x, DoubleVector grad )
      {
        double x0 = x[0];
        double x1 = x[1];
        double ex0 = Math.Exp( x0 );
        grad[0] = ex0 * ( 4 * x0 * x0 + 2 * x1 * x1 + 4 * x0 * x1 + 2 * x1 + 1 ) + ex0 * ( 8 * x0 + 4 * x1 );
        grad[1] = ex0 * ( 4 * x0 + 4 * x1 + 2 );
      }
    }
  }
}