Derivative-free nonlinear optimization for .NET and Java

• Download cscobyla-master-noexe.zip (NuGet excluded) - 23.5 KB
• Download jcobyla-master.zip - 30.1 KB
• Download csbobyqa-master-noexe.zip (NuGet excluded) - 352.1 KB

Introduction 

Optimization of non-linear objective functions and potentially also non-linear constraints is a common problem in many scientific, engineering and business areas. 

Using the code

The implementations are relatively faithful to the original Fortran 77 and 90 implementations. It should be noted however that the indexing of the variables and constraints arrays in these implementations are zero-based, i.e. for a problem with 3 variables, x[0], x[1] and x[2] should be employed in the objective (and, where applicable, constraints) function evaluations. 

Calling COBYLA2 from C#  

To successfully invoke the COBYLA2 algorithm from C#, incorporate the Cobyla.cs file from the cscobyla project in your application. Then, implement a method for computing objective function and (potentially) constraints functions with the following signature: 

void calcfc(int n, int m, double[] x, out double f, double[] con)

where n is the number of variables, m is the number of constraints, x is the variable array, f is the calculated objective function value and  con is the array of calculated constraints function values.

To minimize the objective function subject to constraints, call one of the two overloaded Cobyla.FindMinimum methods:

CobylaExitStatus FindMinimum(CalcfcDelegate calcfc, int n, int m, double[] x,
                 double rhobeg, double rhoend, int iprint, int maxfun,
                 out double f, out double[] con, out int iters, TextWriter logger);

CobylaExitStatus FindMinimum(CalcfcDelegate calcfc, int n, int m, double[] x,
                 double rhobeg, double rhoend, int iprint, int maxfun, TextWriter logger);

where x on input is the initial variable array, rhobeg and rhoend are the initial and final values of the simplex, iprint (0..3) specifies the level of output to the console, maxfun is the maximum allowed number of function evaluations, f is the objective function value and con the constraints function values at variables optimum and iters is the actual number of function evaluations performed in the optimization. If defined, logger is a text writer where output from COBYLA2 is logged.

On return x is the optimal obtained variable values. Both methods return final optimization status, which is one of normal termination, maximum iterations reached or diverging rounding errors.

The latter of the two overloaded methods also implements default values as follows: rhobeg = 0.5, rhoend = 1.0e-6, iprint = 2, maxfun = 3500 and logger = null. The method can thus optionally be called as follows, employing the default parameter values in the minimization:

var status = Cobyla.FindMinimum(calcfc, n, m, x); 

Here is a simple example for minimizing the product of two variables, provided that the variables are confined to the border of the unit circle. First, implement the objective function and constraints computation method:

public static void calcfc1(int n, int m, double[] x, out double f, double[] con)
{
    f = x[0] * x[1];
    con[0] = 1.0 - x[0] * x[0] - x[1] * x[1];
} 

Implicitly, the requirement is that all constraint function values be non-negative, i.e. con[j] ≥ 0 for all constraints j.

To perform the actual optimization, define initial variable values and call Cobyla.FindMinimum: 

var x = new[] { 1.0, 1.0 };
var status = Cobyla.FindMinimum(calcfc1, 2, 1, x);  

Calling COBYLA2 from JAVA   

The files Cobyla.java, Calcfc.java and CobylaExitStatus.java from the jcobyla project can be included in the package com.cureos.numerics of any Java project.

In Java, the objective function and (potentially) constraints functions computation is represented by the Compute method in the Calcfc interface. Implement the interface explicitly or anonymously. The Compute method exhibits the following signature: 

double Compute(int n, int m, double[] x, double[] con)

where n is the number of variables, m is the number of constraints, x is the variable array, and con is the array of calculated constraints function values. The method should return the value of the objective function. To minimize the objective function subject to constraints, call the static Cobyla.FindMinimum method:

CobylaExitStatus FindMinimum(Calcfc calcfc, int n, int m, double[] x,
                 double rhobeg, double rhoend, int iprint, int maxfun); 

where x on input is the initial variable array, rhobeg and rhoend are the initial and final values of the simplex, iprint (0..3) specifies the level of output to the console, and maxfun is the maximum allowed number of function evaluations

On output x contains the optimal obtained variable values. The method returns final optimization status, which is one of normal termination, maximum iterations reached or diverging rounding errors.

Here is a simple example taken from the book Practical Methods of Optimization, Volume 2, by Roger Fletcher (equation 9.1.15). First, implement the Calcfc interface. It is fully possible to make an implicit interface implementation:

Calcfc calcfc = new Calcfc() {
    @Override
    public double Compute(int n, int m, double[] x, double[] con) {
        con[0] = x[1] - x[0] * x[0];
        con[1] = 1.0 - x[0] * x[0] - x[1] * x[1];
        return -x[0] - x[1];
    }
}; 

Implicitly, the requirement is that all constraint function values be non-negative, i.e. con[j] ≥ 0 for all constraints j. Next, define initial variable values and call Cobyla.FindMinimum with suitable control parameters:

double[] x = {1.0, 1.0 };
CobylaExitStatus result = Cobyla.FindMinimum(calcfc, 2, 2, x, 0.5, 1.0e-6, 1, 3500); 

Calling BOBYQA from C#

To successfully invoke the BOBYQA algorithm from C#, incorporate the Bobyqa.cs file from the csbobyqa project in your application. Then, , implement a method for computing the objective function with the following signature:

double calfun(int n, double[] x)

where n is the number of variables and x is the variable array. The method should return the calculated objective function value.

To minimize the objective function subject to bounds, call the static Bobyqa.FindMinimum method:

BobyqaExitStatus FindMinimum(Func<int, double[], double> calfun, int n, double[] x, 
                                 double[] xl, double[] xu, int npt, double rhobeg, 
                                 double rhoend, int iprint, int maxfun, TextWriter logger)

<code>

If xl and/or xu are set to null, all optimization variables are considered to be unbounded downwards and upwards, respectively. If npt is set to a non-positive value, the npt value applied in the optimization is equal to 2 * n + 1. If rhobeg is set to a non-positive value, the rhobeg value applied in the optimization will be based on the variable start values and the ranges of the bounds. If rhoend is set to a non-positive value, the rhoend value applied in the optimization will be one millionth of the applied rhobeg.

The FindMinimum method also implements default values as follows: xl = null, xu = null, npt = -1, rhobeg = -1, rhoend = -1, iprint = 1, maxfun = 10000 and logger = null. To solve an unbounded optimization problem, the method can thus potentially be called as follows, employing the above default parameter values in the minimization:

var status = Bobyqa.FindMinimum(calfun, n, x);

On output x provides the optimal obtained variable values. The method returns an enumerated optimization status value, which should be equal to Normal if optimization is successfully performed.

Here is a simple example HS05 from the Hock-Schittkowski collection. Note that the objective function need not be externally defined but can sufficiently be included as a lambda expression in the method call: 

var xx = new[] { 0.0, 0.0 };
var status = Bobyqa.FindMinimum(
    (n, x) =>                 /* Objective function */
        Math.Sin(x[0] + x[1]) + Math.Pow(x[0] - x[1], 2.0) - 1.5 * x[0] + 2.5 * x[1] + 1, 
    2,                        /* Number of variables */
    xx,                       /* Variable array */
    new[] { -1.5, -3.0 },     /* Lower bounds */
    new[] { 4.0, 3.0 });      /* Upper bounds */  

Where to find the code 

A Java version of BOBYQA is incorporated in Apache Commons Math: http://commons.apache.org/math/ 

The development of COBYLA2 for Java also inspired Reinhard Oldenburg to make a Javascript adaptation of COBYLA2. So for those looking to incorporate nonlinear optimization directly on your website, look no further than here. 

History

December 14, 2012: First version, adapted from the original article on my blog.
December 19, 2012: Added latest revisions of source code to article.