/*--------------------------------------------------------------------------*/
int isColumnVector(void *_pvCtx, int *_piAddress)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iRows = 0;
int iCols = 0;
if (_piAddress == NULL)
{
return 0;
}
if (isVarMatrixType(_pvCtx, _piAddress) == 0)
{
return 0;
}
sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_IS_COLUMN_VECTOR, _("%s: Unable to get argument dimension"), "isColumnVector");
printError(&sciErr, 0);
return 0;
}
if (iCols == 1 && iRows > 1)
{
return 1;
}
return 0;
}
/*--------------------------------------------------------------------------*/
int checkVarDimension(void *_pvCtx, int *_piAddress, int _iRows, int _iCols)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iRows = 0;
int iCols = 0;
if (_piAddress == NULL)
{
return 0;
}
if (isVarMatrixType(_pvCtx, _piAddress) == 0)
{
return 0;
}
sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CHECK_VAR_DIMENSION, _("%s: Unable to get argument dimension"), "checkVarDimension");
printError(&sciErr, 0);
return 0;
}
if ((_iRows == iRows || _iRows == -1) && (_iCols == iCols || _iCols == -1))
{
return 1;
}
return 0;
}
SciErr getMatrixOfBoolean(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piBool)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iType = 0;
if( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfBoolean");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if(sciErr.iErr || iType != sci_boolean)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), "getMatrixOfBoolean", _("boolean matrix"));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN, _("%s: Unable to get argument #%d"), "getMatrixOfBoolean", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if(_piBool)
{
*_piBool = _piAddress + 3;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int isScalar(void *_pvCtx, int *_piAddress)
{
int iRows = 0;
int iCols = 0;
if (_piAddress == NULL)
{
return 0;
}
if (isVarMatrixType(_pvCtx, _piAddress) == 0)
{
return 0;
}
SciErr sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_IS_SCALAR, _("%s: Unable to get argument dimension"), "isScalar");
printError(&sciErr, 0);
return 0;
}
if (iCols == 1 && iRows == 1)
{
return 1;
}
return 0;
}
/*--------------------------------------------------------------------------*/
int isSquareMatrix(void *_pvCtx, int *_piAddress)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iRows = 0;
int iCols = 0;
if (_piAddress == NULL)
{
return 0;
}
if (isVarMatrixType(_pvCtx, _piAddress) == 0)
{
return 0;
}
sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_IS_SQUARE, _("%s: Unable to get argument dimension"), "isSquareMatrix");
printError(&sciErr, 0);
return 0;
}
if (iRows > 1 && iCols == iRows)
{
return 1;
}
return 0;
}
SciErr getBooleanSparseMatrix(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iType = 0;
if( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getBooleanSparseMatrix");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if(sciErr.iErr || iType != sci_boolean_sparse)
{
addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_SPARSE, _("%s: Unable to get argument #%d"), "getBooleanSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_BOOLEAN_SPARSE, _("%s: Unable to get argument #%d"), "getBooleanSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
*_piNbItem = _piAddress[4];
if(_piNbItemRow == NULL)
{
return sciErr;
}
*_piNbItemRow = _piAddress + 5;//4 for header + 1 for NbItem
if(_piColPos == NULL)
{
return sciErr;
}
*_piColPos = *_piNbItemRow + *_piRows;
return sciErr;
}
/*--------------------------------------------------------------------------*/
SciErr getNamedVarDimension(void *_pvCtx, const char *_pstName, int *_piRows, int *_piCols)
{
SciErr sciErr = sciErrInit();
int *piAddr = NULL;
sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
return sciErr;
}
sciErr = getVarDimension(_pvCtx, piAddr, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_NAMED_VARDIM, _("%s: Unable to get dimension of variable \"%s\""), "getNamedVarDimension", _pstName);
return sciErr;
}
return sciErr;
}
SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iType = 0;
if( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if(sciErr.iErr || iType != sci_matrix)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", _("double matrix"));
return sciErr;
}
if(isVarComplex(_pvCtx, _piAddress) != _iComplex)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), "getComplexMatrixOfDouble");
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if(_pdblReal != NULL)
{
*_pdblReal = (double*)(_piAddress + 4);
}
if(_iComplex && _pdblImg != NULL)
{
*_pdblImg = (double*)(_piAddress + 4) + *_piRows * *_piCols;
}
return sciErr;
}
SciErr getCommonMatrixOfDouble(void* _pvCtx, int* _piAddress, char _cType, int _iComplex, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr = sciErrInit();
int iType = 0;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr || iType != sci_matrix)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", _("double matrix"));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DOUBLE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfDouble" : "getMatrixOfDouble", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (_pdblReal != NULL)
{
*_pdblReal = ((types::InternalType*)_piAddress)->getAs<types::Double>()->getReal();
}
if (_iComplex && _pdblImg != NULL)
{
*_pdblImg = ((types::InternalType*)_piAddress)->getAs<types::Double>()->getImg();
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int sci_basename(char *fname,unsigned long fname_len)
{
SciErr sciErr;
BOOL flagexpand = TRUE; /* default */
int *piAddressVarOne = NULL;
wchar_t **pStVarOne = NULL;
int *lenStVarOne = NULL;
int iType1 = 0;
int m1 = 0, n1 = 0;
wchar_t **pStResult = NULL;
/* Check Input & Output parameters */
CheckRhs(1,3);
CheckLhs(1,1);
if (Rhs > 2)
{
int *piAddressVarThree = NULL;
int *piData = NULL;
int iType3 = 0;
int m3 = 0, n3 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (iType3 != sci_boolean)
{
Scierror(999,_("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
return 0;
}
sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarThree, &m3, &n3, &piData);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarThree, &m3, &n3);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if ( (m3 != n3) && (n3 != 1) )
{
Scierror(999,_("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
return 0;
}
flagexpand = piData[0];
}
if (Rhs > 1)
{
int *piAddressVarTwo = NULL;
int *piData = NULL;
int iType2 = 0;
int m2 = 0, n2 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (iType2 != sci_boolean)
{
Scierror(999,_("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &m2, &n2);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if ( (m2 != n2) && (n2 != 1) )
{
Scierror(999,_("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 2);
return 0;
}
sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &piData);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (iType1 == sci_matrix)
{
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( (m1 == n1) && (m1 == 0) )
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, m1, n1, NULL);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
}
}
else if (iType1 == sci_strings)
{
int i = 0;
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
lenStVarOne = (int*)MALLOC(sizeof(int) * (m1 * n1));
if (lenStVarOne == NULL)
{
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
// get lenStVarOne value
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, NULL);
if(sciErr.iErr)
{
freeArrayOfWideString(pStVarOne, m1 * n1);
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
pStVarOne = (wchar_t**)MALLOC(sizeof(wchar_t*) * (m1 * n1));
if (pStVarOne == NULL)
{
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
for (i = 0; i < (m1 * n1); i++)
{
pStVarOne[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (lenStVarOne[i] + 1));
if (pStVarOne[i] == NULL)
{
freeArrayOfWideString(pStVarOne, m1 * n1);
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
}
// get pStVarOne
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
if(sciErr.iErr)
{
freeArrayOfWideString(pStVarOne, m1 * n1);
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
pStResult = (wchar_t**)MALLOC(sizeof(wchar_t*) * (m1 * n1));
if (pStResult == NULL)
{
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
for (i=0;i< m1 * n1; i++)
{
pStResult[i] = basenameW(pStVarOne[i], flagexpand);
}
sciErr = createMatrixOfWideString(pvApiCtx, Rhs + 1, m1, n1, pStResult);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
if (lenStVarOne) {FREE(lenStVarOne); lenStVarOne = NULL;}
freeArrayOfWideString(pStResult, m1 * n1);
freeArrayOfWideString(pStVarOne, m1 * n1);
PutLhsVar();
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_save(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iOldSave = FALSE;
int* piAddr1 = NULL;
int iType1 = 0;
CheckRhs(1, 100000);
CheckLhs(0, 1);
//filename or file descriptor
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (iType1 == sci_strings)
{
int* piAddrI = NULL;
int* piAddrI2 = NULL;
int iTypeI = 0;
int iRowsI = 0;
int iColsI = 0;
char* pstVarI = NULL;
if (Rhs > 1)
{
int i = 0;
for (i = 2 ; i <= Rhs ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrI);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
sciErr = getVarType(pvApiCtx, piAddrI, &iTypeI);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (iTypeI != sci_strings)
{
iOldSave = TRUE;
break;
}
sciErr = getVarDimension(pvApiCtx, piAddrI, &iRowsI, &iColsI);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (iRowsI != 1 || iColsI != 1)
{
iOldSave = TRUE;
break;
}
if (getAllocatedSingleString(pvApiCtx, piAddrI, &pstVarI))
{
return 1;
}
if (strcmp(pstVarI, "-append") != 0)
{
//try to get variable by name
sciErr = getVarAddressFromName(pvApiCtx, pstVarI, &piAddrI2);
if (sciErr.iErr)
{
// Try old save because here the input variable can be of type "string" but not a variable name
// Ex: a=""; save(filename, a);
iOldSave = TRUE;
break;
}
if (piAddrI2 == 0)
{
iOldSave = TRUE;
break;
}
}
freeAllocatedSingleString(pstVarI);
}
}
else
{
iOldSave = FALSE;
}
}
else
{
iOldSave = TRUE;
}
//new save to sod format
if (iOldSave == FALSE)
{
int lw = 0;
//call "overload" to prepare data to export_to_hdf5 function.
C2F(overload) (&lw, "save", (unsigned long)strlen("save"));
}
//old save
if (iOldSave)
{
//show warning only for variable save, not for environment.
if (getWarningMode() && Rhs > 1)
{
sciprint(_("%s: Scilab 6 will not support the file format used.\n"), _("Warning"));
sciprint(_("%s: Please quote the variable declaration. Example, save('myData.sod',a) becomes save('myData.sod','a').\n"), _("Warning"));
sciprint(_("%s: See help('save') for the rational.\n"), _("Warning"));
}
C2F(intsave)();
}
return 0;
}
/*--------------------------------------------------------------------------*/
SciErr getMatrixOfWideString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piwLength, wchar_t** _pwstStrings)
{
SciErr sciErr = sciErrInit();
int iType = 0;
char **pstStrings = NULL;
int *piLenStrings = NULL;
int strSize = 0;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfWideString");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_WIDE_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfWideString", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (iType != sci_strings)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfWideString", _("string matrix"));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_WIDE_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfWideString", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (_piwLength == NULL)
{
return sciErr;
}
types::String *pS = ((types::InternalType*)_piAddress)->getAs<types::String>();
int iSize = pS->getSize();
if (_pwstStrings == NULL || *_pwstStrings == NULL)
{
for (int i = 0 ; i < iSize; i++)
{
_piwLength[i] = (int)wcslen(pS->get(i));
}
}
else
{
for (int i = 0 ; i < pS->getSize() ; i++)
{
if (_pwstStrings[i] == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
return sciErr;
}
wcscpy(_pwstStrings[i], pS->get(i));
}
}
return sciErr;
}
SciErr getMatrixOfString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
{
SciErr sciErr = sciErrInit();
int *piOffset = NULL;
int *piData = NULL;
int iType = 0;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfString", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (iType != sci_strings)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getMatrixOfString", _("string matrix"));
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_STRING, _("%s: Unable to get argument #%d"), "getMatrixOfString", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (_piLength == NULL)
{
return sciErr;
}
types::String *pS = ((types::InternalType*)_piAddress)->getAs<types::String>();
//non cummulative length
int iSize = pS->getSize();
if (_pstStrings == NULL || *_pstStrings == NULL)
{
for (int i = 0 ; i < iSize; i++)
{
char* pstTemp = wide_string_to_UTF8(pS->get(i));
_piLength[i] = (int)strlen(pstTemp);
FREE(pstTemp);
}
}
else
{
for (int i = 0 ; i < iSize; i++)
{
if (_pstStrings[i] == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_SUBSTRING_POINTER, _("%s: Invalid argument address"), "getMatrixOfString");
return sciErr;
}
char* c = wide_string_to_UTF8(pS->get(i));
strcpy(_pstStrings[i], c);
FREE(c);
}
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int sci_msprintf(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iType = 0;
int *piAddressVarOne = NULL;
char *ptrFormat = NULL;
int K = 0;
int i = 0;
int lenghtFormat = 0;
int NumberPercent = 0;
int NumberCols = 0;
int nmax = 0;
int cat_to_last = 0;
int ll = 0;
char **pStrs = NULL;
char **pOutputStrings = NULL;
char *pStrTmp = NULL;
char *pStrTmp1 = NULL;
int lcount = 0;
int rval = 0;
int blk = 200;
int k = 0;
int mOut = 0;
int nOut = 0;
int lenghtSplitChar = (int)strlen(SPLIT_ON_CR_IN_FORMAT);
Nbvars = 0;
CheckRhs(1, 1000);
CheckLhs(0, 1);
for (K = 2; K <= Rhs; K++)
{
int iTypeK = 0;
int *piAddressVarK = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, K, &piAddressVarK);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarK, &iTypeK);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( (iTypeK != sci_matrix) && (iTypeK != sci_strings) )
{
OverLoad(K);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (checkVarDimension(pvApiCtx, piAddressVarOne, 1, 1) != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &ptrFormat))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (ptrFormat == NULL)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
else
{
char *ptrFormatTmp = strsub(ptrFormat, CR_IN_FORMAT, SPLIT_ON_CR_IN_FORMAT);
if (ptrFormatTmp)
{
freeAllocatedSingleString(ptrFormat);
ptrFormat = ptrFormatTmp;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
lenghtFormat = (int)strlen(ptrFormat);
for (i = 0; i < lenghtFormat; i++)
{
if (ptrFormat[i] == PERCENT_CHAR)
{
NumberPercent++;
if ( (i + 1 < lenghtFormat) && (ptrFormat[i + 1] == PERCENT_CHAR))
{
NumberPercent--;
i++;
}
}
}
if ( (Rhs - 1) > NumberPercent )
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong number of input arguments: at most %d expected.\n"), fname, NumberPercent);
return 0;
}
if ( Rhs > 1 )
{
for ( i = 2 ; i <= Rhs ; i++ )
{
int iRows = 0;
int iCols = 0;
int *piAddressVarI = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddressVarI);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarI, &iRows, &iCols);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 0;
}
NumberCols += iCols;
}
}
if ( NumberCols != NumberPercent )
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong number of input arguments: data doesn't fit with format.\n"), fname);
return 0;
}
mOut = 0; /* output line counter */
nmax = 0;
pOutputStrings = NULL;
lcount = 1;
cat_to_last = 0;
while (1)
{
if ((rval = do_xxprintf("msprintf", (FILE *) 0, ptrFormat, Rhs, 1, lcount, (char **) &pStrs)) < 0)
{
break;
}
lcount++;
pStrTmp = (char *)pStrs;
if (pStrTmp == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong value of input argument #%d: data doesn't fit with format.\n"), fname, 1);
return 0;
}
pStrTmp1 = pStrTmp;
while (*pStrTmp != '\0')
{
if (strncmp(pStrTmp, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) == 0)
{
k = (int)(pStrTmp - pStrTmp1);
if (!cat_to_last)
{
/*add a new line */
if (mOut == nmax)
{
nmax += blk;
if (pOutputStrings)
{
pOutputStrings = (char **) REALLOC(pOutputStrings, nmax * sizeof(char **));
}
else
{
pOutputStrings = (char **) MALLOC(nmax * sizeof(char **));
}
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
pOutputStrings[mOut] = (char*)MALLOC((k + 1) * sizeof(char));
if (pOutputStrings[mOut] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(pOutputStrings[mOut], pStrTmp1, k);
pOutputStrings[mOut][k] = EMPTY_CHAR;
mOut++;
}
else
{
/* cat to previous line */
ll = (int)strlen(pOutputStrings[mOut - 1]);
pOutputStrings[mOut - 1] = (char*)REALLOC(pOutputStrings[mOut - 1], (k + 1 + ll) * sizeof(char));
if (pOutputStrings[mOut - 1] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(&(pOutputStrings[mOut - 1][ll]), pStrTmp1, k);
pOutputStrings[mOut - 1][k + ll] = EMPTY_CHAR;
}
k = 0;
pStrTmp += lenghtSplitChar;
pStrTmp1 = pStrTmp;
cat_to_last = 0;
}
else
{
pStrTmp++;
}
}
k = (int)(pStrTmp - pStrTmp1);
if (k > 0)
{
if ((!cat_to_last) || (mOut == 0))
{
/*add a new line */
if (mOut == nmax)
{
nmax += blk;
if (pOutputStrings)
{
pOutputStrings = (char **) REALLOC(pOutputStrings, nmax * sizeof(char **));
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
pOutputStrings = (char **) MALLOC(nmax * sizeof(char **));
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
}
pOutputStrings[mOut] = (char*) MALLOC((k + 1) * sizeof(char));
if (pOutputStrings[mOut] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(pOutputStrings[mOut], pStrTmp1, k);
pOutputStrings[mOut][k] = EMPTY_CHAR;
mOut++;
}
else
{
/* cat to previous line */
ll = (int)strlen(pOutputStrings[mOut - 1]);
pOutputStrings[mOut - 1] = (char*)REALLOC(pOutputStrings[mOut - 1], (k + 1 + ll) * sizeof(char));
if (pOutputStrings[mOut - 1] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(&(pOutputStrings[mOut - 1][ll]), pStrTmp1, k);
pOutputStrings[mOut - 1][k + ll] = EMPTY_CHAR;
}
}
if (strncmp(pStrTmp - lenghtSplitChar, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) != 0)
{
cat_to_last = 1;
}
if (Rhs == 1) break;
}
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
if (rval == RET_BUG) return 0;
/* Create a Scilab String */
nOut = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1 , mOut, nOut, pOutputStrings);
/* lstr must not be freed */
freeArrayOfString(pOutputStrings, mOut * nOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
SciErr getCommonSparseMatrix(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
int iPos = 0;
int iType = 0;
if( _piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_SPARSE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if(iType != sci_sparse)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", _("sparse matrix"));
return sciErr;
}
if(isVarComplex(_pvCtx, _piAddress) != _iComplex)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix");
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if(sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_SPARSE, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexSparseMatrix" : "getSparseMatrix", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
*_piNbItem = _piAddress[4];
if(_piNbItemRow == NULL)
{
return sciErr;
}
*_piNbItemRow = _piAddress + 5;//4 for header + 1 for NbItem
if(_piColPos == NULL)
{
return sciErr;
}
*_piColPos = *_piNbItemRow + *_piRows;
if(_pdblReal == NULL)
{
return sciErr;
}
iPos = (*_piNbItem + *_piRows) % 2 == 1 ? 0 : 1;
*_pdblReal = (double*)(*_piColPos + *_piNbItem + iPos);
if(_iComplex == 1 && _pdblImg != NULL)
{
*_pdblImg = *_pdblReal + *_piNbItem;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int sci_prod(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int iRows = 0;
int iCols = 0;
int*piAddr = NULL;
double* pdblReal = NULL;
double* pdblImg = NULL;
int iRowsRet = 0;
int iColsRet = 0;
double* pdblRealRet = NULL;
double* pdblImgRet = NULL;
int iMode = 0;
CheckRhs(1, 2);
CheckLhs(1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (Rhs == 2)
{
sciErr = getProcessMode(pvApiCtx, 2, piAddr, &iMode);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
sciErr = getVarDimension(pvApiCtx, piAddr, &iRows, &iCols);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (iRows * iCols == 0)
{
double dblVal = 0;
if (iMode == 0)
{
iRows = 1;
iCols = 1;
dblVal = 1;
}
else
{
iRows = 0;
iCols = 0;
}
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, 1, &dblVal);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
switch (iMode)
{
case BY_ROWS :
iRowsRet = 1;
iColsRet = iCols;
break;
case BY_COLS :
iRowsRet = iRows;
iColsRet = 1;
break;
default : //BY_ALL
iRowsRet = 1;
iColsRet = 1;
break;
}
if (isVarComplex(pvApiCtx, piAddr))
{
sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = allocComplexMatrixOfDouble(pvApiCtx, Rhs + 1, iRowsRet, iColsRet, &pdblRealRet, &pdblImgRet);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
vWDmProd(iMode, pdblReal, pdblImg, iRows, iRows, iCols, pdblRealRet, pdblImgRet, 1);
}
else
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = allocMatrixOfDouble(pvApiCtx, Rhs + 1, iRowsRet, iColsRet, &pdblRealRet);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
vDmProd(iMode, pdblReal, iRows, iRows, iCols, pdblRealRet, 1);
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
static int serialize_int(void *_pvCtx, int *_piAddr, int **_piBuffer, int *_piBufferSize)
{
SciErr sciErr;
int iPrecision = 0;
int iRows = 0;
int iCols = 0;
int iItemSize = 0;
void *p = NULL;
void *pvData = NULL;
int *piOut = NULL;
int iOutLen = 0;
sciErr = getVarDimension(_pvCtx, _piAddr, &iRows, &iCols);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrecision);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (iPrecision == SCI_INT8 || iPrecision == SCI_UINT8)
{
iItemSize = sizeof(char);
}
else if (iPrecision == SCI_INT16 || iPrecision == SCI_UINT16)
{
iItemSize = sizeof(short);
}
else if (iPrecision == SCI_INT32 || iPrecision == SCI_UINT32)
{
iItemSize = sizeof(int);
}
/*
else if(iPrecision == SCI_INT64 || iPrecision == SCI_UINT64)
{
iItemSize = sizeof(long long);
}
*/
//check and adjust alignement on integer
iOutLen = iRows * iCols;
if ((iOutLen * iItemSize) % sizeof(int))
{
iOutLen = (iOutLen * iItemSize) / sizeof(int) + 1;
}
else
{
iOutLen = (iOutLen * iItemSize) / (sizeof(int));
}
iOutLen += 4;
piOut = (int *)MALLOC(iOutLen * sizeof(int *));
if (piOut == NULL)
{
return 1;
}
piOut[0] = sci_ints;
piOut[1] = iRows;
piOut[2] = iCols;
piOut[3] = iPrecision; //precision
switch (iPrecision)
{
case SCI_INT8:
{
sciErr = getMatrixOfInteger8(_pvCtx, _piAddr, &iRows, &iCols, (char **)&pvData);
break;
}
case SCI_UINT8:
{
sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddr, &iRows, &iCols, (unsigned char **)&pvData);
break;
}
case SCI_INT16:
{
sciErr = getMatrixOfInteger16(_pvCtx, _piAddr, &iRows, &iCols, (short **)&pvData);
break;
}
case SCI_UINT16:
{
sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddr, &iRows, &iCols, (unsigned short **)&pvData);
break;
}
case SCI_INT32:
{
sciErr = getMatrixOfInteger32(_pvCtx, _piAddr, &iRows, &iCols, (int **)&pvData);
break;
}
case SCI_UINT32:
{
sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddr, &iRows, &iCols, (unsigned int **)&pvData);
break;
}
/*
case SCI_INT64 :
{
sciErr = getMatrixOfInteger64(_pvCtx, _piAddr, &iRows, &iCols, (long long**)&pvData);
break;
}
case SCI_UINT64 :
{
sciErr = getMatrixOfUnsignedInteger64(_pvCtx, _piAddr, &iRows, &iCols, (unsigned long long**)&pvData);
break;
}
*/ default:
FREE(piOut);
return 1;
}
if (sciErr.iErr)
{
FREE(piOut);
printError(&sciErr, 0);
return 1;
}
p = piOut + 4;
memcpy(p, pvData, iRows * iCols * iItemSize);
*_piBuffer = piOut;
*_piBufferSize = iOutLen;
return 0;
}
/*******************************************************************************
Interface for MATIO function called Mat_Open
Scilab function name : matfile_open
*******************************************************************************/
int sci_matfile_open(char *fname, void* pvApiCtx)
{
int nbRow = 0, nbCol = 0;
mat_t *matfile;
int fileIndex = 0;
char * filename = NULL;
char * optionStr = NULL;
int option = 0, var_type;
int * filename_addr = NULL, * option_addr = NULL, * version_addr = NULL;
char * versionStr = NULL;
int version = MAT_FT_MAT5; // By default, use MAtlab 5 files
SciErr sciErr;
CheckRhs(1, 3);
CheckLhs(1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &filename_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, filename_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (var_type == sci_strings)
{
getAllocatedSingleString(pvApiCtx, filename_addr, &filename);
sciErr = getVarDimension(pvApiCtx, filename_addr, &nbRow, &nbCol);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (nbCol != 1)
{
Scierror(999, _("%s: Wrong size for first input argument: string expected.\n"), fname);
freeAllocatedSingleString(filename);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for first input argument: string expected.\n"), fname);
freeAllocatedSingleString(filename);
return FALSE;
}
if (Rhs >= 2)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &option_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, option_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (var_type == sci_strings)
{
getAllocatedSingleString(pvApiCtx, option_addr, &optionStr);
sciErr = getVarDimension(pvApiCtx, option_addr, &nbRow, &nbCol);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (nbCol != 1)
{
Scierror(999, _("%s: Wrong size for second input argument: string expected.\n"), fname);
freeAllocatedSingleString(filename);
freeAllocatedSingleString(optionStr);
return FALSE;
}
if (strcmp(optionStr, "r") == 0)
{
option = MAT_ACC_RDONLY;
}
else if (strcmp(optionStr, "w") == 0)
{
option = MAT_ACC_RDWR;
}
else
{
Scierror(999, _("%s: Wrong value for second input argument: 'r' or 'w' expected.\n"), fname);
freeAllocatedSingleString(filename);
freeAllocatedSingleString(optionStr);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for second input argument: string expected.\n"), fname);
freeAllocatedSingleString(filename);
freeAllocatedSingleString(optionStr);
return FALSE;
}
}
else
{
/* Default option value */
option = MAT_ACC_RDONLY;
}
if (Rhs >= 3)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &version_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, version_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
printf("sci_strings %d %d\n", var_type, sci_strings);
if (var_type == sci_strings)
{
getAllocatedSingleString(pvApiCtx, version_addr, &versionStr);
sciErr = getVarDimension(pvApiCtx, version_addr, &nbRow, &nbCol);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 3);
freeAllocatedSingleString(filename);
freeAllocatedSingleString(optionStr);
freeAllocatedSingleString(versionStr);
return FALSE;
}
if (strcmp(versionStr, "7.3") == 0)
{
version = MAT_FT_MAT73; // Matlab 7.3 file
}
else
{
version = MAT_FT_MAT5; // Default, Matlab 5 file
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
return 0;
}
}
if (option == MAT_ACC_RDWR) // Write, option = "w"
{
/* create a Matlab 5 or 7.3 file */
matfile = Mat_CreateVer(filename, NULL, version);
}
else // Read, option = "r"
{
/* Try to open the file (as a Matlab 5 file) */
matfile = Mat_Open(filename, option);
}
if (matfile == NULL) /* Opening failed */
{
/* Function returns -1 */
fileIndex = -1;
}
if (matfile != NULL) /* Opening succeed */
{
/* Add the file to the manager */
matfile_manager(MATFILEMANAGER_ADDFILE, &fileIndex, &matfile);
}
/* Return the index */
createScalarDouble(pvApiCtx, Rhs + 1, (double)fileIndex);
freeAllocatedSingleString(filename);
freeAllocatedSingleString(optionStr);
freeAllocatedSingleString(versionStr);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_fprintfMat(char *fname,unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
int *piAddressVarTwo = NULL;
int m2 = 0, n2 = 0;
int iType2 = 0;
fprintfMatError ierr = FPRINTFMAT_ERROR;
char *filename = NULL;
char *expandedFilename = NULL;
char **textAdded = NULL;
char *Format = NULL;
double *dValues = NULL;
char *separator = NULL;
int m4n4 = 0;
int i = 0;
Nbvars = 0;
CheckRhs(1,5);
CheckLhs(1,1);
if (Rhs >= 3)
{
int *piAddressVarThree = NULL;
int iType3 = 0;
int m3 = 0, n3 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarThree, &iType3);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (iType3 != sci_strings)
{
Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarThree, &m3, &n3);
if ( (m3 != n3) && (n3 != 1) )
{
Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &Format))
{
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Format = strdup(DEFAULT_FPRINTFMAT_FORMAT);
}
if ( Rhs >= 4 )
{
int *piAddressVarFour = NULL;
int *lengthStrings = NULL;
int iType4 = 0;
int m4 = 0, n4 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour);
if(sciErr.iErr)
{
if (Format) {FREE(Format); Format = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarFour, &iType4);
if(sciErr.iErr)
{
if (Format) {FREE(Format); Format = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
if (iType4 != sci_strings)
{
if (Format) {FREE(Format); Format = NULL;}
Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 4);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &m4, &n4);
if(sciErr.iErr)
{
if (Format) {FREE(Format); Format = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
if (! ((m4 == 1) || (n4 == 1)))
{
if (Format) {FREE(Format); Format = NULL;}
Scierror(999,_("%s: Wrong size for input argument #%d.\n"), fname, 4);
return 0;
}
lengthStrings = (int*)MALLOC(sizeof(int) * (m4 * n4));
if (lengthStrings == NULL)
{
if (Format) {FREE(Format); Format = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
// get lengthStrings value
sciErr = getMatrixOfString(pvApiCtx, piAddressVarFour, &m4, &n4, lengthStrings, NULL);
if(sciErr.iErr)
{
if (Format) {FREE(Format); Format = NULL;}
if (lengthStrings) {FREE(lengthStrings); lengthStrings = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
textAdded = (char**)MALLOC(sizeof(char*) * (m4 * n4));
if (textAdded == NULL)
{
if (Format) {FREE(Format); Format = NULL;}
if (lengthStrings) {FREE(lengthStrings); lengthStrings = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
for (i = 0; i < (m4 * n4); i++)
{
textAdded[i] = (char*)MALLOC(sizeof(char) * (lengthStrings[i] + 1));
if (textAdded[i] == NULL)
{
freeArrayOfString(textAdded, m4 * n4);
if (Format) {FREE(Format); Format = NULL;}
if (lengthStrings) {FREE(lengthStrings); lengthStrings = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"),fname);
return 0;
}
}
// get textAdded
sciErr = getMatrixOfString(pvApiCtx, piAddressVarFour, &m4, &n4, lengthStrings, textAdded);
if (lengthStrings) {FREE(lengthStrings); lengthStrings = NULL;}
if(sciErr.iErr)
{
freeArrayOfString(textAdded, m4 * n4);
if (Format) {FREE(Format); Format = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
m4n4 = m4 * n4;
}
if (Rhs > 4)
{
int *piAddressVarFive = NULL;
int iType5 = 0;
int m5 = 0, n5 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddressVarFive);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 5);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarFive, &iType5);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 5);
return 0;
}
if (iType5 != sci_strings)
{
Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 5);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarFive, &m5, &n5);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 5);
return 0;
}
if ( (m5 != n5) && (n5 != 1) )
{
Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 5);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarFive, &separator))
{
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
separator = strdup(DEFAULT_FPRINTFMAT_SEPARATOR);
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if(sciErr.iErr)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if(sciErr.iErr)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (iType2 != sci_matrix)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
Scierror(999,_("%s: Wrong type for input argument #%d: Matrix of floating point numbers expected.\n"), fname, 2);
return 0;
}
if (isVarComplex(pvApiCtx, piAddressVarTwo))
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
Scierror(999,_("%s: Wrong type for input argument #%d: Real values expected.\n"), fname, 2);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo, &m2, &n2, &dValues);
if(sciErr.iErr)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if(sciErr.iErr)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (iType1 != sci_strings)
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if ( (m1 != n1) && (n1 != 1) )
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &filename))
{
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
expandedFilename = expandPathVariable(filename);
ierr = fprintfMat(expandedFilename, Format, separator, dValues, m2, n2,textAdded, m4n4);
if (expandedFilename) {FREE(expandedFilename); expandedFilename = NULL;}
if (textAdded) freeArrayOfString(textAdded, m4n4);
if (Format) {FREE(Format); Format = NULL;}
if (separator){FREE(separator); separator = NULL;}
switch(ierr)
{
case FPRINTFMAT_NO_ERROR:
{
LhsVar(1) = 0;
if (filename) {FREE(filename); filename = NULL;}
PutLhsVar();
}
break;
case FPRINTFMAT_FOPEN_ERROR:
{
Scierror(999,_("%s: can not open file %s.\n"), fname, filename);
}
break;
case FPRINTMAT_FORMAT_ERROR:
{
Scierror(999,_("%s: Invalid format.\n"), fname);
}
break;
default:
case FPRINTFMAT_ERROR:
{
Scierror(999,_("%s: error.\n"), fname);
}
break;
}
if (filename) {FREE(filename); filename = NULL;}
return 0;
}
SciErr getCommonMatrixOfPoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr = sciErrInit();
int iType = 0;
int iSize = 0;
int *piOffset = NULL;
double *pdblReal = NULL;
double *pdblImg = NULL;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (iType != sci_poly)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", _("polynomial matrix"));
return sciErr;
}
if (isVarComplex(_pvCtx, _piAddress) != _iComplex)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
iSize = *_piRows **_piCols;
if (_piNbCoef == NULL)
{
return sciErr;
}
types::Polynom *pMP = ((types::InternalType*)_piAddress)->getAs<types::Polynom>();
pMP->getSizes(_piNbCoef);
if (_pdblReal == NULL)
{
return sciErr;
}
types::SinglePoly** pSP = pMP->get();
if (_iComplex == 1)
{
for (int i = 0 ; i < iSize ; i++)
{
memcpy(_pdblReal[i], pSP[i]->get(), sizeof(double) * pSP[i]->getSize());
memcpy(_pdblImg[i], pSP[i]->getImg(), sizeof(double) * _piNbCoef[i]);
}
}
else
{
for (int i = 0 ; i < iSize ; i++)
{
memcpy(_pdblReal[i], pSP[i]->get(), sizeof(double) * pSP[i]->getSize());
}
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iType = 0;
int iRows = 0;
int iCols = 0;
double *pdblReal = NULL;
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
return sciErr;
}
if (iType == sci_matrix)
{
if (isVarComplex(_pvCtx, _piAddress))
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument %d: Real matrix expected.\n"), "getDimFromVar",
getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = (int)Max(pdblReal[0], 0);
}
else if (iType == sci_ints)
{
int iPrec = 0;
sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
return sciErr;
}
if (iRows != 1 || iCols != 1)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode",
getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
return sciErr;
}
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
return sciErr;
}
switch (iPrec)
{
case SCI_INT8:
{
char *pcData = NULL;
sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pcData[0];
}
break;
case SCI_UINT8:
{
unsigned char *pucData = NULL;
sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pucData[0];
}
break;
case SCI_INT16:
{
short *psData = NULL;
sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = psData[0];
}
break;
case SCI_UINT16:
{
unsigned short *pusData = NULL;
sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pusData[0];
}
break;
case SCI_INT32:
{
int *piData = NULL;
sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = piData[0];
}
break;
case SCI_UINT32:
{
unsigned int *puiData = NULL;
sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = puiData[0];
}
break;
}
}
else
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or an integer scalar expected.\n"),
"getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
SciErr getProcessMode(void *_pvCtx, int _iPos, int *_piAddRef, int *_piMode)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iRows1 = 0;
int iCols1 = 0;
int iRows2 = 0;
int iCols2 = 0;
int iType2 = 0;
int iMode = 0;
int *piAddr2 = NULL;
sciErr = getVarDimension(_pvCtx, _piAddRef, &iRows1, &iCols1);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
return sciErr;
}
//sciprint("getProcessMode ->");
sciErr = getinternalVarAddress(_pvCtx, _iPos, &piAddr2);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get variable address"), "getProcessMode");
return sciErr;
}
sciErr = getVarType(_pvCtx, piAddr2, &iType2);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument type"), "getProcessMode");
return sciErr;
}
if (iType2 == sci_matrix && !isVarComplex(_pvCtx, piAddr2))
{
double *pdblReal2 = NULL;
sciErr = getMatrixOfDouble(_pvCtx, piAddr2, &iRows2, &iCols2, &pdblReal2);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
return sciErr;
}
if (iRows2 != 1 || iCols2 != 1)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1,
1);
return sciErr;
}
iMode = (int)pdblReal2[0];
}
else if (iType2 == sci_strings)
{
int iLen = 0;
char *pstMode[1] = { "" };
sciErr = getVarDimension(_pvCtx, piAddr2, &iRows2, &iCols2);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument dimension"), "getProcessMode");
return sciErr;
}
if (iRows2 != 1 || iCols2 != 1)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode", _iPos, 1,
1);
return sciErr;
}
sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, NULL);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
return sciErr;
}
pstMode[0] = (char *)MALLOC(sizeof(char) * (iLen + 1)); //+1 for null termination
sciErr = getMatrixOfString(_pvCtx, piAddr2, &iRows2, &iCols2, &iLen, pstMode);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Unable to get argument data"), "getProcessMode");
return sciErr;
}
iMode = (int)pstMode[0][0];
FREE(pstMode[0]);
}
else
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong type for input argument #%d: A string or a scalar expected.\n"),
"getProcessMode", _iPos);
return sciErr;
}
if (iMode == ROW_LETTER || iMode == BY_ROWS)
{
*_piMode = BY_ROWS;
}
else if (iMode == COL_LETTER || iMode == BY_COLS)
{
*_piMode = BY_COLS;
}
else if (iMode == STAR_LETTER || iMode == BY_ALL)
{
*_piMode = BY_ALL;
}
else if (iMode == MTLB_LETTER || iMode == BY_MTLB)
{
*_piMode = 0;
if (iRows1 > 1)
{
*_piMode = 1;
}
else if (iCols1 > 1)
{
*_piMode = 2;
}
}
else
{
addErrorMessage(&sciErr, API_ERROR_GET_PROCESSMODE, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), "getProcessMode",
_iPos, "'*', 'r', 'c', 'm', '0', '1', '2'", "-1");
return sciErr;
}
return sciErr;
}
int ScilabGateway::deff(char * fname, const int envId, void * pvApiCtx)
{
static int ONE = 1;
static int TWO = 2;
static int THREE = 3;
SciErr err;
char ** names[] = {0, 0, 0};
int ret = 0;
std::ostringstream os;
int * addr[] = {0, 0, 0};
int rows[] = {0, 0, 0};
int cols[] = {0, 0, 0};
int error = 0;
char * cwd = 0;
CheckInputArgument(pvApiCtx, 3, 3);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper & helper = env.getOptionsHelper();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
if (pCall == nullptr)
{
symbol::Context* ctx = symbol::Context::getInstance();
types::InternalType* pIT = ctx->get(symbol::Symbol(L"#_deff_wrapper"));
if (pIT && pIT->isCallable())
{
pCall = pIT->getAs<types::Callable>();
}
else
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
for (int i = 0; i < 3; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i + 1, &(addr[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr[i]))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
err = getVarDimension(pvApiCtx, addr[i], &(rows[i]), &(cols[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (rows[0] != 1 || cols[0] != 1)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions for input argument #%d: A single string expected."), 1);
}
if (rows[1] != rows[2] || cols[1] != cols[2])
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions: arguments #2 and #3 must have the same."));
}
for (int i = 0; i < 3; i++)
{
if (getAllocatedMatrixOfString(pvApiCtx, addr[i], &(rows[i]), &(cols[i]), &(names[i])))
{
for (int j = 0; j < i; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
try
{
ret = env.loadclass(names[0][0], cwd, false, helper.getAllowReload());
}
catch (std::exception & /*e*/)
{
FREE(cwd);
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw;
}
FREE(cwd);
for (int i = 0; i < rows[1] * cols[1]; i++)
{
//call #_deff_wrapper
types::typed_list in, out;
types::optional_list opt;
//name
in.push_back(new types::String(names[2][i]));
//protopype
os.str("");
os << "y=" << names[2][i] << "(varargin)" << std::flush;
in.push_back(new types::String(os.str().c_str()));
//body
os.str("");
os << "y=invoke_lu(int32(" << ret << "),int32(" << envId << "),\"" << names[1][i] << "\",varargin)" << std::flush;
in.push_back(new types::String(os.str().c_str()));
ast::ExecVisitor exec;
if (pCall->call(in, opt, 0, out, &exec) != types::Function::OK)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
}
for (int i = 0; i < 3; i++)
{
freeAllocatedMatrixOfString(rows[0], cols[0], names[i]);
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_isdir(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
wchar_t **pStVarOne = NULL;
int iType = 0;
int *lenStVarOne = NULL;
int m1 = 0, n1 = 0;
BOOL *results = NULL;
int i = 0;
/* Check Input & Output parameters */
CheckRhs(1, 1);
CheckLhs(1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (iType != sci_strings)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
lenStVarOne = (int*)MALLOC(sizeof(int) * (m1 * n1));
if (lenStVarOne == NULL)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
results = (BOOL*)MALLOC(sizeof(BOOL) * (m1 * n1));
if (results == NULL)
{
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pStVarOne, m1 * n1);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
FREE(results);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
pStVarOne = (wchar_t**)MALLOC(sizeof(wchar_t*) * (m1 * n1));
if (pStVarOne == NULL)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
for (i = 0; i < m1 * n1; i++)
{
pStVarOne[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (lenStVarOne[i] + 1));
if (pStVarOne[i] == NULL)
{
freeArrayOfWideString(pStVarOne, m1 * n1);
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pStVarOne);
if (sciErr.iErr)
{
freeArrayOfWideString(pStVarOne, m1 * n1);
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
for (i = 0; i < m1 * n1; i++)
{
wchar_t *expandedPath = expandPathVariableW(pStVarOne[i]);
if (expandedPath)
{
results[i] = isdirW(expandedPath);
FREE(expandedPath);
expandedPath = NULL;
}
else
{
results[i] = FALSE;
}
}
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pStVarOne, m1 * n1);
sciErr = createMatrixOfBoolean(pvApiCtx, Rhs + 1, m1, n1, results);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
if (results)
{
FREE(results);
results = NULL;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int isasciiStrings(char *fname, int *piAddressVarOne)
{
SciErr sciErr;
int m1 = 0, n1 = 0;
wchar_t **pwcStVarOne = NULL;
int *lenStVarOne = NULL;
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
lenStVarOne = (int*)MALLOC(sizeof(int) * (m1 * n1));
if (lenStVarOne)
{
BOOL *bOutputMatrix = NULL;
int i = 0;
int lengthAllStrings = 0;
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, NULL);
if (sciErr.iErr)
{
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
pwcStVarOne = (wchar_t**)MALLOC(sizeof(wchar_t*) * (m1 * n1));
for (i = 0; i < (m1 * n1); i++)
{
lengthAllStrings = lengthAllStrings + lenStVarOne[i];
pwcStVarOne[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (lenStVarOne[i] + 1));
if (pwcStVarOne[i] == NULL)
{
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pwcStVarOne, m1 * n1);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
sciErr = getMatrixOfWideString(pvApiCtx, piAddressVarOne, &m1, &n1, lenStVarOne, pwcStVarOne);
if (sciErr.iErr)
{
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pwcStVarOne, m1 * n1);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
bOutputMatrix = (BOOL*)MALLOC(sizeof(BOOL) * lengthAllStrings);
if (bOutputMatrix)
{
int mOut = 0;
int nOut = 0;
int x = 0;
for (i = 0; i < (m1 * n1); i++)
{
int j = 0;
wchar_t* wcInput = pwcStVarOne[i];
int len = (int)wcslen(wcInput);
for (j = 0; j < len; j++)
{
if (iswascii(wcInput[j]))
{
bOutputMatrix[x] = (int)TRUE;
}
else
{
bOutputMatrix[x] = (int)FALSE;
}
x++;
}
}
mOut = 1;
nOut = lengthAllStrings;
sciErr = createMatrixOfBoolean(pvApiCtx, Rhs + 1, mOut, nOut, bOutputMatrix);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pwcStVarOne, m1 * n1);
if (bOutputMatrix)
{
FREE(bOutputMatrix);
bOutputMatrix = NULL;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
if (lenStVarOne)
{
FREE(lenStVarOne);
lenStVarOne = NULL;
}
freeArrayOfWideString(pwcStVarOne, m1 * n1);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
return 0;
}
int ScilabGateway::evalString(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int row;
int col;
char ** code = 0;
ScilabStringStackAllocator * allocator = 0;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 1, 1);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: string expected."), 1);
}
err = getVarDimension(pvApiCtx, addr, &row, &col);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if ((row < 1 || col != 1) && (col < 1 || row != 1))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimension for argument #%d: A row or a column expected."), 1);
}
if (getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &code))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (Rhs == 2)
{
int val;
err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isBooleanType(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A boolean expected."), 2);
}
if (!isScalar(pvApiCtx, addr))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A single boolean expected."), 2);
}
getScalarBoolean(pvApiCtx, addr, &val);
if (val)
{
allocator = new ScilabStringStackAllocator(pvApiCtx, Rhs + 1);
}
}
try
{
env.evalString(const_cast<const char **>(code), row * col, allocator);
}
catch (std::exception & /*e*/)
{
freeAllocatedMatrixOfString(row, col, code);
throw;
}
if (allocator)
{
delete allocator;
LhsVar(1) = Rhs + 1;
}
else
{
LhsVar(1) = 0;
}
PutLhsVar();
return 0;
}
int ScilabGateway::deff(char * fname, const int envId, void * pvApiCtx)
{
static int ONE = 1;
static int TWO = 2;
static int THREE = 3;
SciErr err;
char ** names[] = {0, 0, 0};
int ret = 0;
std::ostringstream os;
char * str;
int * addr[] = {0, 0, 0};
int rows[] = {0, 0, 0};
int cols[] = {0, 0, 0};
int error = 0;
char * cwd = 0;
CheckInputArgument(pvApiCtx, 3, 3);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper & helper = env.getOptionsHelper();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
for (int i = 0; i < 3; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i + 1, &(addr[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr[i]))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
err = getVarDimension(pvApiCtx, addr[i], &(rows[i]), &(cols[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (rows[0] != 1 || cols[0] != 1)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions for input argument #%d: A single string expected."), 1);
}
if (rows[1] != rows[2] || cols[1] != cols[2])
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions: arguments #2 and #3 must have the same."));
}
for (int i = 0; i < 3; i++)
{
if (getAllocatedMatrixOfString(pvApiCtx, addr[i], &(rows[i]), &(cols[i]), &(names[i])))
{
for (int j = 0; j < i; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
try
{
ret = env.loadclass(names[0][0], cwd, false, helper.getAllowReload());
}
catch (std::exception & e)
{
FREE(cwd);
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw;
}
FREE(cwd);
for (int i = 0; i < rows[1] * cols[1]; i++)
{
err = createMatrixOfString(pvApiCtx, ONE, 1, 1, (const char * const *) & (names[2][i]));
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=" << names[2][i] << "(varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, TWO, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=invoke_lu(int32(" << ret << "),int32(" << envId << "),\"" << names[1][i] << "\",varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, THREE, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
SciString(&ONE, const_cast<char *>("!_deff_wrapper"), &ONE, &THREE);
}
for (int i = 0; i < 3; i++)
{
freeAllocatedMatrixOfString(rows[0], cols[0], names[i]);
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int isasciiMatrix(char *fname, int *piAddressVarOne)
{
SciErr sciErr;
int m1 = 0, n1 = 0;
double *pdVarOne = NULL;
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &m1, &n1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (m1 * n1 > 0)
{
BOOL *bOutputMatrix = NULL;
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &pdVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
bOutputMatrix = (BOOL*)MALLOC(sizeof(BOOL) * (m1 * n1));
if (bOutputMatrix)
{
int nbElems = m1 * n1;
int i = 0;
for (i = 0; i < nbElems; i++)
{
int iVal = (int)pdVarOne[i];
if (isascii(iVal))
{
bOutputMatrix[i] = (int)TRUE;
}
else
{
bOutputMatrix[i] = (int)FALSE;
}
}
sciErr = createMatrixOfBoolean(pvApiCtx, Rhs + 1, m1, n1, bOutputMatrix);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (bOutputMatrix)
{
FREE(bOutputMatrix);
bOutputMatrix = NULL;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
/* returns [] */
m1 = 0;
n1 = 0;
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, m1, n1, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
SciErr getCommonMatrixOfPoly(void* _pvCtx, int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iType = 0;
int iSize = 0;
int *piOffset = NULL;
double *pdblReal = NULL;
double *pdblImg = NULL;
if (_piAddress == NULL)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
return sciErr;
}
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
if (iType != sci_poly)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s excepted"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", _("polynomial matrix"));
return sciErr;
}
if (isVarComplex(_pvCtx, _piAddress) != _iComplex)
{
addErrorMessage(&sciErr, API_ERROR_INVALID_COMPLEXITY, _("%s: Bad call to get a non complex matrix"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly");
return sciErr;
}
sciErr = getVarDimension(_pvCtx, _piAddress, _piRows, _piCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_POLY, _("%s: Unable to get argument #%d"), _iComplex ? "getComplexMatrixOfPoly" : "getMatrixOfPoly", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
iSize = *_piRows * *_piCols;
if (_piNbCoef == NULL)
{
return sciErr;
}
piOffset = _piAddress + 8; //4 for header and 4 for variable name
for (int i = 0 ; i < iSize ; i++)
{
_piNbCoef[i] = piOffset[i + 1] - piOffset[i];
}
if (_pdblReal == NULL)
{
return sciErr;
}
pdblReal = (double*)(piOffset + iSize + 1 + ((iSize + 1) % 2 == 0 ? 0 : 1 ));
for (int i = 0 ; i < iSize ; i++)
{
memcpy(_pdblReal[i], pdblReal + piOffset[i] - 1, sizeof(double) * _piNbCoef[i]);
}
if (_iComplex == 1)
{
pdblImg = pdblReal + piOffset[iSize] - 1;
for (int i = 0 ; i < iSize ; i++)
{
memcpy(_pdblImg[i], pdblImg + piOffset[i] - 1, sizeof(double) * _piNbCoef[i]);
}
}
return sciErr;
}
int sci_eigs(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int iRowsOne = 0;
int iColsOne = 0;
double elemt1 = 0;
double elemt2 = 0;
double* Areal = NULL;
doublecomplex* Acplx = NULL;
int Asym = 1;
int Acomplex = 0;
int N = 0;
int *piAddressVarTwo = NULL;
int iTypeVarTwo = 0;
int iRowsTwo = 0;
int iColsTwo = 0;
double* Breal = NULL;
doublecomplex* Bcplx = NULL;
int Bcomplex = 0;
int matB = 0;
int *piAddressVarThree = NULL;
double dblNEV = 0;
int iNEV = 0;
int *piAddressVarFour = NULL;
int iTypeVarFour = 0;
int iRowsFour = 0;
int iColsFour = 0;
char* pstData = NULL;
doublecomplex SIGMA;
int *piAddressVarFive = NULL;
double dblMAXITER = 0;
int *piAddressVarSix = NULL;
double dblTOL = 0;
int *piAddressVarSeven = NULL;
int TypeVarSeven = 0;
int RowsSeven = 0;
int ColsSeven = 0;
double* dblNCV = NULL;
int *piAddressVarEight = NULL;
int iTypeVarEight = 0;
double dblCHOLB = 0;
int iCHOLB = 0;
int *piAddressVarNine = NULL;
int iTypeVarNine = 0;
int iRowsNine = 0;
int iColsNine = 0;
double* RESID = NULL;
doublecomplex* RESIDC = NULL;
int *piAddressVarTen = NULL;
int iINFO = 0;
int RVEC = 0;
// Output arguments
double* eigenvalue = NULL;
double* eigenvector = NULL;
doublecomplex* eigenvalueC = NULL;
doublecomplex* eigenvectorC = NULL;
double* mat_eigenvalue = NULL;
doublecomplex* mat_eigenvalueC = NULL;
int INFO_EUPD = 0;
int error = 0;
int iErr = 0;
int i = 0;
int j = 0;
CheckInputArgument(pvApiCtx, 1, 10);
CheckOutputArgument(pvApiCtx, 0, 2);
/****************************************
* First variable : A *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 1;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne);
//check if A is a square matrix
if (iRowsOne * iColsOne == 1 || iRowsOne != iColsOne)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "eigs", 1);
return 1;
}
N = iRowsOne;
//check if A is complex
if (isVarComplex(pvApiCtx, piAddressVarOne))
{
sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne, &Acplx);
Acomplex = 1;
}
else
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &iRowsOne, &iColsOne, &Areal);
for (i = 0; i < iColsOne; i++)
{
for (j = 0; j < i; j++)
{
elemt1 = Areal[j + i * iColsOne];
elemt2 = Areal[j * iColsOne + i];
if (fabs(elemt1 - elemt2) > 0)
{
Asym = 0;
break;
}
}
if (Asym == 0)
{
break;
}
}
}
/****************************************
* Second variable : B *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 1;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iTypeVarTwo);
if (sciErr.iErr || iTypeVarTwo != sci_matrix)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Wrong type for input argument #%d: An empty matrix or full or sparse square matrix expected.\n"), "eigs", 2);
return 1;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo);
matB = iRowsTwo * iColsTwo;
if (matB && (iRowsTwo != iRowsOne || iColsTwo != iColsOne))
{
Scierror(999, _("%s: Wrong dimension for input argument #%d: B must have the same size as A.\n"), "eigs", 2);
return 1;
}
if (isVarComplex(pvApiCtx, piAddressVarTwo))
{
sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo, &Bcplx);
Bcomplex = 1;
}
else
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo, &iRowsTwo, &iColsTwo, &Breal);
}
if (matB != 0)
{
if (Acomplex && !Bcomplex)
{
Bcplx = (doublecomplex*)MALLOC(N * N * sizeof(doublecomplex));
memset(Bcplx, 0, N * N * sizeof(doublecomplex));
Bcomplex = 1;
for (i = 0 ; i < N * N ; i++)
{
Bcplx[i].r = Breal[i];
}
}
if (!Acomplex && Bcomplex)
{
Acplx = (doublecomplex*)MALLOC(N * N * sizeof(doublecomplex));
memset(Acplx, 0, N * N * sizeof(doublecomplex));
Acomplex = 1;
for (i = 0 ; i < N * N ; i++)
{
Acplx[i].r = Areal[i];
}
}
}
/****************************************
* NEV *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
FREE_AB;
return 1;
}
iErr = getScalarDouble(pvApiCtx, piAddressVarThree, &dblNEV);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
FREE_AB;
return 1;
}
if (isVarComplex(pvApiCtx, piAddressVarThree))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 3);
FREE_AB;
return 1;
}
if (dblNEV != floor(dblNEV) || (dblNEV <= 0))
{
Scierror(999, _("%s: Wrong type for input argument #%d: k must be a positive integer.\n"), "eigs", 3);
FREE_AB;
return 1;
}
if (!finite(dblNEV))
{
Scierror(999, _("%s: Wrong value for input argument #%d: k must be in the range 1 to N.\n"), "eigs", 3);
FREE_AB;
return 1;
}
iNEV = (int)dblNEV;
/****************************************
* SIGMA AND WHICH *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddressVarFour);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
FREE_AB;
return 1;
}
sciErr = getVarType(pvApiCtx, piAddressVarFour, &iTypeVarFour);
if (sciErr.iErr || (iTypeVarFour != sci_matrix && iTypeVarFour != sci_strings))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
FREE_AB;
return 1;
}
if (iTypeVarFour == sci_strings)
{
int iErr = getAllocatedSingleString(pvApiCtx, piAddressVarFour, &pstData);
if (iErr)
{
FREE_AB;
return 1;
}
if (strcmp(pstData, "LM") != 0 && strcmp(pstData, "SM") != 0 && strcmp(pstData, "LR") != 0 && strcmp(pstData, "SR") != 0 && strcmp(pstData, "LI") != 0
&& strcmp(pstData, "SI") != 0 && strcmp(pstData, "LA") != 0 && strcmp(pstData, "SA") != 0 && strcmp(pstData, "BE") != 0)
{
if (!Acomplex && Asym)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s' or '%s'.\n" ),
"eigs", 4, "LM", "SM", "LA", "SA", "BE");
freeAllocatedSingleString(pstData);
return 1;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: Unrecognized sigma value.\n Sigma must be one of '%s', '%s', '%s', '%s', '%s' or '%s'.\n " ),
"eigs", 4, "LM", "SM", "LR", "SR", "LI", "SI");
FREE_AB;
freeAllocatedSingleString(pstData);
return 1;
}
}
if ((Acomplex || !Asym) && (strcmp(pstData, "LA") == 0 || strcmp(pstData, "SA") == 0 || strcmp(pstData, "BE") == 0))
{
Scierror(999, _("%s: Invalid sigma value for complex or non symmetric problem.\n"), "eigs", 4);
FREE_AB;
freeAllocatedSingleString(pstData);
return 1;
}
if (!Acomplex && Asym && (strcmp(pstData, "LR") == 0 || strcmp(pstData, "SR") == 0 || strcmp(pstData, "LI") == 0 || strcmp(pstData, "SI") == 0))
{
Scierror(999, _("%s: Invalid sigma value for real symmetric problem.\n"), "eigs", 4);
freeAllocatedSingleString(pstData);
return 1;
}
SIGMA.r = 0;
SIGMA.i = 0;
}
if (iTypeVarFour == sci_matrix)
{
sciErr = getVarDimension(pvApiCtx, piAddressVarFour, &iRowsFour, &iColsFour);
if (iRowsFour * iColsFour != 1)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), "eigs", 4);
FREE_AB;
return 1;
}
if (getScalarComplexDouble(pvApiCtx, piAddressVarFour, &SIGMA.r, &SIGMA.i))
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
FREE_AB;
return 1;
}
if (C2F(isanan)(&SIGMA.r) || C2F(isanan)(&SIGMA.i))
{
Scierror(999, _("%s: Wrong type for input argument #%d: sigma must be a real.\n"), "eigs", 4);
FREE_AB;
return 1;
}
pstData = "LM";
}
/****************************************
* MAXITER *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddressVarFive);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 5);
FREE_AB;
FREE_PSTDATA;
return 0;
}
iErr = getScalarDouble(pvApiCtx, piAddressVarFive, &dblMAXITER);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a scalar.\n"), "eigs", 5, "opts.maxiter");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if ((dblMAXITER != floor(dblMAXITER)) || (dblMAXITER <= 0))
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer positive value.\n"), "eigs", 5, "opts.maxiter");
FREE_AB;
FREE_PSTDATA;
return 1;
}
/****************************************
* TOL *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddressVarSix);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 6);
FREE_AB;
FREE_PSTDATA;
return 1;
}
iErr = getScalarDouble(pvApiCtx, piAddressVarSix, &dblTOL);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (C2F(isanan)(&dblTOL))
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be a real scalar.\n"), "eigs", 6, "opts.tol");
FREE_AB;
FREE_PSTDATA;
return 1;
}
/****************************************
* NCV *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddressVarSeven);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 7);
FREE_AB;
FREE_PSTDATA;
return 1;
}
sciErr = getVarType(pvApiCtx, piAddressVarSeven, &TypeVarSeven);
if (sciErr.iErr || TypeVarSeven != sci_matrix)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
FREE_AB;
FREE_PSTDATA;
return 1;
}
else
{
if (isVarComplex(pvApiCtx, piAddressVarSeven))
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
}
else
{
sciErr = getVarDimension(pvApiCtx, piAddressVarSeven, &RowsSeven, &ColsSeven);
if (RowsSeven * ColsSeven > 1)
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (RowsSeven * ColsSeven == 1)
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarSeven, &RowsSeven, &ColsSeven, &dblNCV);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 7);
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (dblNCV[0] != floor(dblNCV[0]))
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar.\n"), "eigs", 7, "opts.ncv");
FREE_AB;
FREE_PSTDATA;
return 1;
}
}
}
}
/****************************************
* CHOLB *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddressVarEight);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 8);
FREE_AB;
FREE_PSTDATA;
return 1;
}
sciErr = getVarType(pvApiCtx, piAddressVarEight, &iTypeVarEight);
if (sciErr.iErr || (iTypeVarEight != sci_matrix && iTypeVarEight != sci_boolean))
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (iTypeVarEight == sci_boolean)
{
iErr = getScalarBoolean(pvApiCtx, piAddressVarEight, &iCHOLB);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (iCHOLB != 1 && iCHOLB != 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
FREE_AB;
FREE_PSTDATA;
return 1;
}
dblCHOLB = (double) iCHOLB;
}
if (iTypeVarEight == sci_matrix)
{
iErr = getScalarDouble(pvApiCtx, piAddressVarEight, &dblCHOLB);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: %s must be an integer scalar or a boolean.\n"), "eigs", 8, "opts.cholB");
FREE_AB;
FREE_PSTDATA;
return 1;
}
if (dblCHOLB != 1 && dblCHOLB != 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: %s must be %s or %s.\n"), "eigs", 8, "opts.cholB", "%f", "%t");
FREE_AB;
FREE_PSTDATA;
return 1;
}
}
if ( dblCHOLB ) // check that B is upper triangular with non zero element on the diagonal
{
if (!Bcomplex)
{
for (i = 0; i < N; i++)
{
for (j = 0; j <= i; j++)
{
if (i == j && Breal[i + j * N] == 0)
{
Scierror(999, _("%s: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs");
FREE_PSTDATA;
return 0;
}
else
{
if ( j < i && Breal[i + j * N] != 0 )
{
Scierror(999, _("%s: If opts.cholB is true, B should be upper triangular.\n"), "eigs");
FREE_PSTDATA;
return 0;
}
}
}
}
}
else
{
for (i = 0; i < N; i++)
{
for (j = 0; j <= i; j++)
{
if (i == j && Bcplx[i + i * N].r == 0 && Bcplx[i + i * N].i == 0)
{
Scierror(999, _("%s: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs");
FREE_AB;
FREE_PSTDATA;
return 0;
}
else
{
if ( j < i && (Bcplx[i + j * N].r != 0 || Bcplx[i + j * N].i != 0) )
{
Scierror(999, _("%s: If opts.cholB is true, B should be upper triangular.\n"), "eigs");
FREE_AB;
FREE_PSTDATA;
return 0;
}
}
}
}
}
}
/****************************************
* RESID *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 9, &piAddressVarNine);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 9);
FREE_AB;
FREE_PSTDATA;
return 1;
}
sciErr = getVarType(pvApiCtx, piAddressVarNine, &iTypeVarNine);
if (sciErr.iErr || iTypeVarNine != sci_matrix)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Wrong type for input argument #%d: A real or complex matrix expected.\n"), "eigs", 9);
FREE_AB;
FREE_PSTDATA;
return 1;
}
else
{
sciErr = getVarDimension(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine);
if (iRowsNine * iColsNine == 1 || iRowsNine * iColsNine != N)
{
Scierror(999, _("%s: Wrong dimension for input argument #%d: Start vector %s must be N by 1.\n"), "eigs", 9, "opts.resid");
FREE_AB;
FREE_PSTDATA;
return 1;
}
}
if (!Acomplex && !Bcomplex)
{
if (isVarComplex(pvApiCtx, piAddressVarNine))
{
Scierror(999, _("%s: Wrong type for input argument #%d: Start vector %s must be real for real problems.\n"), "eigs", 9, "opts.resid");
FREE_PSTDATA;
return 1;
}
else
{
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine, &RESID);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
FREE_PSTDATA;
return 1;
}
}
}
else
{
sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddressVarNine, &iRowsNine, &iColsNine, &RESIDC);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
FREE_AB;
FREE_PSTDATA;
return 1;
}
}
/****************************************
* INFO *
*****************************************/
sciErr = getVarAddressFromPosition(pvApiCtx, 10, &piAddressVarTen);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), "eigs", 9);
FREE_AB;
FREE_PSTDATA;
return 1;
}
iErr = getScalarInteger32(pvApiCtx, piAddressVarTen, &iINFO);
if (iErr)
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer expected.\n"), "eigs", 1);
FREE_AB;
FREE_PSTDATA;
return 1;
}
// Initialization output arguments
if (nbOutputArgument(pvApiCtx) > 1)
{
RVEC = 1;
}
if (Acomplex || Bcomplex || !Asym)
{
eigenvalueC = (doublecomplex*)CALLOC((iNEV + 1), sizeof(doublecomplex));
if (RVEC)
{
eigenvectorC = (doublecomplex*)CALLOC(N * (iNEV + 1), sizeof(doublecomplex));
}
}
else
{
eigenvalue = (double*)CALLOC(iNEV, sizeof(double));
/* we should allocate eigenvector only if RVEC is true, but dseupd segfaults
if Z is not allocated even when RVEC is false, contrary to the docs.*/
eigenvector = (double*)CALLOC(iNEV * N, sizeof(double));
}
error = eigs(Areal, Acplx, N, Acomplex, Asym, Breal, Bcplx, Bcomplex, matB, iNEV, SIGMA, pstData, &dblMAXITER,
&dblTOL, dblNCV, RESID, RESIDC, &iINFO, &dblCHOLB, INFO_EUPD, eigenvalue, eigenvector, eigenvalueC, eigenvectorC, RVEC);
FREE_AB;
FREE_PSTDATA;
switch (error)
{
case -1 :
if (Asym && !Acomplex && !Bcomplex)
{
Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, NCV must be k < NCV <= N.\n"), "eigs", 7);
}
else
{
if (!Asym && !Acomplex && !Bcomplex)
{
Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric problems, NCV must be k + 2 < NCV <= N.\n"), "eigs", 7);
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: For complex problems, NCV must be k + 1 < NCV <= N.\n"), "eigs", 7);
}
}
ReturnArguments(pvApiCtx);
return 1;
case -2 :
if (Asym && !Acomplex && !Bcomplex)
{
Scierror(999, _("%s: Wrong value for input argument #%d: For real symmetric problems, k must be an integer in the range 1 to N - 1.\n"), "eigs", 3);
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: For real non symmetric or complex problems, k must be an integer in the range 1 to N - 2.\n"), "eigs", 3);
}
ReturnArguments(pvApiCtx);
return 1;
case -3 :
Scierror(999, _("%s: Error with input argument #%d: B is not positive definite. Try with sigma='SM' or sigma=scalar.\n"), "eigs", 2);
ReturnArguments(pvApiCtx);
return 0;
case -4 :
if (!Acomplex && !Bcomplex)
{
if (Asym)
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSAUPD", iINFO);
}
else
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNAUPD", iINFO);
}
}
else
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNAUPD", iINFO);
}
ReturnArguments(pvApiCtx);
return 1;
case -5 :
if (!Acomplex && !Bcomplex)
{
if (Asym)
{
Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DSAUPD");
}
else
{
Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "DNAUPD");
}
}
else
{
Scierror(999, _("%s: Error with %s: unknown mode returned.\n"), "eigs", "ZNAUPD");
}
ReturnArguments(pvApiCtx);
return 1;
case -6 :
if (!Acomplex && !Bcomplex)
{
if (Asym)
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DSEUPD", INFO_EUPD);
}
else
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "DNEUPD", INFO_EUPD);
}
}
else
{
Scierror(999, _("%s: Error with %s: info = %d \n"), "eigs", "ZNEUPD", INFO_EUPD);
}
ReturnArguments(pvApiCtx);
FREE(mat_eigenvalue);
return 1;
}
if (nbOutputArgument(pvApiCtx) <= 1)
{
if (eigenvalue)
{
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, 1, eigenvalue);
FREE(eigenvalue);
FREE(eigenvector);
}
else if (eigenvalueC)
{
sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, 1, eigenvalueC);
FREE(eigenvalueC);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
// create a matrix which contains the eigenvalues
if (eigenvalue)
{
mat_eigenvalue = (double*)CALLOC(iNEV * iNEV, sizeof(double));
for (i = 0; i < iNEV; i++)
{
mat_eigenvalue[i * iNEV + i] = eigenvalue[i];
}
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, iNEV, mat_eigenvalue);
FREE(eigenvalue);
FREE(mat_eigenvalue);
}
else if (eigenvalueC)
{
mat_eigenvalueC = (doublecomplex*)CALLOC(iNEV * iNEV, sizeof(doublecomplex));
for (i = 0; i < iNEV; i++)
{
mat_eigenvalueC[i * iNEV + i] = eigenvalueC[i];
}
sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNEV, iNEV, mat_eigenvalueC);
FREE(eigenvalueC);
FREE(mat_eigenvalueC);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
if (eigenvector)
{
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, N, iNEV, eigenvector);
FREE(eigenvector);
}
else if (eigenvectorC)
{
sciErr = createComplexZMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, N, iNEV, eigenvectorC);
FREE(eigenvectorC);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
}
ReturnArguments(pvApiCtx);
return 0;
}