# NMath User's Guide

26.2 Minimizing Functions Without Calculating the Derivative (.NET, C#, CSharp, VB, Visual Basic, F#)

NMath provides two classes that implement the interface, and minimize a OneVariableFunction using only function evaluations:

Class performs a golden section search for a minimum of a function, by successively narrowing an interval know to contain a local minimum. The golden section search method is linearly convergent.

Class uses Brent's Method to minimize a function. Brent's Method combines golden section search with parabolic interpolation. Parabolic interpolation fits a parabola through the current set of points, then uses the parabola to estimate the function's minimum. The faster parabolic interpolation is used wherever possible, but in steps where the projected minimum falls outside the interval, or when successive steps are becoming larger, Brent's Method resorts back to the slower golden section search. Brent's Method is quadratically convergent.

Instances of GoldenMinimizer and BrentMinimizer 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 GoldenMinimizer using the default tolerance and a maximum of 50 iterations:

Code Example – C# minimization

```int maxIter = 50;
var minimizer = new GoldenMinimizer( maxIter );
```

Code Example – VB minimization

```Dim MaxIter As Integer = 50
Dim Minimizer As New GoldenMinimizer(MaxIter)
```

Instances of GoldenMinimizer and BrentMinimizer provide Minimize() methods for minimizing a given function within a given interval. Overloads of Minimize() accept a bounding Interval, a , or a triplet of points satisfying the bracketing conditions (Section 26.1). For example, the function has a minimum at 1.0. To compute the minimum, first encapsulate the function:

Code Example – C# minimization

```public static double MyFunction( double x )
{
return Math.Pow( x - 1, 4 );
}

var f = new OneVariableFunction(
new Func<double, double>( MyFunction ) );
```

Code Example – VB minimization

```Public Shared Function MyFunction(X As Double) As Double
Return Math.Pow(X - 1, 4)
End Function

Dim F As New OneVariableFunction(
New Func(Of Double, Double)(AddressOf MyFunction))
```

This code finds a minimum of f in the interval (0,2) using golden section search:

Code Example – C# minimization

```var minimizer = new GoldenMinimizer();
int lower = 0;
int upper = 2;
double min = minimizer.Minimize( f, lower, upper );
```

Code Example – VB minimization

```Dim Minimizer As New GoldenMinimizer()
Dim Lower As Integer = 0
Dim Upper As Integer = 2
Dim Min As Double = Minimizer.Minimize(F, Lower, Upper)
```

This code first constructs a Bracket starting from (0,10), then finds a minimum of f using Brent's Method:

Code Example – C# minimization

```double tol = 1e-9;
int maxIter = 25;
var minimizer = new BrentMinimizer( tol, maxIter );
var bracket = new Bracket( f, 0, 10 );
double min = minimizer.Minimize( bracket );
```

Code Example – VB minimization

```Dim Tol As Double = "1e-9"
Dim MaxIter As Integer = 25
Dim Minimizer As New BrentMinimizer(Tol, MaxIter)
Dim Bracket As New Bracket(F, 0, 10)
Dim Min As Double = Minimizer.Minimize(Bracket)
```

Top

Top