Extreme Optimization > QuickStart Samples > Accessing Matrix Components QuickStart Sample (C#)

Extreme Optimization QuickStart Samples

Accessing Matrix Components QuickStart Sample (C#)

Illustrates different ways of iterating through the rows and columns of a matrix using classes in the Extreme.Mathematics.LinearAlgebra namespace in C#.

VB.NET code Back to QuickStart Samples

using System;

namespace Extreme.Mathematics.QuickStart.CSharp
{
    // The Matrix and Vector classes resides in the 
    // Extreme.Mathematics.LinearAlgebra namespace.
    using Extreme.Mathematics.LinearAlgebra;

    /// <summary>
    /// Illustrates accessing matrix components and iterating 
    /// through the rows and columns of a matrix. Matrix classes
    /// reside in the Extreme.Mathematics.LinearAlgebra namespace.
    /// </summary>
    class AccessingMatrixComponents
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // We'll work with this matrix:
            Matrix m = new GeneralMatrix(2, 3, new double[] {1, 2, 3, 4, 5, 6});

            //
            // Individual components
            //
            // The Matrix class has an indexer property that takes two arguments:
            // the row and column index. Both are zero based.
            Console.WriteLine("m[1,1] = {0}", m[1, 1]);

            //
            // Rows and columns
            //

            // Indexed range access

            // The indexer property is overloaded to allow for direct indexed access 
            // to complete or partial rows or columns.

            Vector row1 = m[0, new Range(1, 2)];
            // This prints "[3, 5]":
            Console.WriteLine("row1 = {0}", row1);

            // The special range Range.All lets you access an entire row
            // or column without having to specify any details about the range.
            Vector row2 = m[1, Range.All];
            // This prints "[2, 4, 6]":
            Console.WriteLine("row1 = {0}", row2);
            Vector column1 = m[Range.All, 0];
            // This prints "[1, 2]":
            Console.WriteLine("column1 = {0}", column1);

            // We can assign to rows and columns, too:
            m[Range.All, 0] = row2;
            // This prints "[[3, 3, 5] [5, 4, 6]]"
            Console.WriteLine("m = {0}", m);

            // GetRow and GetColumn provide an alternate mechanism 
            // for achieving the same result.

            // Passing just one parameter retrieves the specified row or column:
            row1 = m.GetRow(1);
            // This prints "[2, 4, 6]":
            Console.WriteLine("row1 = {0}", row1);
            column1 = m.GetColumn(0);
            // This prints "[1, 2]":
            Console.WriteLine("column1 = {0}", column1);

            // You can also pass a start and end index:
            row2 = m.GetRow(0, 1, 2);
            // This prints "[3, 5]":
            Console.WriteLine("row2 = {0}", row2);

            // We can assign to rows and columns, too, using CopyTo:
            row2.CopyTo(m.GetColumn(0));
            // This prints "[[3, 3, 5] [5, 4, 6]]"
            Console.WriteLine("m = {0}", m);

            // Enumeration

            // The Rows and Columns methods allow you to enumerate over 
            // the rows and columns of a matrix.

            // For example: this calculates the sum of the absolute values
            // of the components of the matrix m:
            double sum = 0;
            foreach(Vector column in m.Columns )
                sum += column.OneNorm();
    
            //
            // Accessing diagonals
            //

            // Diagonals are retrieved using the GetDiagonal method:
            Vector mainDiagonal = m.GetDiagonal();
            // An optional parameter specifies which diagonal:
            //   n < 0 means subdiagonal
            //   n > 0 means nth superdiagonal:
            Vector superDiagonal = m.GetDiagonal(1);

            //
            // Accessing submatrices
            //

            // Indexed range access
            
            // A fourth overload of the indexer property lets you 
            // extract a part of a matrix. Both parameters are Range 
            // structures:
            Matrix a = new GeneralMatrix(10, 10);
            // Extract the 2nd to the 5th row of m:
            Matrix a1 = a[new Range(1, 4), Range.All];
            // Extract the odd columns:
            Matrix a2 = a[Range.All, new Range(1, 10, 2)];
            // Extract the 4x4 leading submatrix of m:
            Matrix a3 = a[new Range(0, 3), new Range(0, 3)];

            // You can also assign to submatrices:
            Matrix identity5 = GeneralMatrix.GetIdentity(5);
            a[new Range(0, 4), new Range(5, 9)] = identity5;
            a[new Range(5, 9), new Range(0, 4)] = identity5;

            // The same results can be achieved with the GetSubmatrix method.

            // Extract the 2nd to the 5th row of m. 
            // Start and end columns are supplied manually.
            Matrix a4 = a.GetSubmatrix(1, 4, 0, 9);
            // Extract the odd columns:
            // Here we need to supply the transpose parameter.
            Matrix a5 = a.GetSubmatrix(0, 9, 1, 1, 10, 2, 
                TransposeOperation.None);
            // Extract the 4x4 leading submatrix of m.
            // And let's get its transpose, just because we can.
            // We need to specify the row and column stride:
            Matrix a6 = a.GetSubmatrix(0, 3, 1, 0, 3, 1,
                TransposeOperation.Transpose);

            // You can still assign to submatrices, using the
            // CopyTo method:
            identity5.CopyTo(a.GetSubmatrix(0, 4, 5, 9));
            identity5.CopyTo(a.GetSubmatrix(5, 9, 0, 4));
        }
    }
}

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