int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
{
if (mxIsCell(array_ptr))
{
((types::Cell *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsChar(array_ptr))
{
((types::String *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsDouble(array_ptr))
{
((types::Double *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsSparse(array_ptr))
{
//TODO
}
else if (mxIsInt8(array_ptr))
{
((types::Int8 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt16(array_ptr))
{
((types::Int16 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt32(array_ptr))
{
((types::Int32 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt64(array_ptr))
{
((types::Int64 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsLogical(array_ptr))
{
((types::Bool *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsStruct(array_ptr))
{
((types::Struct *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint8(array_ptr))
{
((types::UInt8 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint16(array_ptr))
{
((types::UInt16 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint32(array_ptr))
{
((types::UInt32 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint64(array_ptr))
{
((types::UInt64 *)array_ptr)->resize((int *)dims, ndim);
}
return 0;
}
int mxIsNumeric(const mxArray *ptr)
{
return mxIsDouble(ptr) || mxIsSingle(ptr) ||
mxIsInt8(ptr) || mxIsUint8(ptr) ||
mxIsInt16(ptr) || mxIsUint16(ptr) || mxIsInt32(ptr) || mxIsUint32(ptr) || mxIsInt64(ptr) || mxIsUint64(ptr);
}
int mxIsClass(const mxArray *ptr, const char *name)
{
if (strcmp(name, "cell") == 0)
{
return mxIsCell(ptr);
}
if (strcmp(name, "char") == 0)
{
return mxIsChar(ptr);
}
if (strcmp(name, "double") == 0)
{
return mxIsDouble(ptr);
}
if (strcmp(name, "int8") == 0)
{
return mxIsInt8(ptr);
}
if (strcmp(name, "int16") == 0)
{
return mxIsInt16(ptr);
}
if (strcmp(name, "int32") == 0)
{
return mxIsInt32(ptr);
}
if (strcmp(name, "int64") == 0)
{
return mxIsInt64(ptr);
}
if (strcmp(name, "logical") == 0)
{
return mxIsLogical(ptr);
}
if (strcmp(name, "single") == 0)
{
return mxIsSingle(ptr);
}
if (strcmp(name, "struct") == 0)
{
return mxIsStruct(ptr);
}
if (strcmp(name, "uint8") == 0)
{
return mxIsUint8(ptr);
}
if (strcmp(name, "uint16") == 0)
{
return mxIsUint16(ptr);
}
if (strcmp(name, "uint32") == 0)
{
return mxIsUint32(ptr);
}
if (strcmp(name, "uint64") == 0)
{
return mxIsUint64(ptr);
}
// TODO: how to handle <class_name> and <class_id>?
return 0;
}
void
mexFunction (int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
size_t M, N, i;
UINT64_T *a, *b, *c;
bool aScalar, bScalar;
if (nlhs > 1)
mexErrMsgTxt ("Invalid number of output arguments");
if (nrhs != 2)
mexErrMsgTxt ("Invalid number of input arguments");
if (!mxIsUint64(prhs[0]))
mexErrMsgTxt ("Invalid type of input arguments (should be uint64)");
if (!mxIsUint64(prhs[1]))
mexErrMsgTxt ("Invalid type of input arguments (should be uint64)");
aScalar = ((mxGetN(prhs[0])==1) && (mxGetM(prhs[0])==1));
bScalar = ((mxGetN(prhs[1])==1) && (mxGetM(prhs[1])==1));
if (!aScalar && !bScalar)
{
if (mxGetM(prhs[0]) != mxGetM(prhs[1]))
mexErrMsgTxt ("Invalid size of input arguments");
if (mxGetN(prhs[0]) != mxGetN(prhs[1]))
mexErrMsgTxt ("Invalid size of input arguments");
}
if (aScalar)
{
M = mxGetM(prhs[1]);
N = mxGetN(prhs[1]);
}
else
{
M = mxGetM(prhs[0]);
N = mxGetN(prhs[0]);
}
a = mxGetData(prhs[0]);
b = mxGetData(prhs[1]);
plhs[0] = (mxArray*)mxCreateNumericMatrix(M, N, mxUINT64_CLASS, mxREAL);
c = mxGetData(plhs[0]);
if (aScalar)
{
for (i=0; i<(M*N); i++)
c[i] = a[0]*b[i];
}
else if (bScalar)
{
for (i=0; i<(M*N); i++)
c[i] = a[i]*b[0];
}
else
{
for (i=0; i<(M*N); i++)
c[i] = a[i]*b[i];
}
return;
}