Assign Multiple MATLAB Functions to Java Class

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

In this example, you perform the following steps:

1. Assign more than one MATLAB function to a generated class.

2. Manually handle native memory management.

3. Access the MATLAB functions in a Java application (getfactor.java) by instantiating Factor and using the MWArray class library to handle data conversion.

4. Build and run the MatrixMathDemoApp application.

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\javabuilder\Examples\MatrixMathExample\MatrixMathDemoComp\
Java Code Location	matlabroot\toolbox\javabuilder\Examples\MatrixMathExample\MatrixMathDemoJavaApp\getfactor.java

Procedure

1. Copy the MatrixMathExample folder that ships with MATLAB to your work folder:

   copyfile(fullfile(matlabroot,'toolbox','javabuilder','Examples','MatrixMathExample'),'MatrixMathExample')

   At the MATLAB command prompt, navigate to the new MatrixMathExample\MatrixMathDemoComp subfolder in your work folder.

2. If you have not already done so, set up your Java development environment. For details, see Configure Your Environment for Generating Java Packages.

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

4. Build the Java package with the Library Compiler app or compiler.build.javaPackage using the following information:

   Field	Value
   Library Name	factormatrix
   Class Name	factor
   Files to Compile	cholesky    ludecomp    qrdecomp

   For example, if you are using compiler.build.javaPackage, type:

   buildResults = compiler.build.javaPackage(["cholesky.m","ludecomp.m","qrdecomp.m"], ...
   'PackageName','factormatrix', ...
   'ClassName','factor');

   For more details, see the instructions in Generate Java Package and Build Java Application.

5. Write source code for an application that accesses the MATLAB functions.

   The sample application for this example is in MatrixMathExample\MatrixMathDemoJavaApp\getfactor.java.

    getfactor.java

   /* Necessary package imports */
   import com.mathworks.toolbox.javabuilder.*;
   import factormatrix.*;
   
   /*
    * getfactor class computes cholesky, LU, and QR 
    * factorizations of a finite difference matrix
    * of order N. The value of N is passed on the
    * command line. If a second command line arg
    * is passed with the value of "sparse", then
    * a sparse matrix is used.
    */
   class getfactor
   {
      public static void main(String[] args)
      {
         MWNumericArray a = null;   /* Stores matrix to factor */
         Object[] result = null;    /* Stores the result */
         factor theFactor = null;   /* Stores factor class instance */
   
         try
         {
            /* If no input, exit */
            if (args.length == 0)
            {
               System.out.println("Error: must input a positive integer");
               return;
            }
   
            /* Convert input value */
            int n = Integer.valueOf(args[0]).intValue();
   
            if (n <= 0)
            {
               System.out.println("Error: must input a positive integer");
               return;
            }
   
            /*
             * Allocate matrix. If second input is "sparse"
             * allocate a sparse array 
             */
            int[] dims = {n, n};
   
            if (args.length > 1 && args[1].equals("sparse"))
               a = MWNumericArray.newSparse(dims[0], dims[1],n+2*(n-1), 
                                     MWClassID.DOUBLE, MWComplexity.REAL);
            else
               a = MWNumericArray.newInstance(dims,MWClassID.DOUBLE, MWComplexity.REAL);
   
            /* Set matrix values */
            int[] index = {1, 1};
   
            for (index[0] = 1; index[0] <= dims[0]; index[0]++)
            {
               for (index[1] = 1; index[1] <= dims[1]; index[1]++)
               {
                  if (index[1] == index[0])
                     a.set(index, 2.0);
                  else if (index[1] == index[0]+1 || index[1] == index[0]-1)
                     a.set(index, -1.0);
               }
            }
   
            /* Create new factor object */
            theFactor = new factor();
   
            /* Print original matrix */
            System.out.println("Original matrix:");
            System.out.println(a);
   
            /* Compute cholesky factorization and print results. */
            result = theFactor.cholesky(1, a);
            System.out.println("Cholesky factorization:");
            System.out.println(result[0]);
            MWArray.disposeArray(result);
   
            /* Compute LU factorization and print results. */
            result = theFactor.ludecomp(2, a);
            System.out.println("LU factorization:");
            System.out.println("L matrix:");
            System.out.println(result[0]);
            System.out.println("U matrix:");
            System.out.println(result[1]);
            MWArray.disposeArray(result);
   
            /* Compute QR factorization and print results. */
            result = theFactor.qrdecomp(2, a);
            System.out.println("QR factorization:");
            System.out.println("Q matrix:");
            System.out.println(result[0]);
            System.out.println("R matrix:");
            System.out.println(result[1]);
         }
   
         catch (Exception e)
         {
            System.out.println("Exception: " + e.toString());
         }
   
         finally
         {
            /* Free native resources */
            MWArray.disposeArray(a);
            MWArray.disposeArray(result);
            if (theFactor != null)
               theFactor.dispose();
         }
      }
   }

   This statement creates an instance of the class factor:

   theFactor = new factor();
   

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

   result = theFactor.cholesky(1, a);
   ...
   result = theFactor.ludecomp(2, a);
   ...
   result = theFactor.qrdecomp(2, a);
   ...

6. In MATLAB, navigate to the MatrixMathDemoJavaApp folder.

7. Copy the generated factormatrix.jar package into this folder.

   • If you used compiler.build.javaPackage, type:

     copyfile(fullfile('..','MatrixMathDemoComp','factormatrixjavaPackage','factormatrix.jar'))

   • If you used the Library Compiler, type:

     copyfile(fullfile('..','MatrixMathDemoComp','factormatrix','for_testing','factormatrix.jar'))

8. In a command prompt window, cd to the MatrixMathDemoJavaApp folder.

9. Compile the getfactor application using javac.

   • On Windows^®, type:

     javac -classpath "matlabroot\toolbox\javabuilder\jar\javabuilder.jar";.\factormatrix.jar getfactor.java

   • On UNIX^®, type:

     javac -classpath "matlabroot/toolbox/javabuilder/jar/javabuilder.jar":./factormatrix.jar getfactor.java

   Replace matlabroot with the path to your MATLAB or MATLAB Runtime installation folder. For example, on Linux^®, the path may be /usr/local/MATLAB/R2024b.

10. Run the getfactor application using a nonsparse matrix.

    • On Windows, type:

      java -classpath .;"matlabroot\toolbox\javabuilder\jar\javabuilder.jar";.\factormatrix.jar getfactor 4

    • On UNIX, type:

      java -classpath .:"matlabroot/toolbox/javabuilder/jar/javabuilder.jar":./factormatrix.jar getfactor 4

    Note

    If you are running the application on the Mac 64-bit platform, you must add the -d64 flag in the Java command.

 Output for Nonsparse Matrix

Original matrix:
     2    -1     0     0
    -1     2    -1     0
     0    -1     2    -1
     0     0    -1     2
Cholesky factorization:
    1.4142   -0.7071         0         0
         0    1.2247   -0.8165         0
         0         0    1.1547   -0.8660
         0         0         0    1.1180


LU factorization:
L matrix:
    1.0000         0         0         0
   -0.5000    1.0000         0         0
         0   -0.6667    1.0000         0
         0         0   -0.7500    1.0000


U matrix:
    2.0000   -1.0000         0         0
         0    1.5000   -1.0000         0
         0         0    1.3333   -1.0000
         0         0         0    1.2500


QR factorization:
Q matrix:
   -0.8944   -0.3586   -0.1952    0.1826
    0.4472   -0.7171   -0.3904    0.3651
         0    0.5976   -0.5855    0.5477
         0         0    0.6831    0.7303


R matrix:
   -2.2361    1.7889   -0.4472         0
         0   -1.6733    1.9124   -0.5976
         0         0   -1.4639    1.9518
         0         0         0    0.9129

To run the same program for a sparse matrix, use the same command and add the string sparse at the end. For example, on Windows, type:

java -classpath .;"matlabroot\toolbox\javabuilder\jar\javabuilder.jar";.\factormatrix.jar getfactor 4 sparse

 Output for Sparse Matrix

Original 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 getfactor Program

The getfactor program takes one or two arguments from standard input. 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 to standard output.

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