Assign Multiple MATLAB Functions in Component Class

This example shows you how to create a .NET matrix math program using multiple MATLAB^® functions.

In this example, you perform the following steps:

Assign more than one MATLAB function to a component class.
Access the component in a C# application (MatrixMathApp.cs) or a Visual Basic^® application (MatrixMathApp.vb) by instantiating Factor and using the MWArray class library to handle data conversion.
Build and run the MatrixMathApp application using the Visual Studio^® .NET development environment.

MatrixMathApp Application

The MatrixMathApp application performs Cholesky, LU, and QR factorizations on a simple tridiagonal matrix (finite difference matrix) with the following form:

A = [ 2 -1  0  0  0
     -1  2 -1  0  0
      0 -1  2 -1  0
      0  0 -1  2 -1
      0  0  0 -1  2 ]

You supply the size of the matrix on the command line, and the program constructs the matrix and performs the three factorizations. The original matrix and the results are printed to standard output. You may optionally perform the calculations using a sparse matrix by specifying the string "sparse" as the second parameter on the command line.

Files

MATLAB Functions	`cholesky.m` `ludecomp.m` `qrdecomp.m`
MATLAB Function Location	`matlabroot\toolbox\dotnetbuilder\Examples\VSVersion\NET\MatrixMathExample\MatrixMathComp\`
C# Code Location	`matlabroot\toolbox\dotnetbuilder\Examples\VSVersion\NET\MatrixMathExample\MatrixMathCSApp\MatrixMathApp.cs`
Visual Basic Code Location	`matlabroot\toolbox\dotnetbuilder\Examples\VSVersion\NET\MatrixMathExample\MatrixMathVBApp\MatrixMathApp.vb`

Procedure

Copy the following folder that ships with the MATLAB product to your work folder:
```
matlabroot\toolbox\dotnetbuilder\Examples\VSVersion\NET\MatrixMathExample
```
At the MATLAB command prompt, navigate to the new MatrixMathExample\MatrixMathComp subfolder in your work folder.

Examine the MATLAB functions cholesky.m, ludecomp.m, and qrdecomp.m.

function [L] = Cholesky(A)
    L = chol(A);

function [L,U] = LUDecomp(A)
    [L,U] = lu(A);

function [Q,R] = QRDecomp(A)

    [Q,R] = qr(A);

Build the .NET component with the Library Compiler app or compiler.build.dotNETAssembly using the following information:

Field Value
Library Name MatrixMathComp
Class Name Factor
Files to compile cholesky ludecomp qrdecomp

For example, if you are using compiler.build.dotNETAssembly, type:
```
buildResults = compiler.build.dotNETAssembly(["cholesky.m","ludecomp.m","qrdecomp.m"], ...
'AssemblyName','MatrixMathComp', ...
'ClassName','Factor');
```
For more details, see the instructions in Generate .NET Assembly and Build .NET Application.

Field	Value
Library Name	`MatrixMathComp`
Class Name	`Factor`
Files to compile	`cholesky` `ludecomp` `qrdecomp`

Decide whether you are using C# or Visual Basic to access the component.

If you are using C#, write source code for a C# application that accesses the component.

The sample application for this example is in MatrixMathExample\MatrixMathCSApp\MatrixMathApp.cs.

MatrixMathApp.cs

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

This statement creates an instance of the class Factor:

 Factor factor= new Factor();

The following statements call the methods that encapsulate the MATLAB functions:

argOut= factor.cholesky((MWArray)matrix);
...
argsOut= factor.ludecomp(2, matrix);
...
argsOut= factor.qrdecomp(2, matrix);
...

Visual Basic

If you are using Visual Basic, write source code for a Visual Basic application that accesses the component.

The sample application for this example is in MatrixMathExample\MatrixMathVBApp\MatrixMathApp.vb.

MatrixMathApp.vb

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

This statement creates an instance of the class Factor:

Dim factor As Factor = New Factor

The following statements call the methods that encapsulate the MATLAB functions:

argOut = factor.cholesky(matrix)

argsOut = factor.ludecomp(2, matrix)

argsOut = factor.qrdecomp(2, matrix)

Open the .NET project file that corresponds to your application language using Visual Studio.
- C#
  If you are using C#, the MatrixMathCSApp folder contains a Visual Studio .NET project file for this example. Open the project in Visual Studio .NET by double-clicking MatrixMathCSApp.csproj in Windows^® Explorer. You can also open it from the desktop by right-clicking MatrixMathCSApp.csproj and selecting Open Outside MATLAB.
- Visual Basic
  If you are using Visual Basic, the MatrixMathVBApp folder contains a Visual Studio .NET project file for this example. Open the project in Visual Studio .NET by double-clicking MatrixMathVBApp.vbproj in Windows Explorer. You can also open it from the desktop by right-clicking MatrixMathVBApp.vbproj and selecting Open Outside MATLAB.
Add a reference to your assembly file MatrixMathComp.dll located in the folder where you generated the assembly.

Add a reference to the MWArray API.

If MATLAB is installed on your system	`matlabroot\toolbox\dotnetbuilder\bin\win64\<framework_version>\MWArray.dll`
If MATLAB Runtime is installed on your system	`<MATLAB_RUNTIME_INSTALL_DIR>\toolbox\dotnetbuilder\bin\win64\<framework_version>\MWArray.dll`

Build and run the MatrixMathApp application in Visual Studio.

The program displays the following output:

Test Matrix:
   (1,1)        2
   (2,1)       -1
   (1,2)       -1
   (2,2)        2
   (3,2)       -1
   (2,3)       -1
   (3,3)        2
   (4,3)       -1
   (3,4)       -1
   (4,4)        2

Cholesky Factorization:
   (1,1)       1.4142
   (1,2)      -0.7071
   (2,2)       1.2247
   (2,3)      -0.8165
   (3,3)       1.1547
   (3,4)      -0.8660
   (4,4)       1.1180

LU Factorization:
L Matrix:
   (1,1)       1.0000
   (2,1)      -0.5000
   (2,2)       1.0000
   (3,2)      -0.6667
   (3,3)       1.0000
   (4,3)      -0.7500
   (4,4)       1.0000
U Matrix:
   (1,1)       2.0000
   (1,2)      -1.0000
   (2,2)       1.5000
   (2,3)      -1.0000
   (3,3)       1.3333
   (3,4)      -1.0000
   (4,4)       1.2500

QR Factorization:
Q Matrix:
   (1,1)      -0.8944
   (2,1)       0.4472
   (1,2)      -0.3586
   (2,2)      -0.7171
   (3,2)       0.5976
   (1,3)      -0.1952
   (2,3)      -0.3904
   (3,3)      -0.5855
   (4,3)       0.6831
   (1,4)       0.1826
   (2,4)       0.3651
   (3,4)       0.5477
   (4,4)       0.7303
R Matrix:
   (1,1)      -2.2361
   (1,2)       1.7889
   (2,2)      -1.6733
   (1,3)      -0.4472
   (2,3)       1.9124
   (3,3)      -1.4639
   (2,4)      -0.5976
   (3,4)       1.9518
   (4,4)       0.9129

Understanding the MatrixMath Program

The MatrixMath program takes one or two arguments from the command line. The first argument is converted to the integer order of the test matrix. If the string sparse is passed as the second argument, a sparse matrix is created to contain the test array. The Cholesky, LU, and QR factorizations are then computed and the results are displayed.

The main method has three parts:

The first part sets up the input matrix, creates a new factor object, and calls the cholesky, ludecomp, and qrdecomp methods. This part is executed inside of a try block. This is done so that if an exception occurs during execution, the corresponding catch block will be executed.
The second part is the catch block. The code prints a message to standard output to let the user know about the error that has occurred.
The third part is a finally block to manually clean up native resources before exiting. This is optional, as the garbage collector will automatically clean up resources for you.

Related Examples

More About

Convert Data Between .NET and MATLAB