MATLAB Compiler

Advanced C Example

This section illustrates an advanced example of how to write C code that calls a compiled M-file. Consider a stand-alone application whose source code consists of two files:

• multarg.m, which contains a function named multarg
• multargp.c, which contains a C function named main

multarg.m specifies two input parameters and returns two output parameters:

• function [a,b] = multarg(x,y)
  a = (x + y) * pi;
  b = svd(svd(a));
  

The code in multargp.c calls mlfMultarg and then displays the two values that mlfMultarg returns.

• #include <stdio.h>
  #include <string.h>
  #include <math.h>
  #include "matlab.h"
  #include "multpkg.h"/* Include Compiler-generated header file */
  
  static void PrintHandler( const char *text )
  {
      printf(text);
  }
  
  int main( )   /* Programmer written coded to call mlfMultarg */
  {
  #define ROWS  3 
  #define COLS  3
  
      mxArray *a, *b, *x, *y; 
      double  x_pr[ROWS * COLS] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 
      double  x_pi[ROWS * COLS] = {9, 2, 3, 4, 5, 6, 7, 8, 1}; 
      double  y_pr[ROWS * COLS] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 
      double  y_pi[ROWS * COLS] = {2, 9, 3, 4, 5, 6, 7, 1, 8}; 
      double *a_pr, *a_pi, value_of_scalar_b;
  
      multpkgInitialize();/* Call multpkg initialization */
  
      /* Install a print handler to tell mlfPrintMatrix how to
       * display its output.
       */
      mlfSetPrintHandler(PrintHandler);
      
      /* Create input matrix "x" */ 
      x = mxCreateDoubleMatrix(ROWS, COLS, mxCOMPLEX); 
      memcpy(mxGetPr(x), x_pr, ROWS * COLS * sizeof(double));
      memcpy(mxGetPi(x), x_pi, ROWS * COLS * sizeof(double));
      
      /* Create input matrix "y" */ 
      y = mxCreateDoubleMatrix(ROWS, COLS, mxCOMPLEX); 
      memcpy(mxGetPr(y), y_pr, ROWS * COLS * sizeof(double));
      memcpy(mxGetPi(y), y_pi, ROWS * COLS * sizeof(double));
      
      /* Call the mlfMultarg function. */
      a = (mxArray *)mlfMultarg(&b, x, y); 
      
      /* Display the entire contents of output matrix "a". */
      mlfPrintMatrix(a);
      
      /* Display the entire contents of output scalar "b" */
      mlfPrintMatrix(b);
      
      /* Deallocate temporary matrices. */
      mxDestroyArray(a);
      mxDestroyArray(b);
      multpkgTerminate();/* Call multpkg termination */
      return(0);
  }
  

You can build this program into a stand-alone application by using the command

• mcc -t -W lib:multpkg -T link:exe multarg multargp.c 
  libmmfile.mlib
  

The program first displays the contents of a 3-by-3 matrix a and then displays the contents of scalar b:

•    6.2832 +34.5575i  25.1327 +25.1327i  43.9823 +43.9823i
    12.5664 +34.5575i  31.4159 +31.4159i  50.2655 +28.2743i
    18.8496 +18.8496i  37.6991 +37.6991i  56.5487 +28.2743i
  
    143.4164
  

An Explanation of This C Code

Invoking the MATLAB Compiler on multarg.m generates the C function prototype:

• extern mxArray * mlfMultarg(mxArray * * b, mxArray * x, 
      mxArray * y);
  extern void mlxMultarg(int nlhs, mxArray * plhs[], int nrhs,
      mxArray * prhs[]);
  

This C function header shows two input arguments (mxArray *x and mxArray *y) and two output arguments (the return value and mxArray **b).

Use mxCreateDoubleMatrix to create the two input matrices (x and y). Both x and y contain real and imaginary components. The memcpy function initializes the components, for example:

• x = mxCreateDoubleMatrix(ROWS, COLS, COMPLEX);
  memcpy(mxGetPr(x), x_pr, ROWS * COLS * sizeof(double));
  memcpy(mxGetPi(y), y_pi, ROWS * COLS * sizeof(double));
  

The code in this example initializes variable x from two arrays (x_pr and x_pi) of predefined constants. A more realistic example would read the array values from a data file or a database.

After creating the input matrices, main calls mlfMultarg:

• a = (mxArray *)mlfMultarg(&b, x, y); 
  

The mlfMultarg function returns matrices a and b. a has both real and imaginary components; b is a scalar having only a real component. The program uses mlfPrintMatrix to output the matrices, for example:

• mlfPrintMatrix(a);
  

Simple Example

Controlling Code Generation