Документация

using System;

using MathWorks.MATLAB.NET.Utility;
using MathWorks.MATLAB.NET.Arrays;

using MatrixMathComp;

namespace MathWorks.Examples.MatrixMath
{
  /// <summary>
  /// This application computes cholesky, LU, and QR factorizations of a finite 
  ///  difference matrix of order N.
  /// The order is passed into the application on the command line.   
  /// </summary>
  /// <remarks>
  /// Command Line Arguments:
  /// <newpara></newpara>
  /// args[0] - Matrix order(N)
  /// <newpara></newpara>
  /// args[1] - (optional) sparse; Use a sparse matrix
  /// </remarks>
  class MatrixMathApp
    {
      #region MAIN

      /// <summary>
      /// The main entry point for the application.
      /// </summary>
      [STAThread]
      static void Main(string[] args)
        {
          bool makeSparse= true;
          int matrixOrder= 4;

          MWNumericArray matrix= null; // The matrix to factor

          MWArray argOut= null;     // Stores single factorization result
          MWArray[] argsOut= null;  // Stores multiple factorization results

          try
            {
              // If no argument specified, use defaults
              if (0 != args.Length)
                {
                  // Convert matrix order
                  matrixOrder= Int32.Parse(args[0]);

                  if (0 >= matrixOrder)
                    {
                      throw new ArgumentOutOfRangeException("matrixOrder", matrixOrder, 
                       "Must enter a positive integer for the matrix order(N)");
                    } 

                  makeSparse= ((1 < args.Length) && (args[1].Equals("sparse")));
                }

              // Create the test matrix.  If the second argument is "sparse", 
              // create a sparse matrix.
			        matrix= (makeSparse)
				        ? MWNumericArray.MakeSparse(matrixOrder, matrixOrder, 
                     MWArrayComplexity.Real, (matrixOrder+(2*(matrixOrder-1))))
				        : new MWNumericArray(MWArrayComplexity.Real, 
                     MWNumericType.Double, matrixOrder, matrixOrder);

              // Initialize the test matrix
              for (int rowIdx= 1; rowIdx <= matrixOrder; rowIdx++)
                for (int colIdx= 1; colIdx <= matrixOrder; colIdx++)
                  if (rowIdx == colIdx)
                    matrix[rowIdx, colIdx]= 2.0;
                  else if ((colIdx == rowIdx+1) || (colIdx == rowIdx-1))
                    matrix[rowIdx, colIdx]= -1.0;

              // Create a new factor object
              Factor factor= new Factor();

              // Print the test matrix
              Console.WriteLine("Test Matrix:\n{0}\n", matrix);

              // Compute and print the cholesky factorization using the 
              // single output syntax
              argOut= factor.cholesky((MWArray)matrix);

              Console.WriteLine("Cholesky 
                 Factorization:\n{0}\n", argOut);

              // Compute and print the LU factorization using the multiple output syntax
              argsOut= factor.ludecomp(2, matrix);

              Console.WriteLine("LU Factorization:\nL 
                Matrix:\n{0}\nU Matrix:\n{1}\n", argsOut[0], 
                argsOut[1]);

              MWNumericArray.DisposeArray(argsOut);

              // Compute and print the QR factorization 
              argsOut= factor.qrdecomp(2, matrix);

              Console.WriteLine("QR Factorization:\nQ Matrix:\n{0}\nR Matrix:\n{1}\n", 
                argsOut[0], argsOut[1]);

              Console.ReadLine();
            }

          catch(Exception exception)
            {
              Console.WriteLine("Error: {0}", exception);
            }

          finally
            {
              // Free native resources
              if (null != (object)matrix) matrix.Dispose();
              if (null != (object)argOut) argOut.Dispose();

              MWNumericArray.DisposeArray(argsOut);
            }
        }

      #endregion
    }
  }