int GetString(structlpsolvecaller *lpsolvecaller, pMatrix ppm, int element, char *buf, int size, int ShowError)
{
int size1;
zval arg;
ZVAL_UNDEF(&arg);
if (ppm != NULL) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
arg = GetpMatrix(lpsolvecaller, element);
if ((!Z_ISUNDEF(arg)) && (Z_TYPE(arg) != IS_STRING)) {
ZVAL_UNDEF(&arg);
}
if (Z_ISUNDEF(arg)) {
if (ShowError)
ErrMsgTxt(lpsolvecaller, "Expecting a character element");
return(FALSE);
}
size1 = Z_STRLEN(arg);
if (size1 < size)
size = size1;
memcpy(buf, Z_STRVAL(arg), size);
buf[size] = 0;
return(TRUE);
}
strArray GetCellCharItems(pMatrix ppm, int element, int len)
{
int m, n, i;
rMatrix pm = ppm[element];
pMatrix pa0, **pa;
if (!mxIsCell(pm))
ErrMsgTxt("Expecting a cell argument.");
m = GetM(pm);
n = GetN(pm);
if (!(((m == 1) && (n == len)) || ((n == 1) && (m == len))))
ErrMsgTxt("invalid vector.");
pa = pa0 = (pMatrix) matCalloc(len, sizeof(*pa));
for (i = 0; i < len; i++) {
*pa = mxGetCell(pm, i);
if (!mxIsChar(*pa))
break;
pa++;
}
if (i < len) {
matFree(pa0);
ErrMsgTxt("Expecting a character cell element.");
}
return(pa0);
}
int GetN(structlpsolvecaller *lpsolvecaller, zval arg)
{
int n, n1;
HashTable *arr_hash;
zval *data;
zend_string *key;
long i;
switch (Z_TYPE(arg)) {
case IS_LONG:
case IS_DOUBLE:
n = 1;
break;
case IS_ARRAY:
//n = 1; /* only 1-dim arrays supported at this time */
arr_hash = Z_ARRVAL(arg);
n = 0;
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key || (i < 0)) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
n1 = GetM(lpsolvecaller, *data);
if (n1 >= n)
n = n1;
} ZEND_HASH_FOREACH_END();
break;
default:
n = 0;
break;
}
return(n);
}
/* This is not the number of elements in the array, but the maximum index number in it.
This to allow sparse arrays */
int GetM(structlpsolvecaller *lpsolvecaller, zval arg)
{
int m;
HashTable *arr_hash;
zval *data;
long i;
zend_string *key;
int key_len;
switch (Z_TYPE(arg)) {
case IS_LONG:
case IS_DOUBLE:
m = 1;
break;
case IS_ARRAY:
arr_hash = Z_ARRVAL(arg);
/* m = zend_hash_num_elements(arr_hash); */
m = 0;
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key || (i < 0)) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
if (i + 1 >= m)
m = i + 1;
} ZEND_HASH_FOREACH_END();
break;
default:
m = 0;
break;
}
return(m);
}
int GetString(pMatrix ppm, int element, char *buf, int size, int ShowError)
{
rMatrix pm = ppm[element];
if (!mxIsChar(pm)) {
if (ShowError)
ErrMsgTxt("Expecting a character element.");
return(FALSE);
}
mxGetString(pm, buf, size);
return(TRUE);
}
Double GetRealScalar(pMatrix ppm, int element)
{
rMatrix pm = ppm[element];
if ((GetM(pm) == 1) && (GetN(pm) == 1)
&& (IsNumeric(pm)) && (!IsComplex(pm)) ) {
return(mxGetScalar(pm));
} else {
ErrMsgTxt("Expecting a scalar argument.");
}
return(0.0);
}
Double GetRealArg(structlpsolvecaller *lpsolvecaller, zval arg)
{
Double a = 0.0;
switch (Z_TYPE(arg)) {
case IS_LONG:
a = (Double) Z_LVAL(arg);
break;
case IS_DOUBLE:
a = (Double) Z_DVAL(arg);
break;
default:
ErrMsgTxt(lpsolvecaller, "Expecting a scalar value.");
break;
}
return(a);
}
Double GetRealScalar(structlpsolvecaller *lpsolvecaller, int element)
{
zval arg;
ZVAL_UNDEF(&arg);
Double a = 0.0;
arg = GetpMatrix(lpsolvecaller, element);
if ((!Z_ISUNDEF(arg)) && (Z_TYPE(arg) != IS_LONG) && (Z_TYPE(arg) != IS_DOUBLE)) {
ZVAL_UNDEF(&arg);
}
if (Z_ISUNDEF(arg)) {
abort();
ErrMsgTxt(lpsolvecaller, "Expecting a scalar argument.");
} else {
a = GetRealArg(lpsolvecaller, arg);
}
return(a);
}
int GetRealSparseVector(structlpsolvecaller *lpsolvecaller, int element, Double *vec, int *index, int start, int len, int col)
{
int m, n, count = 0;
zval pm = GetpMatrix(lpsolvecaller, element);
zval *data;
HashTable *arr_hash;
Double a;
zend_string *key;
ulong i;
if ((Z_ISUNDEF(pm)) || (Z_TYPE(pm) != IS_ARRAY)) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
#if 1
m = GetM(lpsolvecaller, pm);
n = GetN(lpsolvecaller, pm);
#else
m = zend_hash_num_elements(Z_ARRVAL_P(pm));
n = 1;
#endif
if ( ((col == 0) && (((m != 1) && (n != 1)) || ((m == 1) && (n > len)) || ((n == 1) && (m > len)))) ||
((col != 0) && ((m > len) || (col > n))) /* ||
!IsNumeric(pm) ||
IsComplex(pm) */ ) {
/* Printf("1: m=%d, n=%d, col=%d, len=%d, IsNumeric=%d, IsComplex=%d\n", m,n,col,len,IsNumeric(pm),IsComplex(pm)); */
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
if ((((n == 1) || (col != 0)) && (m > len)) || ((col == 0) && (m == 1) && (n > len))) {
/* Printf("2: m=%d, n=%d, col=%d, len=%d\n", m,n,col,len); */
ErrMsgTxt(lpsolvecaller, "invalid vector.");
}
arr_hash = Z_ARRVAL(pm);
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
} else {
zval pm = *data;
a = 0;
if (Z_TYPE(pm) == IS_ARRAY) {
zval *data;
HashTable *arr_hash;
zend_string *key;
ulong i;
arr_hash = Z_ARRVAL(pm);
ZEND_HASH_FOREACH_KEY_VAL(arr_hash, i, key, data) {
if (key) {
ErrMsgTxt(lpsolvecaller, "invalid vector.");
} else if (i + 1 == col) {
a = GetRealArg(lpsolvecaller, *data);
break;
}
} ZEND_HASH_FOREACH_END();
} else {
a = GetRealArg(lpsolvecaller, pm);
}
if (a) {
*(vec++) = a;
*(index++) = start + i;
count++;
}
}
int GetRealSparseVector(pMatrix ppm, int element, Double *vec, int *index, int start, int len, int col)
{
int j, k, k1, m, n, start1, count = 0;
int *ir, *jc;
double *pr, *pr0;
rMatrix pm = ppm[element];
m = GetM(pm);
n = GetN(pm);
if ( ((col == 0) && (((m != 1) && (n != 1)) || ((m == 1) && (n > len)) || ((n == 1) && (m > len)))) ||
((col != 0) && ((m > len) || (col > n))) ||
!IsNumeric(pm) ||
IsComplex(pm) ) {
ErrMsgTxt("invalid vector.");
}
pr = GetPr(pm);
if (!IsSparse(pm)) {
if ((((n == 1) || (col != 0)) && (m != len)) || ((col == 0) && (m == 1) && (n != len)))
ErrMsgTxt("invalid vector.");
if (col)
pr += (col - 1) * m;
for (k = 0; k < len; k++, pr++) {
if (*pr) {
*(vec++) = *pr;
*(index++) = start + k;
count++;
}
}
} else if (IsSparse(pm)) {
int j1, j2;
jc = mxGetJc(pm);
ir = mxGetIr(pm);
pr0 = pr;
if (col == 0) {
j1 = 0;
j2 = n;
}
else {
j1 = col - 1;
j2 = col;
}
for (j = j1; j < j2; j++) {
k = jc[j];
k1 = jc[j + 1];
pr = pr0 + k;
start1 = start;
if (col == 0)
start1 += j * m;
for (; k < k1; k++, pr++, vec++, index++) {
*vec = *pr;
*index = start1 + ir[k];
count++;
}
}
} else {
ErrMsgTxt("Can't figure out this matrix.");
}
return(count);
}
