Create C Source MEX File

This example shows how to write a MEX file to call a C function, arrayProduct, in MATLAB® using a MATLAB matrix. You can use these same C statements in a C++ application.

arrayProduct multiplies an n-dimensional array, y, by a scalar value, x, and returns the results in array, z.

void arrayProduct(double x, double *y, double *z, int n)
  int i;
  for (i=0; i<n; i++) {
    z[i] = x * y[i];

Create Source File

Open MATLAB Editor, create a file, and document the MEX file with the following information.

 * arrayProduct.c - example in MATLAB External Interfaces
 * Multiplies an input scalar (multiplier) 
 * times a 1xN matrix (inMatrix)
 * and outputs a 1xN matrix (outMatrix)
 * The calling syntax is:
 *		outMatrix = arrayProduct(multiplier, inMatrix)
 * This is a MEX file for MATLAB.

Add the C/C++ header file, mex.h, containing the MATLAB API function declarations.

#include "mex.h"

Save the file on your MATLAB path, for example, in c:\work, and name it arrayProduct.c. The name of your MEX file is arrayProduct.

Create Gateway Routine

Every C program has a main() function. MATLAB uses the gateway routine, mexfunction, as the entry point to the function. Add the following mexFunction code.

/* The gateway function */
void mexFunction(int nlhs, mxArray *plhs[],
                 int nrhs, const mxArray *prhs[])
/* variable declarations here */

/* code here */

This table describes the input parameters for mexfunction.

nlhsNumber of output (left-side) arguments, or the size of the plhs array.
plhsArray of output arguments.
nrhsNumber of input (right-side) arguments, or the size of the prhs array.
prhsArray of input arguments.

Verify MEX File Input and Output Parameters

Verify the number of MEX file input and output arguments using the nrhs and nlhs arguments.

To check for two input arguments, multiplier and inMatrix, use this code.

if(nrhs != 2) {
                      "Two inputs required.");

Use this code to check for one output argument, the product outMatrix.

if(nlhs != 1) {
                      "One output required.");

Verify the argument types using the plhs and prhs arguments. This code validates that multiplier, represented by prhs[0], is a scalar.

/* make sure the first input argument is scalar */
if( !mxIsDouble(prhs[0]) || 
     mxIsComplex(prhs[0]) ||
     mxGetNumberOfElements(prhs[0]) != 1 ) {
                      "Input multiplier must be a scalar.");

This code validates that inMatrix, represented by prhs[1], is type double.

if( !mxIsDouble(prhs[1]) || 
     mxIsComplex(prhs[1])) {
        "Input matrix must be type double.");

Validate that inMatrix is a row vector.

/* check that number of rows in second input argument is 1 */
if(mxGetM(prhs[1]) != 1) {
                      "Input must be a row vector.");

Create Computational Routine

Add the arrayProduct code. This function is your computational routine, the source code that performs the functionality you want to use in MATLAB.

void arrayProduct(double x, double *y, double *z, int n)
  int i;
  for (i=0; i<n; i++) {
    z[i] = x * y[i];

A computational routine is optional. Alternatively, you can place the code within the mexfunction function block.

Write Code for Cross-Platform Flexibility

MATLAB provides a preprocessor macro, mwsize, that represents size values for integers, based on the platform. The computational routine declares the size of the array as int. Replace the int declaration for variables n and i with mwsize.

void arrayProduct(double x, double *y, double *z, mwSize n)
  mwSize i;
  for (i=0; i<n; i++) {
    z[i] = x * y[i];

Declare Variables for Computational Routine

Put the following variable declarations in mexFunction.

  • Declare variables for the input arguments.

    double multiplier;      /* input scalar */
    double *inMatrix;       /* 1xN input matrix */
  • Declare ncols for the size of the input matrix.

    mwSize ncols;           /* size of matrix */
  • Declare the output argument, outMatrix.

    double *outMatrix;      /* output matrix */

Later you assign the mexFunction arguments to these variables.

Read Input Data

To read the scalar input, use the mxGetScalar function.

/* get the value of the scalar input  */
multiplier = mxGetScalar(prhs[0]);

Use the mxGetPr function to point to the input matrix data.

/* create a pointer to the real data in the input matrix  */
inMatrix = mxGetPr(prhs[1]);

Use the mxGetN function to get the size of the matrix.

/* get dimensions of the input matrix */
ncols = mxGetN(prhs[1]);

Prepare Output Data

To create the output argument, plhs[0], use the mxCreateDoubleMatrix function.

/* create the output matrix */
plhs[0] = mxCreateDoubleMatrix(1,ncols,mxREAL);

Use the mxGetPr function to assign the outMatrix argument to plhs[0]

/* get a pointer to the real data in the output matrix */
outMatrix = mxGetPr(plhs[0]);

Perform Calculation

Pass the arguments to arrayProduct.

/* call the computational routine */

View Complete Source File

Compare your source file with arrayProduct.c, located in matlabroot/extern/examples/mex. Open the file in the editor.

Build Binary MEX File

At the MATLAB command prompt, build the binary MEX file.

mex arrayProduct.c

Test the MEX File

s = 5; 
A = [1.5, 2, 9];
B = arrayProduct(s,A)
B =
    7.5000   10.0000   45.0000 

Validate MEX File Input Arguments

It is good practice to validate the type of a MATLAB variable before calling a MEX file. To test the input variable, inputArg, and convert it to double, if necessary, use this code.

A = [1.5, 2, 9];
inputArg = int16(A);
if ~strcmp(class(inputArg),'double')
    inputArg = double(inputArg);
B = arrayProduct(s,inputArg)

See Also

| | | | |

Related Examples

More About

Was this topic helpful?