static mxArray *numeric2mx(PyObject *pSrc)
{
mxArray *lDst = NULL;
pyassert(PyArray_API, "Unable to perform this function without NumPy installed");
if (PyArray_Check(pSrc)) {
lDst = makeMxFromNumeric((const PyArrayObject *)pSrc);
} else if (PySequence_Check(pSrc)) {
lDst = makeMxFromSeq(pSrc);
} else if (PyObject_HasAttrString(pSrc, "__array__")) {
PyObject *arp;
arp = PyObject_CallMethod(pSrc, "__array__", NULL);
lDst = makeMxFromNumeric((const PyArrayObject *)arp);
Py_DECREF(arp); // FIXME check this is correct;
}
else if (PyInt_Check(pSrc) || PyLong_Check(pSrc) ||
PyFloat_Check(pSrc) || PyComplex_Check(pSrc)){
PyObject *t;
t = Py_BuildValue("(O)", pSrc);
// t = PyTuple_New(1);
// PyTuple_SetItem(t, 0, pSrc);
lDst = makeMxFromSeq(t);
Py_DECREF(t); // FIXME check this
} else {
}
return lDst;
error_return:
return NULL;
}
// FIXME: add string array support
static PyStringObject *mx2char(const mxArray *pArray)
{
size_t buflen;
char *buf;
PyStringObject *lRetval;
if (mxGetM(pArray) > 1) {
PyErr_SetString(mlabraw_error, "Only 1 Dimensional strings are currently supported");
return NULL;
}
buflen = mxGetN(pArray) + 1;
buf = (char *)mxCalloc(buflen, sizeof(char));
pyassert(buf, "Out of MATLAB(TM) memory");
if (mxGetString(pArray, buf, buflen)) {
PyErr_SetString(mlabraw_error, "Unable to extract MATLAB(TM) string");
mxFree(buf);
return NULL;
}
lRetval = (PyStringObject *)PyString_FromString(buf);
mxFree(buf);
return lRetval;
error_return:
return NULL;
}
bool operator== (
const ranking_pair<T>& ,
const ranking_pair<T>&
)
{
pyassert(false, "It is illegal to compare ranking pair objects for equality.");
return false;
}
static PyArrayObject *mx2numeric(const mxArray *pArray)
{
//current function returns PyArrayObject in c order currently
mwSize nd;
npy_intp pydims[NPY_MAXDIMS];
PyArrayObject *lRetval = NULL,*t=NULL;
const double *lPR;
const double *lPI;
pyassert(PyArray_API,
"Unable to perform this function without NumPy installed");
nd = mxGetNumberOfDimensions(pArray);
{
const mwSize *dims;
dims = mxGetDimensions(pArray);
for (mwSize i=0; i != nd; i++){
pydims[i] = static_cast<npy_intp>(dims[i]);
}
}
//this function creates a fortran array
t = (PyArrayObject *)
PyArray_New(&PyArray_Type,static_cast<npy_intp>(nd), pydims,
mxIsComplex(pArray) ? PyArray_CDOUBLE : PyArray_DOUBLE,
NULL, // strides
NULL, // data
0, //(ignored itemsize),
NPY_F_CONTIGUOUS,
NULL); // obj
if (t == NULL) return NULL;
lPR = mxGetPr(pArray);
if (mxIsComplex(pArray)) {
double *lDst = (double *)PyArray_DATA(t);
// AWMS unsigned int almost certainly can overflow on some platforms!
npy_intp numberOfElements = PyArray_SIZE(t);
lPI = mxGetPi(pArray);
for (mwIndex i = 0; i != numberOfElements; i++) {
*lDst++ = *lPR++;
*lDst++ = *lPI++;
}
}
else {
double *lDst = (double *)PyArray_DATA(t);
npy_intp numberOfElements = PyArray_SIZE(t);
for (mwIndex i = 0; i != numberOfElements; i++) {
*lDst++ = *lPR++;
}
}
lRetval = (PyArrayObject *)PyArray_FromArray(t,NULL,NPY_C_CONTIGUOUS|NPY_ALIGNED|NPY_WRITEABLE);
Py_DECREF(t);
return lRetval;
error_return:
return NULL;
}
static PyArrayObject *mx2numeric(const mxArray *pArray)
{
mwSize nd;
npy_intp pydims[NPY_MAXDIMS];
PyArrayObject *lRetval = NULL;
mwSize lRows, lCols;
const double *lPR;
const double *lPI;
pyassert(PyArray_API,
"Unable to perform this function without NumPy installed");
nd = mxGetNumberOfDimensions(pArray);
if (nd > 2) {
PyErr_SetString(PyExc_TypeError,
"Only 1-D and 2-D arrays are currently supported");
return NULL;
}
{ const mwSize *dims;
dims = mxGetDimensions(pArray);
for (int i=0; i<nd; i++) pydims[i] = static_cast<npy_intp>(dims[i]); }
lRetval = (PyArrayObject *)
PyArray_SimpleNew(static_cast<npy_intp>(nd), pydims,
mxIsComplex(pArray) ?
PyArray_CDOUBLE : PyArray_DOUBLE);
if (lRetval == NULL) return NULL;
lRows = mxGetM(pArray);
lCols = mxGetN(pArray);
lPR = mxGetPr(pArray);
if (mxIsComplex(pArray)) {
lPI = mxGetPi(pArray);
for (mwIndex lCol = 0; lCol < lCols; lCol++) {
double *lDst = (double *)(lRetval->data) + 2*lCol;
for (mwIndex lRow = 0; lRow < lRows; lRow++, lDst += 2*lCols) {
lDst[0] = *lPR++;
lDst[1] = *lPI++;
}
}
} else {
for (mwIndex lCol = 0; lCol < lCols; lCol++) {
double *lDst = (double *)(lRetval->data) + lCol;
for (mwIndex lRow = 0; lRow < lRows; lRow++, lDst += lCols) {
*lDst = *lPR++;
}
}
}
return lRetval;
error_return:
return NULL;
}
