Extreme Optimization > QuickStart Samples > Elementary Functions QuickStart Sample (C#)

Extreme Optimization QuickStart Samples

Elementary Functions QuickStart Sample (C#)

Illustrates the use of the elementary functions implemented by the Elementary class (Extreme.Mathematics namespace) in C#.

VB.NET code Back to QuickStart Samples

using System;

namespace Extreme.Mathematics.QuickStart.CSharp
{
    // We use many classes from the Extreme.Mathematics namespace.
    using Extreme.Mathematics;

    /// <summary>
    /// Illustrates the use of the elementary functions implemented
    /// by the ElementaryFunctions class in the Extreme.Mathematics.Curve namespace of 
    /// the Extreme Optimization Mathematics Library for .NET.
    /// </summary>
    class ElementaryFunctionsSample
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // This QuickStart sample deals with elementary 
            // functions, implemented in the ElementaryFunctions class.

            //
            // ElementaryFunctions functions
            //

            // Evaluating Log(1+x) directly causes significant
            // round-off error when x is close to 0. The
            // Log1PlusX function allows high precision evaluation
            // of this expression for values of x close to 0:
            Console.WriteLine("Logarithm of 1+1e-12");
            Console.WriteLine("  Math.Log: {0}", 
                Math.Log(1+1e-12));
            Console.WriteLine("  Log1PlusX: {0}", 
                ElementaryFunctions.Log1PlusX(1e-12));

            // In a similar way, Exp(x) - 1 has a variant, 
            // ExpXMinus1, for values of x close to 0:
            Console.WriteLine("Exponential of 1e-12 minus 1.");
            Console.WriteLine("  Math.Exp: {0}", 
                Math.Exp(1e-12) - 1);
            Console.WriteLine("  ExpMinus1: {0}", 
                ElementaryFunctions.ExpMinus1(1e-12));

            // The hypotenuse of two numbers that are very large
            // may cause an overflow when not evaluated properly:
            Console.WriteLine("Hypotenuse:");
            double a = 3e200;
            double b = 4e200;
            Console.Write("  Simple method: ");
            try
            {
                double sumOfSquares = a*a + b*b;
                Console.WriteLine(Math.Sqrt(sumOfSquares));
            }
            catch (OverflowException)
            {
                Console.WriteLine("Overflow!");
            }
            Console.WriteLine("  ElementaryFunctions.Hypot: {0}",
                ElementaryFunctions.Hypot(a, b));

            // Raising numbers to integer powers is much faster
            // than raising numbers to real numbers. The
            // overloaded Pow method implements this:
            Console.WriteLine("2.5^19 = {0}", ElementaryFunctions.Pow(2.5, 19));
            // You can raise numbers to negative integer powers
            // as well:
            Console.WriteLine("2.5^-19 = {0}", ElementaryFunctions.Pow(2.5,-19));

            Console.Write("Press Enter key to exit...");
            Console.ReadLine();
        }
    }
}

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