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
    }
  }

Imports System

Imports MathWorks.MATLAB.NET.Utility
Imports MathWorks.MATLAB.NET.Arrays

Imports MatrixMathComp


Namespace MathWorks.Demo.MatrixMathApp

    ' <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 MatrixMathDemoApp

#Region " MAIN "

        ' <summary>
        ' The main entry point for the application.
        ' </summary>
        Shared Sub Main(ByVal args() As String)

            Dim makeSparse As Boolean = True
            Dim matrixOrder As Integer = 4

            Dim matrix As MWNumericArray = Nothing ' The matrix to factor

            Dim argOut As MWArray = Nothing   ' Stores single factorization result
            Dim argsOut() As MWArray = Nothing  ' Stores multiple factorization results

            Try
                ' If no argument specified, use defaults
                If (0 <> args.Length) Then
                    'Convert matrix order
                    matrixOrder = Int32.Parse(args(0))

                    If (0 > matrixOrder) Then
                        Throw New ArgumentOutOfRangeException("matrixOrder", matrixOrder, _
                         "Must enter a positive integer for the matrix order(N)")
                    End If

                    makeSparse = ((1 < args.Length) AndAlso (args(1).Equals("sparse")))
                End If

                ' Create the test matrix.  If the second argument 
                '   is "sparse", create a sparse matrix.
                matrix = IIf(makeSparse, _
                MWNumericArray.MakeSparse(matrixOrder, matrixOrder, 
                                            MWArrayComplexity.Real, 
                                         (matrixOrder + (2 * (matrixOrder - 1)))), _
                New MWNumericArray(MWArrayComplexity.Real, MWNumericType.Double, 
                                                     matrixOrder, matrixOrder))

                ' Initialize the test matrix
                For rowIdx As Integer = 1 To matrixOrder
                    For colIdx As Integer = 1 To matrixOrder
                        If rowIdx = colIdx Then
                            matrix(rowIdx, colIdx) = New MWNumericArray(2.0)
                        ElseIf colIdx = rowIdx + 1 Or colIdx = rowIdx - 1 Then
                            matrix(rowIdx, colIdx) = New MWNumericArray(-1.0)
                        End If
                    Next colIdx
                Next rowIdx

                ' Create a new factor object
                Dim factor As Factor = New Factor

                ' Print the test matrix
                Console.WriteLine("Test Matrix:{0}{1}{2}", Chr(10), matrix, Chr(10))

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

                Console.WriteLine("Cholesky Factorization:{0}{1}{2}", 
                     Chr(10), argOut, Chr(10))

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

                Console.WriteLine("LU Factorization:
                      {0}L Matrix:{1}{2}{3}U Matrix:{4}{5}{6}", Chr(10), Chr(10), 
                               argsOut(0), Chr(10), Chr(10), argsOut(1), Chr(10))

                MWNumericArray.DisposeArray(argsOut)

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

                Console.WriteLine("QR Factorization:
                      {0}Q Matrix:{1}{2}{3}R Matrix:{4}{5}{6}", Chr(10), Chr(10), 
                               argsOut(0), Chr(10), Chr(10), argsOut(1), Chr(10))

                Console.ReadLine()

            Catch exception As Exception

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

            Finally

                ' Free native resources
                If Not (matrix Is Nothing) Then
                    matrix.Dispose()
                End If
                If Not (argOut Is Nothing) Then
                    argOut.Dispose()
                End If

                MWNumericArray.DisposeArray(argsOut)
            End Try
        End Sub
#End Region
    End Class
End Namespace