New Version 6.0!

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

Download now!

QuickStart Samples

Advanced Polynomials QuickStart Sample (C#)

Illustrates more advanced uses of the Polynomial class, including real and complex root finding, calculating least squares polynomials and polynomial arithmetic in C#.

Visual Basic code F# code IronPython code Back to QuickStart Samples

using System;

namespace Extreme.Numerics.QuickStart.CSharp
{
    // The Complex<T> structure resides in the Extreme.Mathematics namespace.
    using Extreme.Mathematics;
    // The Polynomial class resides in the Extreme.Mathematics.Curves namespace.
    using Extreme.Mathematics.Curves;

    /// <summary>
    /// Illustrates the more advanced uses of the Polynomial class 
    /// in the Extreme.Mathematics.Curve namespace of the Extreme Optimization 
    /// Mathematics Library for .NET.
    /// </summary>
    class AdvancedPolynomials
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // Basic operations on polynomials are covered in the
            // BasicPolynomials QuickStart Sample. This QuickStart
            // Sample focuses on more advanced topics, including
            // finding complex roots, calculating least-squares
            // polynomials, and polynomial arithmetic.

            // Index variable.
            int index;

            //
            // Complex<double> numbers and polynomials
            //

            Polynomial polynomial = new Polynomial(new Double[] {-2, 0, 1, 1});

            // The Polynomial class supports complex numbers
            // as arguments for polynomials. It does not support
            // polynomials with complex coefficients.
            //
            // For more about complex numbers, see the
            // ComplexNumbers QuickStart Sample.
            Complex<double> z1 = new Complex<double>(1, 2);

            // Polynomial provides variants of ValueAt and
            // SlopeAt for complex arguments:
            Console.WriteLine("polynomial.ComplexValueAt({0}) = {1}",
                z1, polynomial.ComplexValueAt(z1));
            Console.WriteLine("polynomial.ComplexSlopeAt({0}) = {1}",
                z1, polynomial.ComplexSlopeAt(z1));

            //
            // Real and complex roots
            //
            // Our polynomial has only one real root:
            double[] roots = polynomial.FindRoots();
            Console.WriteLine("Number of roots of polynomial1: {0}",
                roots.Length);
            Console.WriteLine("Value of root 1 = {0}", roots[0]);
            // The FindComplexRoots method returns all three
            // roots, two of which are complex:
            Complex<double>[] complexRoots = polynomial.FindComplexRoots();
            Console.WriteLine("Number of complex roots: {0}",
                complexRoots.Length);
            Console.WriteLine("Value of root 1 = {0}", 
                complexRoots[0]);
            Console.WriteLine("Value of root 2 = {0}", 
                complexRoots[1]);
            Console.WriteLine("Value of root 3 = {0}", 
                complexRoots[2]);

            //
            // Least squares polynomials
            //
            
            // Let's approximate 7 points on the unit circle
            // by a fourth degree polynomial in the least squares
            // sense.
            // First, we create two arrays containing the x and
            // y values of our data points:
            double[] xValues = new double[7];
            double[] yValues = new double[7];
            double angle = 0;
            for(index = 0; index < 7; index++)
            {
                xValues[index] = Math.Cos(angle);
                yValues[index] = -Math.Sin(angle);
                angle = angle + Constants.Pi / 6;
            }
            // Now we can find the least squares polynomial
            // by calling the ststic LeastSquaresFit method.
            // The last parameter is the degree of the desired
            // polynomial.
            Polynomial lsqPolynomial = 
                Polynomial.LeastSquaresFit(xValues, yValues, 4);
            // Note that, as expected, the odd coefficients
            // are close to zero.
            Console.WriteLine("Least squares fit: {0}", 
                lsqPolynomial.ToString());
            
            //
            // Polynomial arithmetic
            //

            // We can add, subtract, multiply and divide
            // polynomials using overloaded operators:
            Polynomial a = new Polynomial(new Double[] {4, -2, 4});
            Polynomial b = new Polynomial(new Double[] {-3, 1});

            Console.WriteLine("a = {0}", a.ToString());
            Console.WriteLine("b = {0}", b.ToString());
            Polynomial c = a + b;
            Console.WriteLine("a + b = {0}", c.ToString());
            c = a - b;
            Console.WriteLine("a - b = {0}", c.ToString());
            c = a * b;
            Console.WriteLine("a * b = {0}", c.ToString());
            c = a / b;
            Console.WriteLine("a / b = {0}", c.ToString());
            c = a % b;
            Console.WriteLine("a % b = {0}", c.ToString());
            // You can also calculate quotient and remainder
            // at the same time by calling the overloaded Divide
            // method:
            Polynomial d;
            c = Polynomial.Divide(a, b, out d);
            Console.WriteLine("Using Divide method:");
            Console.WriteLine("  a / b = {0}", c.ToString());
            Console.WriteLine("  a % b = {0}", d.ToString());

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