Create Java Application with Multiple MATLAB Functions

This example shows how to create a Java^® application that uses multiple MATLAB^® functions to analyze a signal and then graph the result.

In this example, you perform the following steps:

1. Use MATLAB Compiler SDK™ to create a package containing a class that has a private method that is automatically encapsulated.

2. Access the MATLAB functions in a Java application, including use of the MWArray class hierarchy to represent data.

3. Build and run the application.

spectralanalysis Application

The spectralanalysis application analyzes a signal and graphs the result. The class fourier performs a fast Fourier transform (FFT) on an input data array. A method of this class, computefft, returns the results of that FFT as two output arrays—an array of frequency points and the power spectral density.

The second method, plotfft, graphs the returned data. These two methods, computefft and plotfft, encapsulate MATLAB functions.

Files

MATLAB Functions	computefft.m plotfft.m
MATLAB Function Location	matlabroot\toolbox\javabuilder\Examples\SpectraExample\SpectraDemoComp
Java Code Location	matlabroot\toolbox\javabuilder\Examples\SpectraExample\SpectraDemoJavaApp\powerspect.java

Procedure

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

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

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

2. Examine the MATLAB functions computefft.m and plotfft.m.

    computefft.m

   function [fftdata, freq, powerspect] = computefft(data, interval)
   if (isempty(data))
      fftdata = [];
      freq = [];
      powerspect = [];
      return;
   end
   
   if (interval <= 0)
      error('BuilderJA:Examples:samplingInterval','Sampling interval must be greater then zero');
      return;
   end
   
   fftdata = fft(data);
   freq = (0:length(fftdata)-1)/(length(fftdata)*interval);
   powerspect = abs(fftdata)/(sqrt(length(fftdata)));

    plotfft.m

   function [fftdata, freq, powerspect] = plotfft(data, interval)
   [fftdata, freq, powerspect] = computefft(data, interval);
   len = length(fftdata);
   if (len <= 0)
      return;
   end
   
   t = 0:interval:(len-1)*interval;
   subplot(2,1,1), plot(t, data)
   xlabel('Time'), grid on
   title('Time domain signal')
   subplot(2,1,2), plot(freq(1:len/2), powerspect(1:len/2))
   xlabel('Frequency (Hz)'), grid on
   title('Power spectral density')

3. Build the Java package with the Library Compiler app or compiler.build.javaPackage.

   Use the following information for your project:

   Project Name	spectralanalysis
   Class Name	fourier
   File to Compile	plotfft.m

   Note

   In this example, the application that uses the fourier class does not call computefft directly. The computefft method is required only by the plotfft method. You do not need to manually add the computefft function to the package, as the compiler automatically includes it during dependency analysis.

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

   buildResults = compiler.build.javaPackage('plotfft.m', ...
   'PackageName','spectralanalysis', ...
   'ClassName','fourier');

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

4. Write source code for a Java application that accesses the MATLAB functions.

   The sample application for this example is in SpectraExample\SpectraDemoJavaApp\powerspect.java.

    powerspect.java

   /* Necessary package imports */
   import com.mathworks.toolbox.javabuilder.*;
   import spectralanalysis.*;
   
   /*
    * powerspect class computes and plots the power
    * spectral density of an input signal.
    */
   class powerspect
   {
      public static void main(String[] args)
      {
         double interval = 0.01;     /* Sampling interval */
         int nSamples = 1001;        /* Number of samples */
         MWNumericArray data = null; /* Stores input data */
         Object[] result = null;     /* Stores result */
         fourier theFourier = null;  /* Fourier class instance */
   
         try
         {
            /*
             * Construct input data as sin(2*PI*15*t) + 
             * sin(2*PI*40*t) plus a random signal.
             *    Duration = 10
             *    Sampling interval = 0.01
             */
            int[] dims = {1, nSamples};
            data = MWNumericArray.newInstance(dims, MWClassID.DOUBLE,
                                                 MWComplexity.REAL);
            for (int i = 1; i <= nSamples; i++)
            {
               double t = (i-1)*interval;
               double x = Math.sin(2.0*Math.PI*15.0*t) +
                  Math.sin(2.0*Math.PI*40.0*t) + 
                  Math.random();
               data.set(i, x);
            }
   
            /* Create new fourier object */
            theFourier = new fourier();          
   
            /* Compute power spectral density and plot result */
            result = theFourier.plotfft(3, data, 
               Double.valueOf(interval));
            theFourier.waitForFigures(); 
         }
   
         catch (Exception e)
         {
            System.out.println("Exception: " + e.toString());
         }
   
         finally
         {
            /* Free native resources */
            MWArray.disposeArray(data);
            MWArray.disposeArray(result);
            if (theFourier != null)
               theFourier.dispose();
         }
      }
   }

   The program does the following:

   • Constructs an input array with values representing a random signal with two sinusoids at 15 and 40 Hz embedded inside of it

   • Creates an MWNumericArray array that contains the data

     data = MWNumericArray.newInstance(dims, MWClassID.DOUBLE, MWComplexity.REAL);
     

   • Instantiates a fourier object

   • Calls the plotfft method, which calls computeftt and plots the data

   • Uses a try-catch block to handle exceptions

   • Frees native resources using MWArray methods

5. In MATLAB, navigate to the SpectraDemoJavaApp folder.

6. Copy the generated spectralanalysis.jar package into this folder.

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

     copyfile(fullfile('..','SpectraDemoComp','spectralanalysisjavaPackage','spectralanalysis.jar'))

   • If you used the Library Compiler, type:

     copyfile(fullfile('..','SpectraDemoComp','spectralanalysis','for_testing','spectralanalysis.jar'))

7. Open a command prompt window and navigate to the SpectraDemoJavaApp folder.

8. Compile the powerspect.java application using javac.

   • On Windows^®, execute the following command:

     javac -classpath "matlabroot\toolbox\javabuilder\jar\javabuilder.jar";.\spectralanalysis.jar powerspect.java

   • On UNIX^®, execute the following command:

     javac -classpath "matlabroot/toolbox/javabuilder/jar/javabuilder.jar":./spectralanalysis.jar powerspect.java

   Replace matlabroot with the path to your MATLAB or MATLAB Runtime installation folder. For example, on Windows, the path may be C:\Program Files\MATLAB\R2024b.

9. Run the powerspect application.

   • On Windows, execute the following command:

     java -classpath .;"matlabroot\toolbox\javabuilder\jar\javabuilder.jar";.\spectralanalysis.jar powerspect

   • On UNIX, execute the following command:

     java -classpath .:"matlabroot/toolbox/javabuilder/jar/javabuilder.jar":./spectralanalysis.jar powerspect
     

   Note

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

   The powerspect program displays the following output: