New Version 6.0!

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

Download now!

QuickStart Samples

Linear Equations QuickStart Sample (C#)

Illustrates how to solve systems of simultaneous linear equations in C#.

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

using System;

namespace Extreme.Numerics.QuickStart.CSharp
{
    using Extreme.Mathematics;

    /// <summary>
    /// Illustrates solving systems of simultaneous linear
    /// equations using the DenseMatrix and LUDecomposition classes 
    /// in the Extreme.Mathematics.LinearAlgebra namespace of the Extreme 
    /// Optimization Mathematics Library for .NET.
    /// </summary>
    class LinearEquations
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // A system of simultaneous linear equations is
            // defined by a square matrix A and a right-hand
            // side B, which can be a vector or a matrix.
            //
            // You can use any matrix type for the matrix A.
            // The optimal algorithm is automatically selected.

            // Let's start with a general matrix:
            var m = Matrix.Create(4, 4, new double[]
                {
                    1, 1, 1, 1,
                    1, 2, 3, 4,
                    1, 4, 9, 16,
                    1, 2, 1, 2
                }, MatrixElementOrder.ColumnMajor);
            var b1 = Vector.Create(1.0, 3.0, 6.0, 3.0);
            var b2 = Matrix.Create(4, 2, new double[]
                {
                    1, 3, 6, 3,
                    2, 3, 5, 8
                }, MatrixElementOrder.ColumnMajor);
            Console.WriteLine("m = {0:F4}", m);
            
            //
            // The Solve method
            //

            // The following solves m x = b1. The second 
            // parameter specifies whether to overwrite the
            // right-hand side with the result.
            var x1 = m.Solve(b1, false);
            Console.WriteLine("x1 = {0:F4}", x1);
            // If the overwrite parameter is omitted, the
            // right-hand-side is overwritten with the solution:
            m.Solve(b1);
            Console.WriteLine("b1 = {0:F4}", b1);
            // You can solve for multiple right hand side 
            // vectors by passing them in a DenseMatrix:
            var x2 = m.Solve(b2, false);
            Console.WriteLine("x2 = {0:F4}", x2);
            
            //
            // Related Methods
            //

            // You can verify whether a matrix is singular
            // using the IsSingular method:
            Console.WriteLine("IsSingular(m) = {0}",
                m.IsSingular());
            // The inverse matrix is returned by the Inverse
            // method:
            Console.WriteLine("Inverse(m) = {0:F4}", m.GetInverse());
            // The determinant is also available:
            Console.WriteLine("Det(m) = {0:F4}", m.GetDeterminant());
            // The condition number is an estimate for the
            // loss of precision in solving the equations
            Console.WriteLine("Cond(m) = {0:F4}", m.EstimateConditionNumber());
            Console.WriteLine();

            //
            // The LUDecomposition class
            //

            // If multiple operations need to be performed
            // on the same matrix, it is more efficient to use
            // the LUDecomposition class. This class does the
            // bulk of the calculations only once.
            Console.WriteLine("Using LU Decomposition:");
            // The constructor takes an optional second argument
            // indicating whether to overwrite the original
            // matrix with its decomposition:
            var lu = m.GetLUDecomposition(false);
            // All methods mentioned earlier are still available:
            x2 = lu.Solve(b2, false);
            Console.WriteLine("x2 = {0:F4}", x2);
            Console.WriteLine("IsSingular(m) = {0}",
                lu.IsSingular());
            Console.WriteLine("Inverse(m) = {0:F4}", lu.GetInverse());
            Console.WriteLine("Det(m) = {0:F4}", lu.GetDeterminant());
            Console.WriteLine("Cond(m) = {0:F4}", lu.EstimateConditionNumber());
            // In addition, you have access to the
            // components, L and U of the decomposition.
            // L is lower unit-triangular:
            Console.WriteLine("  L = {0:F4}", lu.LowerTriangularFactor);
            // U is upper triangular:
            Console.WriteLine("  U = {0:F4}", lu.UpperTriangularFactor);

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