Multiple MATLAB Functions in a Component Class

Purpose

The purpose of the example is to show you the following:

How to assign more than one MATLAB^® function to a component class
How to access the component in a C# application (MatrixMathApp.cs) by instantiating Factor and using the MWArray class library to handle data conversion
Note
For information about these data conversion classes, see the MATLAB MWArray Class Library Reference, available in the matlabroot\help\dotnetbuilder\MWArrayAPI folder, where matlabroot represents your MATLAB installation folder
How to build and run the MatrixMathApp application, using the Visual Studio^® .NET development environment

This example builds a .NET component to perform matrix math. The example creates a program that 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.

Procedure

If you have not already done so, copy the files for this example as follows:
1. Copy the following folder that ships with the MATLAB product to your work folder:
```
matlabroot\toolbox\dotnetbuilder\Examples\VSVersion\NET\MatrixMathExample
```
2. At the MATLAB command prompt, cd to the new MatrixMathExample subfolder in your work folder.
Write the MATLAB functions as you would any MATLAB function.
The code for the cholesky, ludecomp, and qrdecomp functions is already in your work folder in MatrixMathExample\MatrixMathComp\.
From the MATLAB apps gallery, open the Library Compiler app.
Build the .NET component. See the instructions in Generate a .NET Assembly and Build a .NET Application for more details. Use the following information:

Project Name MatrixMathComp
Class Name Factor
Files to compile cholesky ludecomp qrdecomp

Write source code for an application that accesses the component.

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

The program listing is shown here.

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

The statement

 Factor factor= new Factor();

creates an instance of the class 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);
...

Note

See Understanding the MatrixMath Program for more details about the structure of this program.

Build the MatrixMathApp application using Visual Studio .NET.
1. 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 > Open Outside MATLAB.
2. Add a reference to the MWArray component, which is matlabroot\toolbox\dotnetbuilder\bin\architecture\framework_version \mwarray.dll. See Supported Microsoft .NET Framework Versions for a list of supported framework versions.
3. If necessary, add (or fix the location of) a reference to the MatrixMathComp component which you built in a previous step. (The component, MatrixMathComp.dll, is in the \MatrixMathExample\MatrixMathComp\x86\V2.0\Debug\distrib subfolder of your work area.)
Build and run the application in Visual Studio .NET.

MATLAB Functions to Be Encapsulated

The following code defines the MATLAB functions used in the example.

cholesky.m

ludecomp.m

qrdecomp.m

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.
Note
This optional as the garbage collector will automatically clean-up resources for you.

Documentation