Extreme Optimization > QuickStart Samples > Optimization In One Dimension QuickStart Sample (C#)

Extreme Optimization QuickStart Samples

Optimization In One Dimension QuickStart Sample (C#)

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

VB.NET code Back to QuickStart Samples

using System;

namespace Extreme.Mathematics.QuickStart.CSharp
{
    // The optimization classes resides in the 
    // Extreme.Mathematics.EquationSolvers namespace.
    using Extreme.Mathematics.Optimization;
    // Function delegates reside in the Extreme.Mathematics
    // namespace.
    using Extreme.Mathematics;

    /// <summary>
    /// Illustrates the use of the Brent and Golden Section optimizers
    /// in the Extreme.Mathematics.Optimization namespace of the
    /// Extreme Optimization Mathematics Library for .NET.
    /// </summary>
    class OptimizationIn1D
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // 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 RealFunction. 
            // For more information about this delegate, see the
            // FunctionDelegates QuickStart sample.
            RealFunction f1 = new RealFunction(TestFunction1);
            RealFunction f2 = new RealFunction(TestFunction2);

            //
            // Brent's algorithm
            //

            // Now let's create the BrentOptimizer object.
            BrentOptimizer optimizer = 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 (!optimizer.IsBracketValid)
                throw new Exception
                    ("An interval containing a minimum was not found.");

            // 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
            // Result property.
            Console.WriteLine("  Minimum: {0}", optimizer.Result);
            double exactResult = Math.Sqrt(2/3.0);
            double result = (double)optimizer.Result;
            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:
            GoldenSectionOptimizer optimizer2 = 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();
        }

        // Minimum at x = Sqrt(2/3) = 0.816496580927726
        static double TestFunction1(double x)
        {
            return x*x*x - 2*x - 5;
        }

        // Maximum at x = 0.35
        static double TestFunction2(double x)
        {
            return 1/Math.Exp(x*x - 0.7*x +0.2);
        }
    }
}

Copyright 2004-2007, 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, and Visual Studio.NET are registered trademarks of Microsoft Corporation