Using the C Math Library

Creating Cell Arrays

The MATLAB C Math Library allows you to create cell arrays by:

• Using a cell array creation function
• Using a cell array conversion function
• Concatenating existing arrays
• Assigning a value to an element in a cell array

Using the Cell Array Creation Routine

You can create an array of empty cells using the mlfCell() routine. The following code fragment creates a 2-by-3-by-2 array of empty cells.

mxArray *A = NULL;

mlfAssign(&A, mlfCell(mlfScalar(2),
                      mlfScalar(3),
                      mlfScalar(2),
                      NULL));

mlfPrintMatrix(A);

mxDestroyArray(A); 

This code produces the following output.

(:,:,1) =
    []    []    []
    []    []    []

(:,:,2) =
    []    []    []
    []    []    []

MATLAB uses brackets to indicate cell array elements and [] represents an empty cell. You can then assign values to cells in the array using assignment. For an example of assigning a value to a cell in a cell array, see Using Assignment to Create Cell Arrays.

Using Cell Array Conversion Routines

You can also create cell arrays by converting other MATLAB arrays into cell arrays. The MATLAB C Math Library includes routines that convert a numeric array into a cell array, mlfNum2cell(), or a structure into a cell array, mlfStruct2cell().

The following code fragment creates a numeric array, using mlfOnes(), and converts it into a cell array using the mlfNum2cell() routine.

mxArray *N = NULL; 
mxArray *C = NULL; 

/*  Create a numeric array  */
mlfAssign(&N, mlfOnes(mlfScalar(2),mlfScalar(3),NULL));
mlfPrintMatrix(N);

/* Convert it into a cell array */
mlfAssign(&C, mlfNum2cell(N,NULL));

mlfPrintMatrix(C);

mxDestroyArray(N); 
mxDestroyArray(C);

In this output, the brackets indicate that each element in the numeric array has been placed into a cell in the cell array.

1    1    1
1    1    1

[1]  [1]  [1]
[1]  [1]  [1]

The brackets indicate cell array elements.

Using Concatenation to Create Cell Arrays

You can group existing MATLAB arrays into a cell array by concatenation. In MATLAB, you use the {} (braces) operator to create cell arrays through concatenation. For example, you can use the following syntax in MATLAB to concatenate arrays into a cell array:

» A = 1:10
A =
   1     2     3     4     5     6     7     8     9    10

» B= 'my string'
B =
my string

» C = [ 1 2 3; 4 5 6 ]
C =
     1     2     3
     4     5     6

» D = { A B C }
D = 
    [1x10 double]    'my string'    [2x3 double]

To create the same cell array through concatenation in a C program, use the MATLAB C Math Library mlfCellhcat() routine. This routine performs the same function as {}, the MATLAB cell concatenation operator.

mxArray *A = NULL;
mxArray *B = NULL;
mxArray *C = NULL;
mxArray *D = NULL;
static double data[] = { 1, 4, 2, 5, 3, 6 };

mlfAssign(&A, mlfColon(mlfScalar(1),mlfScalar(10),NULL));
mlfAssign(&B, mxCreateString("my string"));
mlfAssign(&C, mlfDoubleMatrix(2, 3, data, NULL));

mlfAssign(&D, mlfCellhcat(A,B,C,NULL));
mlfPrintMatrix(D);

mxDestroyArray(A); 
mxDestroyArray(B);
mxDestroyArray(C);
mxDestroyArray(D);

To see the output from this code fragment, see Displaying the Contents of a Cell Array.

Using Assignment to Create Cell Arrays

You can also create a cell array by assigning a value to a location in a cell array, using the mlfIndexAssign() routine. The MATLAB C Math Library creates a cell array large enough to accommodate the specified location or expands an existing array. For more information about using indexing with cell arrays, see Chapter 5.

The following example is equivalent to the MATLAB statement,
A(2,2) = {17}. Note the use of curly braces in the index subscript format string: "{?,?}". This syntax indicates you want to create a cell array. Also note that the index subscript format string may be passed as a standard C character string; it does not need to be a MATLAB character array.

mxArray *A = NULL;

mlfIndexAssign(&A,
               "{?,?}",   /* index subscript format string */
               mlfScalar(2),   /* index value  */
               mlfScalar(2),   /* index value  */
               mlfScalar(17)); /* value to be assigned  */

mlfPrintMatrix(A);

mxDestroyArray(A); 

The following output shows the cell array created by this code fragment.

[]    []
[]    [17]

Cell Arrays

Displaying the Contents of a Cell Array