New Version 6.0!

Try it for free with our fully functional 60-day trial version.

Download now!

QuickStart Samples

Optimization In One Dimension QuickStart Sample (Visual Basic)

Illustrates the use of the Brent and Golden Section optimizer classes in the Extreme.Mathematics.Optimization namespace for one-dimensional optimization in Visual Basic.

C# code F# code IronPython code Back to QuickStart Samples

Option Infer On

' The optimization classes resides in the 
' Extreme.Mathematics.EquationSolvers namespace.
Imports Extreme.Mathematics.Optimization
' Function delegates reside in the Extreme.Mathematics
' namespace.
Imports Extreme.Mathematics

Namespace Extreme.Numerics.QuickStart.VB
    ' Illustrates the use of the Brent and Golden Section optimizers
    ' in the Extreme.Mathematics.Optimization namespace of the
    ' Extreme Optimization Numerical Libraries for .NET.
    Module OptimizationIn1D

        Sub Main()
            ' Several algorithms exist for optimizing functions
            ' in one variable. The most common one is
            ' Brent's algorithm.

            ' The function we are trying to minimize is called the
            ' objective function and must be provided as a Func(Of Double, Double). 
            ' For more information about this delegate, see the
            ' FunctionDelegates QuickStart sample.
            Dim f1 As Func(Of Double, Double) = AddressOf TestFunction1
            Dim f2 As Func(Of Double, Double) = AddressOf TestFunction2

            '
            ' Brent's algorithm
            '

            ' Now let's create the BrentOptimizer object.
            Dim optimizer As BrentOptimizer = New BrentOptimizer

            ' Set the objective function:
            optimizer.ObjectiveFunction = f1
            ' Optimizers can find either a minimum or a maximum.
            ' Which of the two is specified by the ExtremumType
            ' property
            optimizer.ExtremumType = ExtremumType.Minimum

            ' The first phase is to find an interval that contains
            ' a local minimum. This is done by the FindBracket method.
            optimizer.FindBracket(0, 6)
            ' You can verify that an interval was found from the
            ' IsBracketValid property:
            If (Not optimizer.IsBracketValid) Then
                Throw New Exception("An interval containing a minimum was not found.")
            End If

            ' Finally, we can run the optimizer by calling the FindExtremum method:
            optimizer.FindExtremum()

            Console.WriteLine("Function 1: x^3 - 2x - 5")
            ' The Status property indicates
            ' the result of running the algorithm.
            Console.WriteLine("  Result: {0}", optimizer.Status)
            ' The result is available through the
            ' Extremum property.
            Console.WriteLine("  Minimum: {0}", optimizer.Extremum)
            Dim exactResult = Math.Sqrt(2 / 3.0)
            Dim result = optimizer.Extremum
            Console.WriteLine("  Exact minimum: {0}", exactResult)

            ' You can find out the estimated error of the result
            ' through the EstimatedError property:
            Console.WriteLine("  Estimated error: {0}", optimizer.EstimatedError)
            Console.WriteLine("  Actual error: {0}", Math.Abs(result - exactResult))
            Console.WriteLine("  # iterations: {0}", optimizer.IterationsNeeded)

            Console.WriteLine("Function 2: 1/Exp(x*x - 0.7*x +0.2)")
            ' You can also perform these calculations more directly 
            ' using the FindMinimum or FindMaximum methods. This implicitly
            ' calls the FindBracket method.
            result = optimizer.FindMaximum(f2, 0)
            Console.WriteLine("  Maximum: {0}", result)
            Console.WriteLine("  Actual maximum: {0}", 0.35)
            Console.WriteLine("  Estimated error: {0}", optimizer.EstimatedError)
            Console.WriteLine("  Actual error: {0}", result - 0.35)
            Console.WriteLine("  # iterations: {0}", optimizer.IterationsNeeded)

            '
            ' Golden section search
            '

            ' A slower but simpler algorithm for finding an extremum
            ' is the golden section search. It is implemented by the
            ' GoldenSectionMinimizer class:
            Dim optimizer2 As New GoldenSectionOptimizer

            Console.WriteLine("Using Golden Section optimizer:")
            result = optimizer2.FindMaximum(f2, 0)
            Console.WriteLine("  Maximum: {0}", result)
            Console.WriteLine("  Actual maximum: {0}", 0.35)
            Console.WriteLine("  Estimated error: {0}", optimizer2.EstimatedError)
            Console.WriteLine("  Actual error: {0}", result - 0.35)
            Console.WriteLine("  # iterations: {0}", optimizer2.IterationsNeeded)

            Console.Write("Press Enter key to exit...")
            Console.ReadLine()
        End Sub

        ' Minimum at x = Sqrt(2/3) = 0.816496580927726
        Function TestFunction1(ByVal x As Double) As Double
            Return x * x * x - 2 * x - 5
        End Function

        ' Maximum at x = 0.35
        Function TestFunction2(ByVal x As Double) As Double
            Return 1 / Math.Exp(x * x - 0.7 * x + 0.2)
        End Function

    End Module

End Namespace