VB Simple Nonlinear Programming Example

← All NMath Code Examples

 

Imports System

Imports CenterSpace.NMath.Core


Namespace CenterSpace.NMath.Examples.VisualBasic

  A .NET example in Visual Basic
  Module NonlinearProgrammingExample

    Example illustrating using the Module ActiveSetLineSearchSQP to solve a
    NonLinear Programming (NLP) problem with linear constraints and variable
    bounds. 
    Sub Main()

      min -x0*x1*x2
      0 <= x0 + 2*x1 + 2*x2 <= 72,
      0 <= x0, x1, x2 <= 42

      Dimensionality of the domain of the objective function.
      Dim XDim As Integer = 3
      Dim Objective As Func(Of DoubleVector, Double) = AddressOf Temp
      Dim Problem As New NonlinearProgrammingProblem(XDim, Objective)

      Add variable bounds.
      For I = 0 To XDim - 1
        Add a lower bound of 0 and upper bound of 42 for the ith variable.
        Problem.AddBounds(I, 0.0, 42.0)
      Next

      Add the constraint 0 <= x0 + 2*x1 + 2*x2 <= 72. Note that this
      is a linear constraint.
      Problem.AddLinearConstraint(New DoubleVector(1.0, 2.0, 2.0), 0.0, 72)

      Pick the point (1, 1, 1) as initial solution guess.
      Dim x0 As New DoubleVector(3, 1.0)

      Pick a tolerance for convergence. The iteration will stop when
      either the magnitude of the predicted function value change or the
      magnitude of  the step direction is less than the specified tolerance.
      Dim tolerance As Double = 0.0001
      Dim solver As New ActiveSetLineSearchSQP(tolerance)
      Dim Success As Boolean = solver.Solve(Problem, x0)

      Console.WriteLine()

      Console.WriteLine("Termination status = " & solver.SolverTerminationStatus.ToString())
      Console.WriteLine("X = " & solver.OptimalX.ToString())
      Console.WriteLine("f(x) = " & solver.OptimalObjectiveFunctionValue)
      Console.WriteLine("Iterations = " & solver.Iterations)

      Seems like it took quite a few iterations to converge. Note that the
      solver computes a step direction and a step size at each iteration. 
      The step direction is computed by forming a quadratic programming 
      problem with linear constraints at each iteration whose solution
      yields the step direction. The size of the step taken in this 
      direction is then chosen to decrease the function value and not
      violate constraints. Since our constraints for this problem are linear 
      to begin with, we may try taking a larger step in order to converge
      faster. Well use the ConstantSQPStepSize Module with a constant step
      size of one and see what happens.
      solver.SolverOptions.StepSizeCalculator = New ConstantSQPStepSize(1)
      Success = solver.Solve(Problem, x0)
      Console.WriteLine()
      Console.WriteLine("Using a constant step size of 1:")
      Console.WriteLine("Termination status = " & solver.SolverTerminationStatus.ToString())
      Console.WriteLine("X = " & solver.OptimalX.ToString())
      Console.WriteLine("f(x) = " & solver.OptimalObjectiveFunctionValue)
      Console.WriteLine("Iterations = " & solver.Iterations)

      As you can see the algorithm converges must faster with the constant
      step size of one. In general if your constraints are all linear, or
      very nearly linear, the constant step size calculator may yield
      faster convergence.


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

    End Sub

    Function Temp(ByVal x As DoubleVector) As Double
      Return -x(0) * x(1) * x(2)
    End Function

  End Module
End Namespace


← All NMath Code Examples
Top