Extreme Optimization >
Mathematics Library for .NET >
QuickStart Samples >
OptimizationInND QuickStart Sample (VB.NET)
Extreme Optimization Mathematics Library for .NET
OptimizationInND QuickStart Sample (VB.NET)
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 Back
to QuickStart Samples
' The optimization classes reside in the
' Extreme.Mathematics.Optimization namespace.
Imports Extreme.Mathematics.Optimization
' Function delegates reside in the Extreme.Mathematics
' namespace.
Imports Extreme.Mathematics
' Vectors reside in the Extreme.Mathematics.LinearAlgebra
' namespace.
Imports Extreme.Mathematics.LinearAlgebra
Namespace Extreme.Mathematics.QuickStart.VB
' Illustrates unconstrained optimization in multiple dimensions
' using classes in the Extreme.Mathematics.Optimization
' namespace of the Extreme Optimization Mathematics Library
' for .NET.
Module NewtonEquationSolver
Sub Main()
'
' Objective function
'
' The objective function must be supplied as a
' MultivariateRealFunction delegate. This is a method
' that takes one Vector argument and returns a real number.
' See the end of this sample for definitions of the methods
' that are referenced here.
Dim f As MultivariateRealFunction = _
New MultivariateRealFunction(AddressOf fRosenbrock)
' The gradient of the objective function can be supplied either
' as a MultivariateVectorFunction delegate, or a
' MultivariateVectorFunction delegate. The former takes
' one vector argument and returns a vector. The latter
' takes a second vector argument, which is an existing
' vector that is used to return the result.
Dim g As FastMultivariateVectorFunction = _
New FastMultivariateVectorFunction(AddressOf gRosenbrock)
' The initial values are supplied as a vector:
Dim initialGuess As GeneralVector = New GeneralVector(-1.2, 1)
' The actual solution is (1, 1).
'
' Quasi-Newton methods: BFGS and DFP
'
' For most purposes, the quasi-Newton methods give
' excellent results. There are two variations: DFP and
' BFGS. The latter gives slightly better results.
' Which method is used, is specified by a constructor
' parameter of type QuasiNewtonMethod:
Dim bfgs As QuasiNewtonOptimizer = _
New QuasiNewtonOptimizer(QuasiNewtonMethod.Bfgs)
bfgs.InitialGuess = initialGuess
bfgs.ExtremumType = ExtremumType.Minimum
' Set the ObjectiveFunction:
bfgs.ObjectiveFunction = f
' Set either the GradientFunction or FastGradientFunction:
bfgs.FastGradientFunction = g
' The FindExtremum method does all the hard work:
bfgs.FindExtremum()
Console.WriteLine("BFGS Method:")
Console.WriteLine(" Solution: {0}", bfgs.Extremum)
Console.WriteLine(" Estimated error: {0}", bfgs.EstimatedError)
Console.WriteLine(" # iterations: {0}", bfgs.IterationsNeeded)
' Optimizers return the number of function evaluations
' and the number of gradient evaluations needed:
Console.WriteLine(" # function evaluations: {0}", _
bfgs.EvaluationsNeeded)
Console.WriteLine(" # gradient evaluations: {0}", _
bfgs.GradientEvaluationsNeeded)
'
' Conjugate Gradient methods
'
' Conjugate gradient methods exist in three variants:
' Fletcher-Reeves, Polak-Ribiere, and positive Polak-Ribiere.
' Which method is used, is specified by a constructor
' parameter of type ConjugateGradientMethod:
Dim cg As ConjugateGradientOptimizer = _
New ConjugateGradientOptimizer( _
ConjugateGradientMethod.PositivePolakRibiere)
' Everything else works as before:
cg.ObjectiveFunction = f
cg.FastGradientFunction = g
cg.InitialGuess = initialGuess
cg.FindExtremum()
Console.WriteLine("Conjugate Gradient Method:")
Console.WriteLine(" Solution: {0}", cg.Extremum)
Console.WriteLine(" Estimated error: {0}", cg.EstimatedError)
Console.WriteLine(" # iterations: {0}", cg.IterationsNeeded)
Console.WriteLine(" # function evaluations: {0}", _
cg.EvaluationsNeeded)
Console.WriteLine(" # gradient evaluations: {0}", _
cg.GradientEvaluationsNeeded)
'
' Powell's method
'
' Powell's method is a conjugate gradient method that
' does not require the derivative of the objective function.
' It is implemented by the PowellOptimizer class:
Dim pw As PowellOptimizer = New PowellOptimizer
pw.InitialGuess = initialGuess
' Powell's method does not use derivatives:
pw.ObjectiveFunction = f
pw.FindExtremum()
Console.WriteLine("Powell's Method:")
Console.WriteLine(" Solution: {0}", pw.Extremum)
Console.WriteLine(" Estimated error: {0}", pw.EstimatedError)
Console.WriteLine(" # iterations: {0}", pw.IterationsNeeded)
Console.WriteLine(" # function evaluations: {0}", _
pw.EvaluationsNeeded)
Console.WriteLine(" # gradient evaluations: {0}", _
pw.GradientEvaluationsNeeded)
'
' Nelder-Mead method
'
' Also called the downhill simplex method, the method of Nelder
' and Mead is useful for functions that are not tractable
' by other methods. For example, other methods
' may fail if the objective function is not continuous.
' Otherwise it is much slower than other methods.
' The method is implemented by the NelderMeadOptimizer class:
Dim nm As NelderMeadOptimizer = New NelderMeadOptimizer
' The class has three special properties, that help determine
' the progress of the algorithm. These parameters have
' default values and need not be set explicitly.
nm.ContractionFactor = 0.5
nm.ExpansionFactor = 2
nm.ReflectionFactor = -2
' Everything else is the same.
nm.SolutionTest.Tolerance = 0.000000000000001
nm.InitialGuess = initialGuess
' The method does not use derivatives:
nm.ObjectiveFunction = f
nm.FindExtremum()
Console.WriteLine("Nelder-Mead Method:")
Console.WriteLine(" Solution: {0}", nm.Extremum)
Console.WriteLine(" Estimated error: {0}", nm.EstimatedError)
Console.WriteLine(" # iterations: {0}", nm.IterationsNeeded)
Console.WriteLine(" # function evaluations: {0}", _
nm.EvaluationsNeeded)
Console.Write("Press Enter key to exit...")
Console.ReadLine()
End Sub
' The famous Rosenbrock test function.
Function fRosenbrock(ByVal x As Vector) As Double
Dim p As Double = (1 - x(0))
Dim q As Double = x(1) - x(0) * x(0)
Return p * p + 105 * q * q
End Function
' Gradient of the Rosenbrock test function.
Function gRosenbrock(ByVal x As Vector, ByVal f As Vector) As Vector
' Always assume that the second argument may be null:
If (f Is Nothing) Then
f = New GeneralVector(2)
End If
Dim p As Double = (1 - x(0))
Dim q As Double = x(1) - x(0) * x(0)
f(0) = -2 * p - 420 * x(0) * q
f(1) = 210 * q
Return f
End Function
End Module
End Namespace
Copyright 2004-2008,
Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M
Sharp are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, Visual
Studio.NET, and the Visual Studio Logo are registered trademarks of Microsoft Corporation