/* Pass analyze_cell a pointer to a cell mxArray. Each element
in a cell mxArray is called a "cell"; each cell holds zero
or one mxArray. analyze_cell accesses each cell and displays
information about it. */
static void
analyze_cell(const mxArray *cell_array_ptr)
{
int total_num_of_cells;
int index;
const mxArray *cell_element_ptr;
total_num_of_cells = mxGetNumberOfElements(cell_array_ptr);
mexPrintf("total num of cells = %d\n", total_num_of_cells);
mexPrintf("\n");
/* Each cell mxArray contains m-by-n cells; Each of these cells
is an mxArray. */
for (index=0; index<total_num_of_cells; index++) {
mexPrintf("\n\n\t\tCell Element: ");
display_subscript(cell_array_ptr, index);
mexPrintf("\n");
cell_element_ptr = mxGetCell(cell_array_ptr, index);
if (cell_element_ptr == NULL)
mexPrintf("\tEmpty Cell\n");
else {
/* Display a top banner. */
mexPrintf("------------------------------------------------\n");
get_characteristics(cell_element_ptr);
analyze_class(cell_element_ptr);
mexPrintf("\n");
}
}
mexPrintf("\n");
}
/* Pass analyze_string a pointer to a char mxArray. Each element
in a char mxArray holds one 2-byte character (an mxChar);
analyze_string displays the contents of the input char mxArray
one row at a time. Since adjoining row elements are NOT stored in
successive indices, analyze_string has to do a bit of math to
figure out where the next letter in a string is stored. */
static void
analyze_string(const mxArray *string_array_ptr)
{
char *buf;
mwSize number_of_dimensions, buflen;
const mwSize *dims;
mwSize d, page, total_number_of_pages, elements_per_page;
/* Allocate enough memory to hold the converted string. */
buflen = mxGetNumberOfElements(string_array_ptr) + 1;
buf = mxCalloc(buflen, sizeof(char));
/* Copy the string data from string_array_ptr and place it into buf. */
if (mxGetString(string_array_ptr, buf, buflen) != 0)
mexErrMsgIdAndTxt( "MATLAB:explore:invalidStringArray",
"Could not convert string data.");
/* Get the shape of the input mxArray. */
dims = mxGetDimensions(string_array_ptr);
number_of_dimensions = mxGetNumberOfDimensions(string_array_ptr);
elements_per_page = dims[0] * dims[1];
/* total_number_of_pages = dims[2] x dims[3] x ... x dims[N-1] */
total_number_of_pages = 1;
for (d=2; d<number_of_dimensions; d++) {
total_number_of_pages *= dims[d];
}
for (page=0; page < total_number_of_pages; page++) {
mwSize row;
/* On each page, walk through each row. */
for (row=0; row<dims[0]; row++) {
mwSize column;
mwSize index = (page * elements_per_page) + row;
mexPrintf("\t");
display_subscript(string_array_ptr, index);
mexPrintf(" ");
/* Walk along each column in the current row. */
for (column=0; column<dims[1]; column++) {
mexPrintf("%c",buf[index]);
index += dims[0];
}
mexPrintf("\n");
}
}
}
void analyze_logical(const mxArray *array_ptr)
{
mxLogical *pr;
mwSize total_num_of_elements, index;
total_num_of_elements = mxGetNumberOfElements(array_ptr);
pr = (mxLogical *)mxGetData(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (*pr++) {
mexPrintf(" = true\n");
} else {
mexPrintf(" = false\n");
}
}
}
static void
analyze_double(const mxArray *array_ptr)
{
double *pr, *pi;
int total_num_of_elements, index;
pr = mxGetPr(array_ptr);
pi = mxGetPi(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr))
mexPrintf(" = %g + %gi\n", *pr++, *pi++);
else
mexPrintf(" = %g\n", *pr++);
}
}
static void
analyze_uint32(const mxArray *array_ptr)
{
unsigned int *pr, *pi;
int total_num_of_elements, index;
pr = (unsigned int *)mxGetData(array_ptr);
pi = (unsigned int *)mxGetImagData(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr))
mexPrintf(" = %u + %ui\n", *pr++, *pi++);
else
mexPrintf(" = %u\n", *pr++);
}
}
static void
analyze_int8(const mxArray *array_ptr)
{
signed char *pr, *pi;
char total_num_of_elements, index;
pr = (signed char *)mxGetData(array_ptr);
pi = (signed char *)mxGetImagData(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr))
mexPrintf(" = %d + %di\n", *pr++, *pi++);
else
mexPrintf(" = %d\n", *pr++);
}
}
void analyze_single(const mxArray *array_ptr)
{
float *pr, *pi;
mwSize total_num_of_elements, index;
pr = (float *)mxGetData(array_ptr);
pi = (float *)mxGetImagData(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr)){
mexPrintf(" = %g + %gi\n", *pr++, *pi++);
} else {
mexPrintf(" = %g\n", *pr++);
}
}
}
void analyze_uint64(const mxArray *array_ptr)
{
uint64_T *pr, *pi;
mwSize total_num_of_elements, index;
pr = (uint64_T *)mxGetData(array_ptr);
pi = (uint64_T *)mxGetImagData(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr)) {
mexPrintf(" = %" FMT64 "u + %" FMT64 "ui\n", *pr++, *pi++);
} else {
mexPrintf(" = %" FMT64 "u\n", *pr++);
}
}
}
static void
analyze_int16(const mxArray *array_ptr)
{
short int *pr, *pi;
short int total_num_of_elements, index;
pr = (short int *)mxGetPr(array_ptr);
pi = (short int *)mxGetPi(array_ptr);
total_num_of_elements = mxGetNumberOfElements(array_ptr);
for (index=0; index<total_num_of_elements; index++) {
mexPrintf("\t");
display_subscript(array_ptr, index);
if (mxIsComplex(array_ptr))
mexPrintf(" = %d + %di\n", *pr++, *pi++);
else
mexPrintf(" = %d\n", *pr++);
}
}
/* Pass analyze_structure a pointer to a structure mxArray. Each element
in a structure mxArray holds one or more fields; each field holds zero
or one mxArray. analyze_structure accesses every field of every
element and displays information about it. */
static void
analyze_structure(const mxArray *structure_array_ptr)
{
mwSize total_num_of_elements;
mwIndex index;
int number_of_fields, field_index;
const char *field_name;
const mxArray *field_array_ptr;
mexPrintf("\n");
total_num_of_elements = mxGetNumberOfElements(structure_array_ptr);
number_of_fields = mxGetNumberOfFields(structure_array_ptr);
/* Walk through each structure element. */
for (index=0; index<total_num_of_elements; index++) {
/* For the given index, walk through each field. */
for (field_index=0; field_index<number_of_fields; field_index++) {
mexPrintf("\n\t\t");
display_subscript(structure_array_ptr, index);
field_name = mxGetFieldNameByNumber(structure_array_ptr,
field_index);
mexPrintf(".%s\n", field_name);
field_array_ptr = mxGetFieldByNumber(structure_array_ptr,
index,
field_index);
if (field_array_ptr == NULL) {
mexPrintf("\tEmpty Field\n");
} else {
/* Display a top banner. */
mexPrintf("------------------------------------------------\n");
get_characteristics(field_array_ptr);
analyze_class(field_array_ptr);
mexPrintf("\n");
}
}
mexPrintf("\n\n");
}
}
