NMath User's Guide

25.2 Minimizing Derivable Functions (.NET, C#, CSharp, Visual Basic, VB.NET)

NMath provides two classes that implement the IMultiVariableDMinimizer interface, and minimize a MultiVariableFunction using function evaluations and derivative calculations:

• Class ConjugateGradientMinimizer minimizes a multivariate function using the Polak-Ribiere variant of the Fletcher-Reeves conjugate gradient method. Gradients are calculated using the partial derivatives, then chosen based on a direction that is conjugate to the old gradient and, insofar as possible, to all previous directions traversed.
• Class VariableMetricMinimizer minimizes a multivariate function using the Broyden-Fletcher-Goldfarb-Shanno variable metric (or quasi-Newton) method. Variable metric methods are very similar to conjugate gradient methods-both calculate gradients using the partial derivatives. Storage is less efficient (order N2 storage, versus order a few times N), but since variable metric methods predate conjugate gradient methods, they are still widely used.

Like all NMath minimizers, instances of ConjugateGradientMinimizer and VariableMetricMinimizer are constructed by specifying an error tolerance and a maximum number of iterations, or by accepting the defaults for these values. For example, this code constructs a VariableMetricMinimizer using a tolerance or 10-5 and a maximum of 20 iterations:

double tol = 1e-5;
int maxIter = 20;
VariableMetricMinimizer minimizer =
  new VariableMetricMinimizer( tol, maxIter );

Class ConjugateGradientMinimizer and VariableMetricMinimizer implement the IMultiVariableDMinimizer interface, which provides a single Minimize() method with the following signature:

DoubleVector Minimize( MultiVariableFunction f, 
                       MultiVariableFunction[] df,
                       DoubleVector x ); 

where f is the function to minimize, df is an array of partial derivatives, and x is the start point.

For instance, given the following function and partial derivatives:

protected static double MyFunction( DoubleVector v )
{
  return ( ( v[0] - 5.0 ) * ( v[0] - 5.0 ) ) +
         ( ( v[1] + 3.0 ) * ( v[1] + 3.0 ) );
}

protected static double MyFunctionDx( DoubleVector v )
{
  return ( 2 * v[0] ) - 10;
}

protected static double MyFunctionDy( DoubleVector v )
{
  return ( 2 * v[1] ) + 6;
}

This code computes the minimum using a ConjugateGradientMinimizer, starting at the origin:

MultiVariableFunction function = new MultiVariableFunction(
    new NMathFunctions.DoubleVectorDoubleFunction( MyFunction ) );

MultivariableFunction partialx = new MultiVariableFunction(
  new NMathFunctions.DoubleVectorDoubleFunction( MyFunctionDx ) );
MultivariableFunction partialy = new MultiVariableFunction(
  new NMathFunctions.DoubleVectorDoubleFunction( MyFunctionDy ) );
MultiVariableFunction[] df =
  new MultiVariableFunction[] { partialx, partialy };

ConjugateGradientMinimizer minimizer = 
  new ConjugateGradientMinimizer();
DoubleVector start = new DoubleVector( 2, 0 );
DoubleVector min = minimizer.Minimize( f, df, start );

TOC |  Previous |  Next |  Index