Matrix Math Example

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 complete reference information about the MWArray class hierarchy, see the MWArray Class Library Reference (available online only).

• 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.

Back to Top

Procedure

1. 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\VS8\NET\MatrixMathExample
      

   2. At the MATLAB command prompt, cd to the new MatrixMathExample subfolder in your work folder.

2. 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\.

3. While in MATLAB, issue the following command to open the Deployment Tool:

   deploytool

4. Build the .NET component. See the instructions in Building Your Component for more details. Use the following information:

   Project Name	MatrixMathComp
   Class Name	Factor
   Files to compile	cholesky.mludecomp.mqrdecomp.m

5. 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

   // *******************************************************************************
   //
   // MatrixMathApp.css
   // This example demonstrates how to use MATLAB Builder NE to build a component 
   // that returns multiple results and optionally uses sparse matrices for 
   // arguments.
   // Copyright 2001-2009 The MathWorks, Inc.
   //
   // *******************************************************************************
   
   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.

6. 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 MATLAB 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.

   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.)

7. Build and run the application in Visual Studio .NET.

Back to Top

MATLAB Functions to Be Encapsulated

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

 cholesky.m

function [L] = Cholesky(A)
%CHOLESKY Cholesky factorization of A.
%   L= CHOLESKY(A) returns the Cholesky factorization of A.
%   This file is used as an example for the .NET Builder
%   Language product.

%   Copyright 2001-2003 The MathWorks, Inc.
%   $Revision: 1.1.4.49 $  $Date$

    L = chol(A);

 ludecomp.m

function [L,U] = LUDecomp(A)
%LUDECOMP LU factorization of A.
%   [L,U]= LUDECOMP(A) returns the LU factorization of A.
%   This file is used as an example for the .NET Builder
%   Language product.

%   Copyright 2001-2003 The MathWorks, Inc.
%   $Revision: 1.1.4.49 $  $Date$

    [L,U] = lu(A);

 qrdecomp.m

function [Q,R] = QRDecomp(A)
%QRDECOMP QR factorization of A.
%   [Q,R]= QRDECOMP(A) returns the QR factorization of A.
%   This file is used as an example for the .NET Builder
%   Language product.

%   Copyright 2001-2003 The MathWorks, Inc.
%   $Revision: 1.1.4.49 $  $Date$

    [Q,R] = qr(A);

Back to Top

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.

Back to Top

Spectral Analysis Example

Phonebook Example

Recommended Products

• MATLAB
• Signal Processing Toolbox
• Optimization Toolbox
• Statistics Toolbox
• Control System Toolbox

Get MATLAB trial software

Includes the most popular MATLAB recorded presentations with Q&A sessions led by MATLAB experts.

Get the Interactive Kit