types::Function::ReturnValue sci_strcmp(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::Double* pOutDouble = NULL; types::String* pString1 = NULL; types::String* pString2 = NULL; wchar_t* pwcChar3 = NULL; BOOL do_stricmp = FALSE; if (in.size() < 2 || in.size() > 3) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "strcmp", 2, 3); return types::Function::Error; } if (_iRetCount != 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "strcmp", 1); return types::Function::Error; } if (in[0]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "strcmp", 1); return types::Function::Error; } if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "strcmp", 2); return types::Function::Error; } pString1 = in[0]->getAs<types::String>(); pString2 = in[1]->getAs<types::String>(); if (pString1->getSize() != pString2->getSize() && pString2->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d.\n"), "strcmp", 2); return types::Function::Error; } if (in.size() == 3) { if (in[2]->isString() == false || in[2]->getAs<types::String>()->isScalar() == false || wcslen(in[2]->getAs<types::String>()->get(0)) != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: Char expected.\n"), "strcmp", 3); return types::Function::Error; } pwcChar3 = in[2]->getAs<types::String>()->get(0); if ( (pwcChar3[0] != CHAR_I) && (pwcChar3[0] != CHAR_S)) { Scierror(999, _("%s: Wrong value for input argument #%d: %s or %s expected.\n"), "strcmp", 3, "'i' (stricmp)", "'s' (strcmp)"); return types::Function::Error; } if (pwcChar3[0] == CHAR_I) { do_stricmp = TRUE; } } int *values = stringsCompare(pString1->get(), pString1->getSize(), pString2->get(), pString2->getSize(), do_stricmp); if (values) { pOutDouble = new types::Double(pString1->getDims(), pString1->getDimsArray()); pOutDouble->setInt(values); FREE(values); } else { Scierror(999, _("%s : No more memory.\n"), "strcmp"); } out.push_back(pOutDouble); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_triu(types::typed_list &in, int _iRetCount, types::typed_list &out) { int iOffset = 0; if (in.size() < 1 || in.size() > 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "triu", 1, 2); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "triu", 1); return types::Function::Error; } if (in[0]->isGenericType() == false) { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu"; return Overload::call(wstFuncName, in, _iRetCount, out); } if (in[0]->getAs<types::GenericType>()->getDims() > 2) { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu"; return Overload::call(wstFuncName, in, _iRetCount, out); } if (in.size() == 2) { if (in[1]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "triu", 2); return types::Function::Error; } types::Double* pDblOffset = in[1]->getAs<types::Double>(); if (pDblOffset->isScalar() == false || pDblOffset->isComplex()) { Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "triu", 2); return types::Function::Error; } iOffset = (int)pDblOffset->get(0); } /***** get data *****/ if (in[0]->isDouble() || in[0]->isInt()) // double { types::InternalType* pOut = NULL; switch (in[0]->getType()) { case types::InternalType::ScilabDouble: pOut = triu_const(in[0]->getAs<types::Double>(), iOffset); break; case types::InternalType::ScilabInt8: pOut = triu_const(in[0]->getAs<types::Int8>(), iOffset); break; case types::InternalType::ScilabInt16: pOut = triu_const(in[0]->getAs<types::Int16>(), iOffset); break; case types::InternalType::ScilabInt32: pOut = triu_const(in[0]->getAs<types::Int32>(), iOffset); break; case types::InternalType::ScilabInt64: pOut = triu_const(in[0]->getAs<types::Int64>(), iOffset); break; case types::InternalType::ScilabUInt8: pOut = triu_const(in[0]->getAs<types::UInt8>(), iOffset); break; case types::InternalType::ScilabUInt16: pOut = triu_const(in[0]->getAs<types::UInt16>(), iOffset); break; case types::InternalType::ScilabUInt32: pOut = triu_const(in[0]->getAs<types::UInt32>(), iOffset); break; case types::InternalType::ScilabUInt64: pOut = triu_const(in[0]->getAs<types::UInt64>(), iOffset); break; default: {} // never occurred } out.push_back(pOut); } else if (in[0]->isPoly()) // polynom { types::Polynom* pPolyIn = in[0]->getAs<types::Polynom>(); int iRows = pPolyIn->getRows(); int iCols = pPolyIn->getCols(); int* piRanks = new int[iRows * iCols]; memset(piRanks, 0x00, iRows * iCols * sizeof(int)); types::Polynom* pPolyOut = new types::Polynom(pPolyIn->getVariableName(), iRows, iCols, piRanks); delete[] piRanks; pPolyOut->setZeros(); for (int i = 0 ; i < iCols ; i++) { int iSize = std::min(std::max(i + 1 - iOffset, 0), iRows); for (int j = 0; j < iSize; j++) { int iPos = i * iRows + j; pPolyOut->set(iPos, pPolyIn->get(iPos)); } } out.push_back(pPolyOut); } else { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu"; return Overload::call(wstFuncName, in, _iRetCount, out); } return types::Function::OK; }
types::Function::ReturnValue sci_det(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::Double* pDbl = NULL; types::Double* pDblMantissa = NULL; types::Double* pDblExponent = NULL; double* pData = NULL; if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "det", 1); return types::Function::Error; } if (_iRetCount > 2) { Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), "det", 1, 2); return types::Function::Error; } if ((in[0]->isDouble() == false)) { ast::ExecVisitor exec; std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_det"; return Overload::call(wstFuncName, in, _iRetCount, out, &exec); } pDbl = in[0]->getAs<types::Double>()->clone()->getAs<types::Double>(); if (pDbl->isComplex()) { pData = (double *)oGetDoubleComplexFromPointer(pDbl->getReal(), pDbl->getImg(), pDbl->getSize()); if (!pData) { Scierror(999, _("%s: Cannot allocate more memory.\n"), "det"); return types::Function::Error; } } else { pData = pDbl->getReal(); } if (pDbl->getRows() != pDbl->getCols()) { Scierror(20, _("%s: Wrong type for input argument #%d: Square matrix expected.\n"), "det", 1); return types::Function::Error; } if ((pDbl->getRows() == -1)) // manage eye case { Scierror(271, _("%s: Size varying argument a*eye(), (arg %d) not allowed here.\n"), "det", 1); return types::Function::Error; } pDblMantissa = new types::Double(1, 1, pDbl->isComplex()); if (_iRetCount == 2) { pDblExponent = new types::Double(1, 1); } int iExponent = 0; int iRet = iDetM(pData, pDbl->getCols(), pDblMantissa->getReal(), pDbl->isComplex() ? pDblMantissa->getImg() : NULL, pDblExponent ? &iExponent : NULL); if (iRet != 0) { Scierror(999, _("%s: LAPACK error n°%d.\n"), "det", iRet); return types::Function::Error; } if (pDblExponent) { pDblExponent->set(0, iExponent); } if (pDbl->isComplex()) { vFreeDoubleComplexFromPointer((doublecomplex*)pData); } if (_iRetCount == 2) { out.push_back(pDblExponent); } delete pDbl; out.push_back(pDblMantissa); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_mgetl(types::typed_list &in, int _iRetCount, types::typed_list &out) { int iFileID = 0; int iErr = 0; bool bCloseFile = false; int iLinesExcepted = -1; int iLinesRead = -1; wchar_t** wcReadedStrings = NULL; if (in.size() < 1 || in.size() > 2) { Scierror(77, _("%s: Wrong number of input arguments: %d to %d expected.\n"), "mgetl" , 1, 2); return types::Function::OK; } if (in.size() == 2) { //number of lines if (in[1]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), "mgetl", 2); return types::Function::Error; } if (in[1]->getAs<types::Double>()->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d: An integer value expected.\n"), "mgetl", 2); return types::Function::Error; } if (in[1]->getAs<types::Double>()->get(0) != (int)in[1]->getAs<types::Double>()->get(0)) { Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), "mgetl", 2); return types::Function::Error; } iLinesExcepted = static_cast<int>(in[1]->getAs<types::Double>()->get(0)); } if (in[0]->isDouble() && in[0]->getAs<types::Double>()->getSize() == 1) { iFileID = static_cast<int>(in[0]->getAs<types::Double>()->get(0)); } else if (in[0]->isString() && in[0]->getAs<types::String>()->getSize() == 1) { wchar_t *expandedFileName = expandPathVariableW(in[0]->getAs<types::String>()->get(0)); iErr = mopen(expandedFileName, L"rt", 0, &iFileID); if (iErr) { char* pst = wide_string_to_UTF8(expandedFileName); switch (iErr) { case MOPEN_NO_MORE_LOGICAL_UNIT: Scierror(66, _("%s: Too many files opened!\n"), "mgetl"); break; case MOPEN_CAN_NOT_OPEN_FILE: Scierror(999, _("%s: Cannot open file %s.\n"), "mgetl", pst); break; case MOPEN_NO_MORE_MEMORY: Scierror(999, _("%s: No more memory.\n"), "mgetl"); break; case MOPEN_INVALID_FILENAME: Scierror(999, _("%s: invalid filename %s.\n"), "mgetl", pst); break; default: //MOPEN_INVALID_STATUS Scierror(999, _("%s: invalid status.\n"), "mgetl"); break; } FREE(pst); FREE(expandedFileName); return types::Function::Error; } FREE(expandedFileName); bCloseFile = true; } else { //Error Scierror(999, _("%s: Wrong type for input argument #%d: a String or Integer expected.\n"), "mgetl", 1); return types::Function::Error; } switch (iFileID) { case 0: // stderr case 6: // stdout Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mgetl", iFileID); return types::Function::Error; default : { types::File* pFile = FileManager::getFile(iFileID); // file opened with fortran open function if (pFile == NULL || pFile->getFileType() == 1) { Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mgetl", iFileID); return types::Function::Error; } wcReadedStrings = mgetl(iFileID, iLinesExcepted, &iLinesRead, &iErr); switch (iErr) { case MGETL_MEMORY_ALLOCATION_ERROR : break; } } } if (wcReadedStrings && iLinesRead > 0) { types::String *pS = new types::String(iLinesRead, 1); pS->set(wcReadedStrings); out.push_back(pS); freeArrayOfWideString(wcReadedStrings, iLinesRead); } else { out.push_back(types::Double::Empty()); if (wcReadedStrings) { FREE(wcReadedStrings); } } if (bCloseFile) { mclose(iFileID); } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_atan(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::Double* pDblX = NULL; types::Double* pDblY = NULL; types::Double* pDblOut = NULL; if (in.size() < 1 || in.size() > 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "atan", 1, 2); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "atan", 1); return types::Function::Error; } if (in[0]->isDouble() == false) { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_atan"; return Overload::call(wstFuncName, in, _iRetCount, out); } pDblX = in[0]->getAs<types::Double>(); if (in.size() == 1) { if (pDblX->isComplex()) { pDblOut = new types::Double(pDblX->getDims(), pDblX->getDimsArray(), true); double* pXR = pDblX->get(); double* pXI = pDblX->getImg(); double* pOR = pDblOut->get(); double* pOI = pDblOut->getImg(); int size = pDblX->getSize(); bool msg = true; for (int i = 0; i < size; i++) { if (msg && pXR[i] == 0 && std::abs(pXI[i]) == 1) { if (ConfigVariable::getIeee() == 0) { Scierror(999, _("%s: Wrong value for input argument #%d : Singularity of the function.\n"), "atan", 1); return types::Function::Error; } else if (msg && ConfigVariable::getIeee() == 1) { if (ConfigVariable::getWarningMode()) { sciprint(_("%s: Warning: Wrong value for input argument #%d : Singularity of the function.\n"), "atan", 1); } msg = false; } } C2F(watan)(pXR + i, pXI + i, pOR + i, pOI + i); } } else { pDblOut = new types::Double(pDblX->getDims(), pDblX->getDimsArray(), false); double* pXR = pDblX->get(); double* pOR = pDblOut->get(); int size = pDblX->getSize(); for (int i = 0; i < size; i++) { pOR[i] = std::atan(pXR[i]); } } } else // in.size() == 2 { pDblY = in[1]->getAs<types::Double>(); if (pDblX->isComplex() || pDblY->isComplex()) { Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "atan", 2); return types::Function::Error; } if (pDblX->getSize() != pDblY->getSize()) { Scierror(999, _("%s: Wrong size for input argument #%d and #%d: Same size expected.\n"), "atan", 1, 2); return types::Function::Error; } pDblOut = new types::Double(pDblX->getDims(), pDblX->getDimsArray(), false); double* pXR = pDblX->get(); double* pYR = pDblY->get(); double* pOR = pDblOut->get(); int size = pDblX->getSize(); for (int i = 0; i < size; i++) { pOR[i] = std::atan2(pXR[i], pYR[i]); } } out.push_back(pDblOut); return types::Function::OK; }
types::Function::ReturnValue sci_fieldnames(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() != 1) { Scierror(999, _("%s: Wrong number of input argument(s): %d expected.\n"), "fieldnames", 1); return types::Function::Error; } // FIXME : iso-functionnal to Scilab < 6 // Works on other types except userType, {m,t}list and struct if (in[0]->isStruct() == false && in[0]->isMList() == false && in[0]->isTList() == false && in[0]->isUserType() == false) { out.push_back(types::Double::Empty()); return types::Function::OK; } // STRUCT if (in[0]->isStruct() == true) { types::String* pFields = in[0]->getAs<types::Struct>()->getFieldNames(); if (pFields) { out.push_back(pFields); //delete pFields; } else { out.push_back(types::Double::Empty()); } return types::Function::OK; } types::InternalType* pIT; // TLIST or MLIST if (in[0]->isList() == true) { // We only need list capabilities to retrieve first argument as List. types::List *pInList = in[0]->getAs<types::List>(); pIT = pInList->get(0); if (pIT == nullptr || pIT->isString() == false) { // FIXME : iso-functionnal to Scilab < 6 // Works on other types except userType, {m,t}list and struct out.push_back(types::Double::Empty()); return types::Function::OK; } } // USER-TYPE (typically an Xcos object) if (in[0]->isUserType() == true) { // We only need userType capabilities to retrieve first argument as UserType. types::UserType *pInUser = in[0]->getAs<types::UserType>(); // Extract the sub-type std::wstring subType (pInUser->getShortTypeStr()); // Extract the properties types::typed_list one(1, new types::Double(1)); types::InternalType* pProperties = pInUser->extract(&one); if (pProperties == nullptr || pProperties->isString() == false) { // FIXME : iso-functionnal to Scilab < 6 // Works on other types except userType, {m,t}list and struct out.push_back(types::Double::Empty()); return types::Function::OK; } int nProp = ((types::String*) pProperties)->getSize(); pIT = new types::String(nProp + 1, 1); ((types::String*) pIT)->set(0, subType.data()); for (int i = 0; i < nProp; ++i) { ((types::String*) pIT)->set(i + 1, ((types::String*)pProperties)->get(i)); } } types::String *pAllFields; if (pIT) { pAllFields = pIT->getAs<types::String>(); } else { Scierror(999, _("Could not retrieve sub-type.\n")); return types::Function::Error; } wchar_t **pwcsAllStrings = pAllFields->get(); // shift to forget first value corresponding to type. // ++pwcsAllStrings; types::String *pNewString = new types::String(pAllFields->getSize() - 1, 1, pwcsAllStrings + 1); out.push_back(pNewString); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_hdf5_load_v3(types::typed_list &in, int _iRetCount, types::typed_list &out) { std::string filename; int rhs = static_cast<int>(in.size()); if (rhs < 1) { Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1); return types::Function::Error; } if (in[0]->getId() != types::InternalType::IdScalarString) { Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 1); return types::Function::Error; } wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]); char* cfilename = wide_string_to_UTF8(wfilename); filename = cfilename; FREE(wfilename); FREE(cfilename); int iFile = openHDF5File(filename.data(), 0); if (iFile < 0) { Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data()); return types::Function::Error; } //manage version information int iVersion = getSODFormatAttribute(iFile); if (iVersion != SOD_FILE_VERSION) { //can't read file with version newer that me ! Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion); return types::Function::Error; } if (rhs > 1) { for (int i = 1; i < rhs; ++i) { std::string var; char* cvar = wide_string_to_UTF8(in[i]->getAs<types::String>()->get()[0]); var = cvar; FREE(cvar); if (import_variable(iFile, var) == false) { Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), var.data()); return types::Function::Error; } } } else { //restore all variables int iNbItem = 0; iNbItem = getVariableNames6(iFile, NULL); if (iNbItem != 0) { std::vector<char*> vars(iNbItem); iNbItem = getVariableNames6(iFile, vars.data()); for (auto & var : vars) { std::string s(var); FREE(var); if (import_variable(iFile, s) == false) { Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), s.data()); return types::Function::Error; } } } } //close the file closeHDF5File(iFile); out.push_back(new types::Bool(1)); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_roots(types::typed_list &in, int _iRetCount, types::typed_list &out) { std::wstring wstrAlgo = L"e"; // e = eigen (default), f = fast types::Double* pDblIn = NULL; types::Double* pDblOut = NULL; types::Polynom* pPolyIn = NULL; double* pdblInReal = NULL; double* pdblInImg = NULL; double* pdblTempReal = NULL; double* pdblTempImg = NULL; int iOne = 1; int imOne = -1; int iSize = 0; bool bComplex = false; types::Function::ReturnValue ret = types::Function::OK; if (in.size() < 1 || in.size() > 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "roots", 1, 2); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "roots", 1); return types::Function::Error; } // get algo type if (in.size() == 2) { if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : string expected.\n"), "roots", 2); return types::Function::Error; } types::String* pStrAlgo = in[1]->getAs<types::String>(); if (pStrAlgo->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "roots", 2); return types::Function::Error; } wstrAlgo = pStrAlgo->get(0); if (wstrAlgo != L"e" && wstrAlgo != L"f") { Scierror(999, _("%s: Wrong value for input argument #%d : ""%s"" or ""%s"" expected.\n"), "roots", 2, "e", "f"); return types::Function::Error; } } if (in[0]->isDouble()) { // for Matlab compatibility root of the vector of coefficients pDblIn = in[0]->getAs<types::Double>(); if (pDblIn->isEmpty()) { out.push_back(types::Double::Empty()); return types::Function::OK; } iSize = pDblIn->getSize(); // old fortran function dtild // switch elements of a vector. [1 2 3] => [3 2 1] pdblInReal = new double[iSize]; C2F(dcopy)(&iSize, pDblIn->get(), &iOne, pdblInReal, &imOne); if (pDblIn->isComplex()) { bComplex = true; pdblInImg = new double[iSize]; C2F(dcopy)(&iSize, pDblIn->getImg(), &iOne, pdblInImg, &imOne); } } else if (in[0]->isPoly()) { pPolyIn = in[0]->getAs<types::Polynom>(); if (pPolyIn->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d : A scalar expected.\n"), "roots", 1); return types::Function::Error; } iSize = pPolyIn->getMaxRank() + 1; pdblInReal = pPolyIn->get(0)->get(); if (pPolyIn->isComplex()) { bComplex = true; pdblInImg = pPolyIn->get(0)->getImg(); } } else { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_roots"; return Overload::call(wstFuncName, in, _iRetCount, out); } // If "fast" algo was chosen and polynomial is complex, // then produce an error. if (wstrAlgo == L"f" && bComplex) { Scierror(999, _("%s: Wrong value for input argument #%d : If algo is ""%s"", a real is expected.\n"), "roots", 2, "f"); return types::Function::Error; } double t = 0; while (t == 0) { iSize--; if (iSize < 0) { out.push_back(types::Double::Empty()); return types::Function::OK; } t = std::fabs(pdblInReal[iSize]); if (bComplex) { t += std::fabs(pdblInImg[iSize]); } } // If "fast" algo was chosen and polynomial has degree greater than 100, // then produce an error. if (wstrAlgo == L"f" && iSize > 100) { Scierror(999, _("%s: Wrong value for input argument #%d : If algo is ""%s"", a degree less than %d expected.\n"), "roots", 2, "f", 100); return types::Function::Error; } if (wstrAlgo == L"f") { // real polynomial: rpoly algorithm // this alg is much more speedy, but it may happens that it gives // erroneous results without messages : example // roots(%s^31-8*%s^30+9*%s^29+0.995) should have two real roots near // 1.355 and 6.65 and the other ones inside a circle centered in 0 // with radius 1 pDblOut = new types::Double(iSize, 1, true); int iFail = 0; int iSizeP1 = iSize + 1; double* pdblTempReal = new double[iSize + 1]; C2F(dcopy)(&iSizeP1, pdblInReal, &iOne, pdblTempReal, &imOne); C2F(rpoly)(pdblTempReal, &iSize, pDblOut->get(), pDblOut->getImg(), &iFail); delete pdblTempReal; if (iFail) { if (iFail == 1) { Scierror(999, _("%s: Convergence problem...\n"), "roots"); } else if (iFail == 2) { Scierror(999, _("%s: Leading coefficient is zero.\n"), "roots"); } else if (iFail == 3) { Scierror(999, _("%s: Too high degree (max 100).\n"), "roots"); } return types::Function::Error; } out.push_back(pDblOut); } else // wstrAlgo == L"e" { // Companion matrix method int iSizeM1 = iSize - 1; int iSizeP1 = iSize + 1; double dblOne = 1; double* pdblTempReal = new double[iSize]; double* pdblTempImg = NULL; double sr = pdblInReal[iSize]; C2F(dcopy)(&iSize, pdblInReal, &iOne, pdblTempReal, &imOne); if (bComplex) { pdblTempImg = new double[iSize]; C2F(dcopy)(&iSize, pdblInImg, &iOne, pdblTempImg, &imOne); double si = pdblInImg[iSize]; double t = sr * sr + si * si; sr = -sr / t; si = si / t; C2F(wscal)(&iSize, &sr, &si, pdblTempReal, pdblTempImg, &iOne); } else { double dbl = -1 / sr; C2F(dscal)(&iSize, &dbl, pdblTempReal, &iOne); } pDblOut = new types::Double(iSize, iSize, bComplex); double* pdblOutReal = pDblOut->get(); double* pdblOutImg = NULL; memset(pdblOutReal, 0x00, pDblOut->getSize() * sizeof(double)); C2F(dset)(&iSizeM1, &dblOne, &pdblOutReal[iSize], &iSizeP1); C2F(dcopy)(&iSize, pdblTempReal, &iOne, pdblOutReal, &iOne); delete[] pdblTempReal; if (bComplex) { pdblOutImg = pDblOut->getImg(); memset(pdblOutImg, 0x00, pDblOut->getSize() * sizeof(double)); C2F(dcopy)(&iSize, pdblTempImg, &iOne, pdblOutImg, &iOne); delete[] pdblTempImg; } //call spec types::InternalType* pSpec = symbol::Context::getInstance()->get(symbol::Symbol(L"spec")); if (pSpec && pSpec->isFunction()) { types::Function *funcSpec = pSpec->getAs<types::Function>(); types::typed_list tlInput; types::optional_list tlOpt; tlInput.push_back(pDblOut); ret = funcSpec->call(tlInput, tlOpt, 1, out); pDblOut->killMe(); } else { Scierror(999, _("%s: unable to find spec function\n"), "roots"); return types::Function::Error; } } if (pDblIn) { delete pdblInReal; if (bComplex) { delete pdblInImg; } } return ret; }
types::Function::ReturnValue sci_string(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "string", 1); return types::Function::Error; } switch (in[0]->getType()) { case types::GenericType::ScilabSparse: { //C=sparse([0 0 4 0 9;0 0 5 0 0;1 3 0 7 0;0 0 6 0 10;2 0 0 8 0]);string(C) types::Sparse* pS = in[0]->getAs<types::Sparse>(); int iRows = pS->getRows(); int iCols = pS->getCols(); bool isComplex = pS->isComplex(); std::wostringstream ostr; std::vector<std::wstring> vect; ostr << "(" << iRows << "," << iCols << ") sparse matrix"; vect.push_back(ostr.str()); ostr.str(L""); ostr.clear(); for (int i = 0 ; i < iRows ; i++) { for (int j = 0 ; j < iCols ; j++) { std::wostringstream temp; double real = pS->getReal(i, j); double cplx = 0; if (isComplex) { cplx = pS->getImg(i, j).imag(); } if (real || cplx ) { temp << L"(" << i + 1 << L"," << j + 1 << L") "; if (real) { temp << pS->getReal(i, j); } if (cplx) { if (real && cplx > 0) { temp << L"+"; } else if (cplx < 0) { temp << L"-"; } temp << L"%i*" << std::abs(cplx); } ostr << temp.str(); vect.push_back(ostr.str()); ostr.str(L""); ostr.clear(); } } } types::String* pSt = new types::String((int)vect.size(), 1); for (int i = 0 ; i < vect.size(); i++) { pSt->set(i, vect[i].c_str()); } out.push_back(pSt); break; } case types::InternalType::ScilabInt8 : { return intString(in[0]->getAs<types::Int8>(), out); } case types::InternalType::ScilabUInt8 : { return intString(in[0]->getAs<types::UInt8>(), out); } case types::InternalType::ScilabInt16 : { return intString(in[0]->getAs<types::Int16>(), out); } case types::InternalType::ScilabUInt16 : { return intString(in[0]->getAs<types::UInt16>(), out); } case types::InternalType::ScilabInt32 : { return intString(in[0]->getAs<types::Int32>(), out); } case types::InternalType::ScilabUInt32 : { return intString(in[0]->getAs<types::UInt32>(), out); } case types::InternalType::ScilabInt64 : { return intString(in[0]->getAs<types::Int64>(), out); } case types::InternalType::ScilabUInt64 : { return intString(in[0]->getAs<types::UInt64>(), out); } case types::InternalType::ScilabDouble : { return doubleString(in[0]->getAs<types::Double>(), out); } case types::InternalType::ScilabString : { out.push_back(in[0]); break; } case types::InternalType::ScilabFunction: { Scierror(999, _("%s: Wrong type for input argument #%d.\n"), "string", 1); return types::Function::Error; } case types::InternalType::ScilabMacroFile : { if (_iRetCount != 3) { Scierror(77, _("%s: Wrong number of output argument(s): %d expected.\n"), "string", 3); return types::Function::Error; } types::MacroFile* pMF = in[0]->getAs<types::MacroFile>(); types::InternalType* pOut = NULL; types::InternalType* pIn = NULL; types::InternalType* pBody = NULL; getMacroString(pMF->getMacro(), &pOut, &pIn, &pBody); out.push_back(pOut); out.push_back(pIn); out.push_back(pBody); break; } case types::InternalType::ScilabMacro : { if (_iRetCount != 3) { Scierror(77, _("%s: Wrong number of output argument(s): %d expected.\n"), "string", 3); return types::Function::Error; } types::Macro* pM = in[0]->getAs<types::Macro>(); types::InternalType* pOut = NULL; types::InternalType* pIn = NULL; types::InternalType* pBody = NULL; getMacroString(pM, &pOut, &pIn, &pBody); out.push_back(pOut); out.push_back(pIn); out.push_back(pBody); break; } case types::InternalType::ScilabTList : case types::InternalType::ScilabMList : case types::InternalType::ScilabPolynom : { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_string"; return Overload::call(wstFuncName, in, _iRetCount, out); } case types::InternalType::ScilabBool: { return booleanString(in[0]->getAs<types::Bool>(), out); } case types::InternalType::ScilabLibrary: { types::Library* pL = in[0]->getAs<types::Library>(); std::wstring path = pL->getPath(); std::list<std::wstring> macros; int size = pL->getMacrosName(macros); types::String* pS = new types::String(size + 1, 1); pS->set(0, path.c_str()); int i = 1; for (auto it : macros) { pS->set(i++, it.c_str()); } out.push_back(pS); break; } case types::InternalType::ScilabImplicitList: { return implicitListString(in[0]->getAs<types::ImplicitList>(), out); } case types::InternalType::ScilabColon: { out.push_back(new types::String(L"")); break; } default: { std::wostringstream ostr; in[0]->toString(ostr); out.push_back(new types::String(ostr.str().c_str())); break; } } return types::Function::OK; }
static types::Function::ReturnValue isdef(types::typed_list& in, int _iRetCount, types::typed_list& out, const char* fname) { types::String* pStrIn = NULL; if (in.size() != 1 && in.size() != 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected."), fname, 1, 2); return types::Function::Error; } if (!in[0]->isString()) { Scierror(999, _("%s: Wrong type for argument #%d: Matrix of strings expected.\n"), fname, 1); return types::Function::Error; } if (in.size() == 2 && (!in[1]->isString() || in[1]->getAs<types::String>()->getSize() != 1)) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), fname, 2); return types::Function::Error; } const wchar_t *psScope = L"all"; // Default option is "all" if (in.size() == 2) { psScope = in[1]->getAs<types::String>()->get(0); } pStrIn = in[0]->getAs<types::String>(); types::InternalType *pIT; types::Bool* pBOut = new types::Bool(pStrIn->getDims(), pStrIn->getDimsArray()); switch (getScopeFromOption(psScope)) { case All: for (int i = 0; i < pStrIn->getSize(); i++) { pIT = symbol::Context::getInstance()->get(symbol::Symbol(pStrIn->get(i))); pBOut->set(i, pIT != NULL && pIT->getType() != types::InternalType::ScilabVoid); } break; case Local: for (int i = 0; i < pStrIn->getSize(); i++) { pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pStrIn->get(i))); pBOut->set(i, pIT != NULL && pIT->getType() != types::InternalType::ScilabVoid); } break; case NoLocal: for (int i = 0; i < pStrIn->getSize(); i++) { pIT = symbol::Context::getInstance()->getAllButCurrentLevel(symbol::Symbol(pStrIn->get(i))); pBOut->set(i, pIT != NULL && pIT->getType() != types::InternalType::ScilabVoid); } break; default: Scierror(36, _("%s: Wrong input argument %d.\n"), fname, 2); return types::Function::Error; } out.push_back(pBOut); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_xls_read(types::typed_list &in, int _iRetCount, types::typed_list &out) { // input types::Double* pDblId = NULL; types::Double* pDblSheetpos = NULL; int iId = 0; int iSheetpos = 0; int rows = 0; int cols = 0; int iErr = 0; int* ind = NULL; double* data = NULL; // *** check the minimal number of input args. *** if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "xls_read", 2); return types::Function::Error; } // *** check number of output args according the methode. *** if (_iRetCount != 2) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "xls_read", 2); return types::Function::Error; } // *** check type of input args and get it. *** // file id if (in[0]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "xls_read", 1); return types::Function::Error; } pDblId = in[0]->getAs<types::Double>(); if (pDblId->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "xls_read", 1); return types::Function::Error; } iId = static_cast<int>(pDblId->get(0)); // sheetpos if (in[1]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "xls_read", 2); return types::Function::Error; } pDblSheetpos = in[1]->getAs<types::Double>(); if (pDblSheetpos->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A scalar expected.\n"), "xls_read", 2); return types::Function::Error; } iSheetpos = static_cast<int>(pDblSheetpos->get(0)); xls_read(&iId, &iSheetpos, &data, &ind, &rows, &cols, &iErr); switch (iErr) { case 1 : Scierror(999, _("%s: No more memory.\n"), "xls_read"); return types::Function::Error; case 2 : Scierror(999, _("%s: Failed to read expected data, may be invalid xls file.\n"), "xls_read"); return types::Function::Error; case 3 : Scierror(999, _("%s: End of file.\n"), "xls_read"); return types::Function::Error; default : /* no error */ break; } if (rows * cols) { types::Double* pDblData = new types::Double(rows, cols); pDblData->set(data); types::Double* pDblInd = new types::Double(rows, cols); for (int i = 0; i < cols; i++) { for (int j = 0; j < rows; j++) { pDblInd->set(j, i, static_cast<int>(ind[i * rows + j])); } } out.push_back(pDblData); out.push_back(pDblInd); free(data); free(ind); } else { out.push_back(types::Double::Empty()); out.push_back(types::Double::Empty()); } return types::Function::OK; }
types::Function::ReturnValue sci_helpbrowser(types::typed_list &in, int _iRetCount, types::typed_list& out) { int iHelpAdrSize = 0; char **helpAdr = NULL; char **languageAdr = NULL; if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected."), "helpbrowser", 0, 1); return types::Function::Error; } switch (in.size()) { case 4: if (!(in[3]->isBool() == true && in[3]->getAs<types::Bool>()->isScalar() == true)) { Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected."), "helpbrowser", 4); return types::Function::Error; } if (!(in[2]->isString() == true && in[2]->getAs<types::String>()->isScalar() == true)) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 3); return types::Function::Error; } case 2: // Second argument must be String or at least []. if (!(in[1]->isString() == true && in[1]->getAs<types::String>()->isScalar() == true)) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 2); return types::Function::Error; } // Matrix of String or [] allowed. if ( !( (in[0]->isString() == true) || (in[0]->isDouble() == true && in[0]->getAs<types::Double>()->isEmpty() == true))) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected."), "helpbrowser", 1); return types::Function::Error; } break; default: Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected."), "helpbrowser", 2, 4); return types::Function::Error; } /* We load SciNotes when calling javahelp because we have no way to know * to load it when using Javahelp because it can call SciNotes directly */ if (!loadedDep) { loadOnUseClassPath("SciNotes"); loadedDep = TRUE; } if (in[0]->isString() == true) { types::String *pInHelpAdr = in[0]->getAs<types::String>(); helpAdr = new char*[pInHelpAdr->getSize()]; iHelpAdrSize = pInHelpAdr->getSize(); for (int i = 0 ; i < pInHelpAdr->getSize() ; ++i) { helpAdr[i] = wide_string_to_UTF8(pInHelpAdr->get(i)); } } char* pstLang = NULL; char* pstKey = NULL; if (in.size() == 2) { pstLang = wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0)); launchHelpBrowser(helpAdr, iHelpAdrSize, pstLang); } if (in.size() == 4) { pstLang = wide_string_to_UTF8(in[2]->getAs<types::String>()->get(0)); pstKey = wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0)); int iFullText = in[3]->getAs<types::Bool>()->get(0); searchKeyword(helpAdr, iHelpAdrSize, pstKey, pstLang, (BOOL) iFullText); } if (pstLang != NULL) { FREE(pstLang); } if (pstKey != NULL) { FREE(pstKey); } if (helpAdr != NULL) /* No toolboxes loaded */ { for (int i = 0 ; i < iHelpAdrSize ; i++) { FREE(helpAdr[i]); } delete[] helpAdr; } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::Double* pDblIn = NULL; types::Double* pDblOut = NULL; types::Polynom* pPolyIn = NULL; types::Polynom* pPolyOut = NULL; int iOrientation = 0; int iOuttype = 1; // 1 = native | 2 = double (type of output value) if (in.size() < 1 || in.size() > 3) { Scierror(999, _("%s: Wrong number of input arguments: %d to %d expected.\n"), "sum", 1, 3); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "sum", 1); return types::Function::Error; } bool isCopy = true; /***** get data *****/ switch (in[0]->getType()) { case types::InternalType::ScilabDouble: { pDblIn = in[0]->getAs<types::Double>(); isCopy = false; break; } case types::InternalType::ScilabBool: { pDblIn = getAsDouble(in[0]->getAs<types::Bool>()); iOuttype = 2; break; } case types::InternalType::ScilabPolynom: { pPolyIn = in[0]->getAs<types::Polynom>(); break; } case types::InternalType::ScilabInt8: { pDblIn = getAsDouble(in[0]->getAs<types::Int8>()); break; } case types::InternalType::ScilabInt16: { pDblIn = getAsDouble(in[0]->getAs<types::Int16>()); break; } case types::InternalType::ScilabInt32: { pDblIn = getAsDouble(in[0]->getAs<types::Int32>()); break; } case types::InternalType::ScilabInt64: { pDblIn = getAsDouble(in[0]->getAs<types::Int64>()); break; } case types::InternalType::ScilabUInt8: { pDblIn = getAsDouble(in[0]->getAs<types::UInt8>()); break; } case types::InternalType::ScilabUInt16: { pDblIn = getAsDouble(in[0]->getAs<types::UInt16>()); break; } case types::InternalType::ScilabUInt32: { pDblIn = getAsDouble(in[0]->getAs<types::UInt32>()); break; } case types::InternalType::ScilabUInt64: { pDblIn = getAsDouble(in[0]->getAs<types::UInt64>()); break; } default: { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sum"; types::Function::ReturnValue ret = Overload::call(wstFuncName, in, _iRetCount, out); if (isCopy && pDblIn) { pDblIn->killMe(); } return ret; } } if (in.size() >= 2) { if (in[1]->isDouble()) { types::Double* pDbl = in[1]->getAs<types::Double>(); if (pDbl->isScalar() == false) { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "sum", 2); return types::Function::Error; } iOrientation = static_cast<int>(pDbl->get(0)); if (iOrientation <= 0) { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "sum", 2); return types::Function::Error; } } else if (in[1]->isString()) { types::String* pStr = in[1]->getAs<types::String>(); if (pStr->isScalar() == false) { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "sum", 2); return types::Function::Error; } wchar_t* wcsString = pStr->get(0); if (wcscmp(wcsString, L"*") == 0) { iOrientation = 0; } else if (wcscmp(wcsString, L"r") == 0) { iOrientation = 1; } else if (wcscmp(wcsString, L"c") == 0) { iOrientation = 2; } else if (wcscmp(wcsString, L"m") == 0) { int iDims = 0; int* piDimsArray = NULL; if (pDblIn) { iDims = pDblIn->getDims(); piDimsArray = pDblIn->getDimsArray(); } else { iDims = pPolyIn->getDims(); piDimsArray = pPolyIn->getDimsArray(); } // old function was "mtlsel" for (int i = 0; i < iDims; i++) { if (piDimsArray[i] > 1) { iOrientation = i + 1; break; } } } else if ((wcscmp(wcsString, L"native") == 0) && (in.size() == 2)) { iOuttype = 1; } else if ((wcscmp(wcsString, L"double") == 0) && (in.size() == 2)) { iOuttype = 2; } else { const char* pstrExpected = NULL; if (in.size() == 2) { pstrExpected = "\"*\",\"r\",\"c\",\"m\",\"native\",\"double\""; } else { pstrExpected = "\"*\",\"r\",\"c\",\"m\""; } if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "sum", 2, pstrExpected); return types::Function::Error; } } else { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix or a string expected.\n"), "sum", 2); return types::Function::Error; } } if (in.size() == 3) { if (in[2]->isString() == false) { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "sum", 3); return types::Function::Error; } types::String* pStr = in[2]->getAs<types::String>(); if (pStr->isScalar() == false) { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "sum", 3); return types::Function::Error; } wchar_t* wcsString = pStr->get(0); if (wcscmp(wcsString, L"native") == 0) { iOuttype = 1; } else if (wcscmp(wcsString, L"double") == 0) { iOuttype = 2; } else { if (isCopy && pDblIn) { pDblIn->killMe(); } Scierror(999, _("%s: Wrong value for input argument #%d: %s or %s expected.\n"), "sum", 3, "\"native\"", "\"double\""); return types::Function::Error; } } /***** perform operation *****/ if (pDblIn) { if (pDblIn->isEmpty()) { if (iOrientation == 0) { out.push_back(new types::Double(0)); } else { out.push_back(types::Double::Empty()); } if (isCopy) { pDblIn->killMe(); } return types::Function::OK; } else if (iOrientation > pDblIn->getDims()) { pDblOut = pDblIn; if (in[0]->isBool() == false) { iOuttype = 2; } } else { pDblOut = sum(pDblIn, iOrientation); if (isCopy) { pDblIn->killMe(); } } } else if (pPolyIn) { iOuttype = 1; if (iOrientation > pPolyIn->getDims()) { pPolyOut = pPolyIn->getAs<types::Polynom>(); } else { pPolyOut = sum(pPolyIn, iOrientation); } } /***** set result *****/ if ((iOuttype == 1) && isCopy) { switch (in[0]->getType()) { case types::InternalType::ScilabBool: { types::Bool* pB = new types::Bool(pDblOut->getDims(), pDblOut->getDimsArray()); int* p = pB->get(); double* pd = pDblOut->get(); int size = pB->getSize(); for (int i = 0; i < size; ++i) { p[i] = pd[i] != 0 ? 1 : 0; } out.push_back(pB); break; } case types::InternalType::ScilabPolynom: { out.push_back(pPolyOut); break; } case types::InternalType::ScilabInt8: { out.push_back(toInt<types::Int8>(pDblOut)); break; } case types::InternalType::ScilabInt16: { out.push_back(toInt<types::Int16>(pDblOut)); break; } case types::InternalType::ScilabInt32: { out.push_back(toInt<types::Int32>(pDblOut)); break; } case types::InternalType::ScilabInt64: { out.push_back(toInt<types::Int64>(pDblOut)); break; } case types::InternalType::ScilabUInt8: { out.push_back(toInt<types::UInt8>(pDblOut)); break; } case types::InternalType::ScilabUInt16: { out.push_back(toInt<types::UInt16>(pDblOut)); break; } case types::InternalType::ScilabUInt32: { out.push_back(toInt<types::UInt32>(pDblOut)); break; } case types::InternalType::ScilabUInt64: { out.push_back(toInt<types::UInt64>(pDblOut)); break; } default: return types::Function::Error; } if (pDblOut) { pDblOut->killMe(); } } else { out.push_back(pDblOut); } return types::Function::OK; }
types::Function::ReturnValue sci_interp(types::typed_list &in, int _iRetCount, types::typed_list &out) { // input types::Double* pDblXp = NULL; types::Double* pDblX = NULL; types::Double* pDblY = NULL; types::Double* pDblD = NULL; // output types::Double* pDblYp = NULL; types::Double* pDblYp1 = NULL; types::Double* pDblYp2 = NULL; types::Double* pDblYp3 = NULL; int iType = 8; // default C0 int sizeOfXp = 0; int sizeOfX = 0; // *** check the minimal number of input args. *** if (in.size() < 4 || in.size() > 5) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "interp", 4, 5); return types::Function::Error; } // *** check number of output args according the methode. *** if (_iRetCount > 4) { Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), "interp", 1, 4); return types::Function::Error; } // *** check type of input args and get it. *** // xp if (in[0]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "interp", 1); return types::Function::Error; } pDblXp = in[0]->getAs<types::Double>(); sizeOfXp = pDblXp->getSize(); if (pDblXp->isComplex()) { Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "interp", 1); return types::Function::Error; } // x if (in[1]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "interp", 2); return types::Function::Error; } pDblX = in[1]->getAs<types::Double>(); if ((pDblX->getCols() != 1 && pDblX->getRows() != 1) || pDblX->getSize() < 2) { Scierror(999, _("%s: Wrong size for input arguments #%d: A vector of size at least 2 expected.\n"), "interp", 2); return types::Function::Error; } sizeOfX = pDblX->getSize(); if (pDblX->isComplex()) { Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "interp", 2); return types::Function::Error; } // y if (in[2]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "interp", 3); return types::Function::Error; } pDblY = in[2]->getAs<types::Double>(); if (pDblY->isComplex()) { Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "interp", 3); return types::Function::Error; } // d if (in[3]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A matrix expected.\n"), "interp", 4); return types::Function::Error; } pDblD = in[3]->getAs<types::Double>(); if (pDblD->isComplex()) { Scierror(999, _("%s: Wrong type for argument #%d: Real matrix expected.\n"), "interp", 4); return types::Function::Error; } if ( pDblX->getRows() != pDblY->getRows() || pDblX->getCols() != pDblY->getCols() || pDblX->getRows() != pDblD->getRows() || pDblX->getCols() != pDblD->getCols()) { Scierror(999, _("%s: Wrong size for input arguments #%d to #%d: Same sizes expected.\n"), "interp", 2, 4); return types::Function::Error; } // out mode if (in.size() == 5) { if (in[4]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d : A string expected.\n"), "interp", 5); return types::Function::Error; } wchar_t* wcsType = in[4]->getAs<types::String>()->get(0); if (wcscmp(wcsType, L"C0") == 0) { iType = 8; } else if (wcscmp(wcsType, L"by_zero") == 0) { iType = 7; } else if (wcscmp(wcsType, L"natural") == 0) { iType = 1; } else if (wcscmp(wcsType, L"periodic") == 0) { iType = 3; } else if (wcscmp(wcsType, L"by_nan") == 0) { iType = 10; } else if (wcscmp(wcsType, L"linear") == 0) { iType = 9; } else // undefined { Scierror(999, _("%s: Wrong values for input argument #%d : '%s' is a unknow '%s' type.\n"), "interp", 5, wcsType, "outmode"); return types::Function::Error; } } // *** Perform operation. *** pDblYp = new types::Double(pDblXp->getRows(), pDblXp->getCols()); pDblYp1 = new types::Double(pDblXp->getRows(), pDblXp->getCols()); pDblYp2 = new types::Double(pDblXp->getRows(), pDblXp->getCols()); pDblYp3 = new types::Double(pDblXp->getRows(), pDblXp->getCols()); C2F(evalpwhermite)(pDblXp->get(), pDblYp->get(), pDblYp1->get(), pDblYp2->get(), pDblYp3->get(), &sizeOfXp, pDblX->get(), pDblY->get(), pDblD->get(), &sizeOfX, &iType); // *** Return result in Scilab. *** out.push_back(pDblYp); if (_iRetCount > 1) { out.push_back(pDblYp1); } if (_iRetCount > 2) { out.push_back(pDblYp2); } if (_iRetCount > 3) { out.push_back(pDblYp3); } return types::Function::OK; }
types::Function::ReturnValue sci_makecell(types::typed_list &in, int _iRetCount, types::typed_list &out) { int iProd = 0; int iDims = 0; int* piDimsArray = NULL; if (in.size() < 2) { Scierror(999, _("%s: Wrong size for input arguments: more than %d expected.\n"), "makecell", 2); return types::Function::Error; } if (_iRetCount > 1) { Scierror(999, _("%s: Wrong size for output arguments: %d expected.\n"), "makecell", 1); return types::Function::Error; } //check data type switch (in[0]->getType()) { case types::InternalType::ScilabDouble : { types::Double* pIn = in[0]->getAs<types::Double>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabInt8 : { types::Int8* pIn = in[0]->getAs<types::Int8>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabUInt8 : { types::UInt8* pIn = in[0]->getAs<types::UInt8>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabInt16 : { types::Int16* pIn = in[0]->getAs<types::Int16>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabUInt16 : { types::UInt16* pIn = in[0]->getAs<types::UInt16>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabInt32 : { types::Int32* pIn = in[0]->getAs<types::Int32>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabUInt32 : { types::UInt32* pIn = in[0]->getAs<types::UInt32>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabInt64 : { types::Int64* pIn = in[0]->getAs<types::Int64>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } case types::InternalType::ScilabUInt64 : { types::UInt64* pIn = in[0]->getAs<types::UInt64>(); iDims = pIn->getSize(); piDimsArray = new int[iDims]; iProd = get_dimsarray(pIn->get(), iDims, piDimsArray); break; } default : { Scierror(999, _("%s: Wrong input arguments: Dimensions given as first argument do not match specified cell contents.\n"), "makecell"); return types::Function::Error; } } //check vector format types::GenericType* pGT = in[0]->getAs<types::GenericType>(); if (pGT->isScalar() || (pGT->getRows() != 1 && pGT->getCols() != 1)) { delete[] piDimsArray; Scierror(999, _("%s: Wrong size for input argument #%d: A vector expected.\n"), "makecell", 1); return types::Function::Error; } //check input parameters count if (iProd != (in.size() - 1)) { delete[] piDimsArray; Scierror(999, _("%s: Wrong input arguments: Dimensions given as first argument do not match specified cell contents.\n"), "makecell"); return types::Function::Error; } types::Cell* pC = new types::Cell(iDims, piDimsArray); int i2dSize = piDimsArray[0] * piDimsArray[1]; for (int i = 0; i < in.size() - 1; i++) { int idx2dStart = (i / i2dSize) * i2dSize; int idx2dRowMajor = (((i - idx2dStart) % piDimsArray[1]) * piDimsArray[0]) + ((i - idx2dStart) / piDimsArray[1]); int idx = idx2dRowMajor + idx2dStart; pC->set(idx , in[i + 1]); } delete[] piDimsArray; out.push_back(pC); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_findfileassociation(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::String* pS = nullptr; std::wstring param1; std::wstring param2(L"open"); int rhs = static_cast<int>(in.size()); if (rhs != 1 && rhs != 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), fname.data(), 1, 2); return types::Function::Error; } if (_iRetCount != 1) { Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), fname.data(), 1); return types::Function::Error; } if (in[0]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname.data(), 1); return types::Function::Error; } pS = in[0]->getAs<types::String>(); if (pS->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname.data(), 1); return types::Function::Error; } param1 = pS->get()[0]; if (rhs == 2) { if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname.data(), 2); return types::Function::Error; } pS = in[1]->getAs<types::String>(); if (pS->isScalar() == false) { Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname.data(), 2); return types::Function::Error; } param2 = pS->get()[0]; } wchar_t* output = FindFileAssociation(param1.data(), param2.data()) ; if (output) { out.push_back(new types::String(output)); } else { out.push_back(types::Double::Empty()); } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_setdefaultlanguage(types::typed_list &in, int _piRetCount, types::typed_list &out) { if (in.size() != 1) { Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), "setdefaultlanguage", 1); return types::Function::Error; } if (_piRetCount != 1) { Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), "setdefaultlanguage", 1); return types::Function::Error; } #ifndef _MSC_VER /* ** No need to set default language except under Windows. ** Will return FALSE */ if (getWarningMode()) { sciprint(_("%ls: This feature is only supported on Windows.\n"), L"setdefaultlanguage"); } types::Bool* pbOut = new types::Bool(FALSE); out.push_back(pbOut); return types::Function::OK; #else if (in[0]->isString() == false || in[0]->getAs<types::String>()->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "setdefaultlanguage" , 1); return types::Function::Error; } wchar_t *newlang = getLanguageFromAlias(in[0]->getAs<types::String>()->get(0)); if ( !isValidLanguage(newlang) ) { if ( getWarningMode() ) { sciprint(_("Unsupported language '%ls'.\n"), newlang); } out.push_back(new types::Bool(FALSE)); return types::Function::OK; } else { wchar_t *savedLanguage = getLanguagePreferences(); if ( wcscmp(newlang, savedLanguage) == 0 ) { /* do nothing */ out.push_back(new types::Bool(TRUE)); return types::Function::OK; } else { // ?? if (savedLanguage) { FREE(savedLanguage); savedLanguage = NULL; } if ( !setlanguage(newlang) ) /* */ { out.push_back(new types::Bool(FALSE)); return types::Function::OK; } else { if ( getWarningMode() ) { sciprint("\n"); sciprint(_("The language for menus cannot be changed on a running console.\n")); sciprint(_("Restart Scilab to apply to menus.\n")); } if ( setLanguagePreferences() ) { out.push_back(new types::Bool(TRUE)); } else { out.push_back(new types::Bool(FALSE)); } return types::Function::OK; } } } #endif }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_readmps(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::String* pStrFileName = NULL; double dLowBnd = 0; double dUpBnd = 0; int iMaxM = 0; int iMaxN = 0; int iMaxNza = 0; int iM = 0; int iN = 0; int iNza = 0; int lunit = 0; // file unit. 0 mean we open the file by this name. int mlunit = 0; int piMode[2] = { -1, 0}; int ierr = 0; int line = 0; char typrow[2]; wchar_t* wcsFileName = NULL; char* strErrorBuf = new char[bsiz]; double big = NumericConstants::double_max; if (in.size() < 2 || in.size() > 3) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "readmps", 2, 3); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "readmps", 1); return types::Function::Error; } /*** get inputs arguments ***/ // get file name if (in[0]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "readmps", 1); return types::Function::Error; } pStrFileName = in[0]->getAs<types::String>(); if (pStrFileName->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar string expected.\n"), "readmps", 1); return types::Function::Error; } // get Bounds if (in[1]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "readmps", 2); return types::Function::Error; } types::Double* pDblBounds = in[1]->getAs<types::Double>(); if (pDblBounds->isComplex()) { Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "readmps", 2); return types::Function::Error; } if (pDblBounds->getSize() != 2) { Scierror(999, _("%s: Wrong size for input argument #%d: A real vector of size %d expected.\n"), "readmps", 2, 2); return types::Function::Error; } dLowBnd = pDblBounds->get(0); dUpBnd = pDblBounds->get(1); if (in.size() == 3) { // get Max sizes if (in[2]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "readmps", 3); return types::Function::Error; } types::Double* pDblMaxSizes = in[2]->getAs<types::Double>(); if (pDblMaxSizes->isComplex()) { Scierror(999, _("%s: Wrong type for input argument #%d: A real vector expected.\n"), "readmps", 3); return types::Function::Error; } if (pDblMaxSizes->getSize() != 3) { Scierror(999, _("%s: Wrong size for input argument #%d: A real vector of size %d expected.\n"), "readmps", 3, 3); return types::Function::Error; } iMaxM = (int)pDblMaxSizes->get(0); iMaxN = (int)pDblMaxSizes->get(1); iMaxNza = (int)pDblMaxSizes->get(2); } else { if (openMPSFile(pStrFileName, piMode, &lunit)) { return types::Function::Error; } C2F(rdmpsz)(&lunit, &iMaxM, &iMaxN, &iMaxNza, &ierr, typrow, &line); mlunit = -lunit; C2F(clunit)(&mlunit, NULL, piMode, 0); if (ierr == 1) { Scierror(998, _("%s: Error while reading line %d.\n"), "readmps", line); return types::Function::Error; } else if (ierr == 2) { Scierror(999, _("%s: Unknown row type %s at line %d.\n"), "readmps", typrow, line); return types::Function::Error; } lunit = 0; } iM = iMaxM; iN = iMaxN; iNza = iMaxNza; /*** read MPS file ***/ if (openMPSFile(pStrFileName, piMode, &lunit)) { return types::Function::Error; } // alloc data char nameb[9] = " "; char namec[9] = " "; char namran[9] = " "; char nambnd[9] = " "; char nammps[9] = " "; char* pstrRwName = new char[8 * iM + 1]; pstrRwName[8 * iM] = '\0'; char* pstrClName = new char[8 * iN + 1]; pstrClName[8 * iN] = '\0'; int irobj = 0; int* piStavar = new int[iN]; int* piRwstat = new int[iM]; int* piRowcod = new int[2 * iM]; int* piColcod = new int[2 * iN]; int* piRwnmbs = new int[iNza]; int* piClpnts = new int[iN + 1]; int* piRow = new int[iN]; types::Double* pDblCoef = new types::Double(iNza, 1); types::Double* pDblRhsb = new types::Double(iM, 1); types::Double* pDblRanges = new types::Double(iM, 1); types::Double* pDblBnds = new types::Double(iN, 2); double* pdblRelt = new double[iN]; C2F(rdmps1)(&ierr, strErrorBuf, &iMaxM, &iMaxN, &iMaxNza, &iM, &iN, &iNza, &irobj, &big, &dLowBnd, &dUpBnd, namec, nameb, namran, nambnd, nammps, &lunit, pstrRwName, pstrClName, piStavar, piRwstat, piRowcod, piRowcod + iM, piColcod, piColcod + iN, piRwnmbs, piClpnts, piRow, pDblCoef->get(), pDblRhsb->get(), pDblRanges->get(), pDblBnds->get() + iN, pDblBnds->get(), pdblRelt, bsiz, 8L, 8L, 8L, 8L, 8L); delete piRow; delete pdblRelt; mlunit = -lunit; C2F(clunit)(&mlunit, NULL, piMode, 0); if (ierr) { int iLen = 4096; char* str = strErrorBuf + 4095; while (*str == ' ') { iLen--; str--; } strErrorBuf[iLen] = '\0'; Scierror(999, "%s", strErrorBuf); delete[] strErrorBuf; return types::Function::Error; } delete[] strErrorBuf; /*** return output arguments ***/ types::String* pStr = NULL; types::Double* pDbl = NULL; double* pdbl = NULL; types::TList* pTL = new types::TList(); pStr = new types::String(1, 19); pStr->set(0, L"mps"); pStr->set(1, L"irobj"); pStr->set(2, L"namec"); pStr->set(3, L"nameb"); pStr->set(4, L"namran"); pStr->set(5, L"nambnd"); pStr->set(6, L"name"); pStr->set(7, L"rownames"); pStr->set(8, L"colnames"); pStr->set(9, L"rowstat"); pStr->set(10, L"rowcode"); pStr->set(11, L"colcode"); pStr->set(12, L"rownmbs"); pStr->set(13, L"colpnts"); pStr->set(14, L"acoeff"); pStr->set(15, L"rhs"); pStr->set(16, L"ranges"); pStr->set(17, L"bounds"); pStr->set(18, L"stavar"); pTL->append(pStr); pTL->append(new types::Double((double)irobj)); pTL->append(new types::String(namec)); pTL->append(new types::String(nameb)); pTL->append(new types::String(namran)); pTL->append(new types::String(nambnd)); pTL->append(new types::String(nammps)); pStr = new types::String(iM, 1); for (int i = 0; i < iM; i++) { char pstrTemp[9]; memcpy(pstrTemp, pstrRwName + i * 8, 8); pstrTemp[8] = '\0'; pStr->set(i, pstrTemp); } pTL->append(pStr); delete pstrRwName; pStr = new types::String(1, iN); for (int i = 0; i < iN; i++) { char pstrTemp[9]; memcpy(pstrTemp, pstrClName + i * 8, 8); pstrTemp[8] = '\0'; pStr->set(i, pstrTemp); } pTL->append(pStr); delete pstrClName; pDbl = new types::Double(iM, 1); pdbl = pDbl->get(); for (int i = 0; i < iM; i++) { pdbl[i] = (double)piRwstat[i]; } pTL->append(pDbl); delete piRwstat; pDbl = new types::Double(iM, 2); pdbl = pDbl->get(); for (int i = 0; i < iM * 2; i++) { pdbl[i] = (double)piRowcod[i]; } pTL->append(pDbl); delete piRowcod; pDbl = new types::Double(iN, 2); pdbl = pDbl->get(); for (int i = 0; i < iN * 2; i++) { pdbl[i] = (double)piColcod[i]; } pTL->append(pDbl); delete piColcod; pDbl = new types::Double(iNza, 1); pdbl = pDbl->get(); for (int i = 0; i < iNza; i++) { pdbl[i] = (double)piRwnmbs[i]; } pTL->append(pDbl); delete piRwnmbs; pDbl = new types::Double(1, iN + 1); pdbl = pDbl->get(); for (int i = 0; i < iN + 1; i++) { pdbl[i] = (double)piClpnts[i]; } pTL->append(pDbl); delete piClpnts; pTL->append(pDblCoef); pTL->append(pDblRhsb); pTL->append(pDblRanges); pTL->append(pDblBnds); pDbl = new types::Double(iN, 1); pdbl = pDbl->get(); for (int i = 0; i < iN; i++) { pdbl[i] = (double)piStavar[i]; } pTL->append(pDbl); delete piStavar; out.push_back(pTL); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_acos(types::typed_list &in, int _iRetCount, types::typed_list &out) { types::Double* pDblIn = NULL; types::Double* pDblOut = NULL; if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "acos", 1); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "acos", 1); return types::Function::Error; } if (in[0]->isDouble() == false) { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_acos"; return Overload::call(wstFuncName, in, _iRetCount, out); } pDblIn = in[0]->getAs<types::Double>(); if (pDblIn->isComplex()) { pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray(), true); int size = pDblIn->getSize(); double* pInR = pDblIn->get(); double* pInI = pDblIn->getImg(); double* pOutR = pDblOut->get(); double* pOutI = pDblOut->getImg(); for (int i = 0 ; i < size ; i++) { C2F(wacos)(pInR + i, pInI + i, pOutR + i, pOutI + i); } } else { bool bOutSide = 0; //check if all variables are between [-1,1] double* pInR = pDblIn->get(); int size = pDblIn->getSize(); for (int i = 0; i < size; i++) { if (std::abs(pInR[i]) > 1) { bOutSide = 1; break; } } if (bOutSide) // Values outside [-1,1] { pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray(), true); double* pOutR = pDblOut->get(); double* pOutI = pDblOut->getImg(); double zero = 0; for (int i = 0; i < size; i++) { C2F(wacos)(pInR + i, &zero, pOutR + i, pOutI + i); } } else //all values are in [-1,1] { pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray(), false); double* pOutR = pDblOut->get(); for (int i = 0; i < size; i++) { pOutR[i] = std::acos(pInR[i]); } } } out.push_back(pDblOut); return types::Function::OK; }
/*------------------------------------------------------------------------*/ types::Function::ReturnValue sci_grep(types::typed_list &in, int _iRetCount, types::typed_list &out) { bool bRegularExpression = false; //check input paramters if (in.size() < 2 || in.size() > 3) { Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), "grep", 2, 3); return types::Function::Error; } if (in[0]->isDouble() && in[0]->getAs<types::Double>()->getSize() == 0) { types::Double *pD = types::Double::Empty(); out.push_back(pD); return types::Function::OK; } if (in.size() == 3) { //"r" for regular expression if (in[2]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "grep", 3); return types::Function::Error; } types::String* pS = in[2]->getAs<types::String>(); if (pS->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "grep", 3); return types::Function::Error; } if (pS->get(0)[0] == 'r') { bRegularExpression = true; } } if (in[0]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "grep", 1); return types::Function::Error; } if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "grep", 2); return types::Function::Error; } types::String* pS1 = in[0]->getAs<types::String>(); types::String* pS2 = in[1]->getAs<types::String>(); for (int i = 0 ; i < pS2->getSize() ; i++) { if (wcslen(pS2->get(i)) == 0) { Scierror(249, _("%s: Wrong values for input argument #%d: Non-empty strings expected.\n"), "grep", 2); return types::Function::Error; } } GREPRESULTS grepresults; int code_error_grep = GREP_OK; grepresults.currentLength = 0; grepresults.sizeArraysMax = 0; grepresults.positions = NULL; grepresults.values = NULL; char** pStr1 = (char**)MALLOC(sizeof(char*) * pS1->getSize()); for (int i = 0 ; i < pS1->getSize() ; i++) { pStr1[i] = wide_string_to_UTF8(pS1->get(i)); } char** pStr2 = (char**)MALLOC(sizeof(char*) * pS2->getSize()); for (int i = 0 ; i < pS2->getSize() ; i++) { pStr2[i] = wide_string_to_UTF8(pS2->get(i)); } if (bRegularExpression) { code_error_grep = GREP_NEW(&grepresults, pStr1, pS1->getSize(), pStr2, pS2->getSize()); } else { code_error_grep = GREP_OLD(&grepresults, pStr1, pS1->getSize(), pStr2, pS2->getSize()); } for (int i = 0; i < pS1->getSize(); i++) { FREE(pStr1[i]); } FREE(pStr1); for (int i = 0; i < pS2->getSize(); i++) { FREE(pStr2[i]); } FREE(pStr2); switch (code_error_grep) { case GREP_OK : { types::Double* pD1 = NULL; if (grepresults.currentLength == 0) { pD1 = types::Double::Empty(); } else { pD1 = new types::Double(1, grepresults.currentLength); double* pDbl1 = pD1->getReal(); for (int i = 0 ; i < grepresults.currentLength ; i++ ) { pDbl1[i] = static_cast<double>(grepresults.values[i]); } } out.push_back(pD1); if (_iRetCount == 2) { types::Double* pD2 = NULL; if (grepresults.currentLength == 0) { pD2 = types::Double::Empty(); } else { pD2 = new types::Double(1, grepresults.currentLength); double* pDbl2 = pD2->getReal(); for (int i = 0 ; i < grepresults.currentLength ; i++ ) { pDbl2[i] = static_cast<double>(grepresults.positions[i]); } } out.push_back(pD2); } if (grepresults.values) { FREE(grepresults.values); grepresults.values = NULL; } if (grepresults.positions) { FREE(grepresults.positions); grepresults.positions = NULL; } } break; case MEMORY_ALLOC_ERROR : Scierror(999, _("%s: No more memory.\n"), "grep"); //no break, to free reserved memory. case GREP_ERROR : { if (grepresults.values) { FREE(grepresults.values); grepresults.values = NULL; } if (grepresults.positions) { FREE(grepresults.positions); grepresults.positions = NULL; } return types::Function::Error; } break; } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ Function::ReturnValue sci_load(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() < 1) { Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1); return types::Function::Error; } InternalType* pIT = in[0]; if (pIT->getId() != InternalType::IdScalarString) { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname.data(), 1); return Function::Error; } String *pS = pIT->getAs<types::String>(); wchar_t* pwstPathLib = expandPathVariableW(pS->get(0)); char* pstPath = wide_string_to_UTF8(pwstPathLib); if (FileExist(pstPath)) { if (isHDF5File(pstPath)) { FREE(pstPath); FREE(pwstPathLib); //call overload std::wstring wstFuncName = L"%_sodload"; ast::ExecVisitor exec; Callable::ReturnValue Ret = Callable::Error; Ret = Overload::call(wstFuncName, in, _iRetCount, out, &exec); return Ret; } else { int err = 0; Library* lib = loadlib(pS->get(0), &err); FREE(pstPath); switch (err) { case 0: //no error break; case 1: { char* pstPath = wide_string_to_UTF8(pS->get(0)); Scierror(999, _("%s: %s is not a valid module file.\n"), fname.data(), pstPath); FREE(pstPath); return Function::Error; } case 2: { Scierror(999, "%s: %s", fname.data(), _("Redefining permanent variable.\n")); return Function::Error; } default: { //nothing } } FREE(pwstPathLib); lib->killMe(); } } else { Scierror(999, _("%s: Unable to open file: \"%ls\".\n"), fname.data(), pwstPathLib); FREE(pstPath); FREE(pwstPathLib); return Function::Error; } return Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_find(types::typed_list &in, int _iRetCount, types::typed_list &out) { int iMax = -1; if (in.size() > 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "find", 1, 2); return types::Function::Error; } if (in.size() == 2) { if (in[1]->isDouble() == false || in[1]->getAs<types::Double>()->isScalar() == false || in[1]->getAs<types::Double>()->get(0) <= 0) { Scierror(999, _("%s: Wrong type for input argument #%d: Scalar positive integer expected.\n"), "find", 2); return types::Function::Error; } iMax = (int)in[1]->getAs<types::Double>()->get(0); } int* piIndex = 0; int iValues = 0; if (in[0]->isGenericType() == false) { //call overload for other types std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_find"; return Overload::call(wstFuncName, in, _iRetCount, out); } types::GenericType* pGT = in[0]->getAs<types::GenericType>(); piIndex = new int[pGT->getSize()]; if (in[0]->isBool()) { types::Bool* pB = in[0]->getAs<types::Bool>(); for (int i = 0 ; (iMax == -1 || iValues < iMax) && i < pB->getSize() ; i++) { if (pB->get(i)) { piIndex[iValues] = i; iValues++; } } } else if (in[0]->isDouble()) { types::Double* pD = in[0]->getAs<types::Double>(); for (int i = 0 ; (iMax == -1 || iValues < iMax) && i < pD->getSize() ; i++) { if (pD->get(i)) { piIndex[iValues] = i; iValues++; } } } else if (in[0]->isSparse()) { types::Sparse* pSP = in[0]->getAs<types::Sparse>(); int iNNZ = (int)pSP->nonZeros(); int iRows = pSP->getRows(); int* pRows = new int[iNNZ * 2]; pSP->outputRowCol(pRows); int *pCols = pRows + iNNZ; for (int i = 0 ; (iMax == -1 || iValues < iMax) && i < iNNZ ; i++) { piIndex[iValues] = (pCols[i] - 1) * iRows + (pRows[i] - 1); iValues++; } delete[] pRows; } else if (in[0]->isSparseBool()) { types::SparseBool* pSB = in[0]->getAs<types::SparseBool>(); int iNNZ = (int)pSB->nbTrue(); int iRows = pSB->getRows(); int* pRows = new int[iNNZ * 2]; pSB->outputRowCol(pRows); int* pCols = pRows + iNNZ; for (int i = 0 ; (iMax == -1 || iValues < iMax) && i < iNNZ ; i++) { piIndex[iValues] = (pCols[i] - 1) * iRows + (pRows[i] - 1); iValues++; } delete[] pRows; } else { delete[] piIndex; //call overload for other types std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_find"; return Overload::call(wstFuncName, in, _iRetCount, out); } if (iValues == 0) { for (int i = 0 ; i < _iRetCount ; i++) { out.push_back(types::Double::Empty()); } } else { int* piRefDims = pGT->getDimsArray(); int iRefDims = pGT->getDims(); int* piDims = new int[_iRetCount]; int iDims = _iRetCount; if (iDims == iRefDims) { for (int i = 0 ; i < iRefDims ; i++) { piDims[i] = piRefDims[i]; } } else if (iDims > iRefDims) { for (int i = 0 ; i < iRefDims ; i++) { piDims[i] = piRefDims[i]; } for (int i = iRefDims ; i < iDims ; i++) { piDims[i] = 1; } } else //iDims < iRefDims { for (int i = 0 ; i < iDims - 1 ; i++) { piDims[i] = piRefDims[i]; } piDims[iDims - 1] = 1; for (int i = iDims - 1 ; i < iRefDims ; i++) { piDims[iDims - 1] *= piRefDims[i]; } } int** piCoord = new int*[iValues]; for (int i = 0 ; i < iValues ; i++) { piCoord[i] = new int[_iRetCount]; } for (int i = 0 ; i < iValues ; i++) { getCoordFromIndex(piIndex[i], piCoord[i], piDims, iDims); } for (int i = 0 ; i < _iRetCount ; i++) { types::Double* pOut = new types::Double(1, iValues); for (int j = 0 ; j < iValues ; j++) { pOut->set(j, piCoord[j][i] + 1); } out.push_back(pOut); } delete[] piDims; for (int i = 0 ; i < iValues ; i++) { delete[] piCoord[i]; } delete[] piCoord; } delete[] piIndex; return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_floor(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "floor", 1); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "floor", 1); return types::Function::Error; } if (in[0]->isDouble()) { types::Double* pDblIn = in[0]->getAs<types::Double>(); types::Double* pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray(), pDblIn->isComplex()); double* pInR = pDblIn->get(); double* pOutR = pDblOut->get(); int size = pDblIn->getSize(); if (pDblIn->isComplex()) { double* pInI = pDblIn->getImg(); double* pOutI = pDblOut->getImg(); for (int i = 0; i < size; i++) { pOutR[i] = std::floor(pInR[i]); pOutI[i] = std::floor(pInI[i]); } } else { for (int i = 0; i < size; i++) { pOutR[i] = std::floor(pInR[i]); } } out.push_back(pDblOut); } else if (in[0]->isSparse()) { types::Sparse* pSparseIn = in[0]->getAs<types::Sparse>(); types::Sparse* pSparseOut = new types::Sparse(pSparseIn->getRows(), pSparseIn->getCols(), pSparseIn->isComplex()); int const nonZeros = static_cast<int>(pSparseIn->nonZeros()); int* pRows = new int[nonZeros * 2]; pSparseIn->outputRowCol(pRows); int* pCols = pRows + nonZeros; double* pNonZeroR = new double[nonZeros]; double* pNonZeroI = new double[nonZeros]; pSparseIn->outputValues(pNonZeroR, pNonZeroI); if (pSparseIn->isComplex()) { for (int i = 0; i < nonZeros; i++) { std::complex<double> cplx(dfloors(pNonZeroR[i]), dfloors(pNonZeroI[i])); pSparseOut->set(pRows[i] - 1, pCols[i] - 1, cplx, false); } } else { for (int i = 0; i < nonZeros; i++) { pSparseOut->set(pRows[i] - 1, pCols[i] - 1, dfloors(pNonZeroR[i]), false); } } pSparseOut->finalize(); delete[] pRows; delete[] pNonZeroR; delete[] pNonZeroI; out.push_back(pSparseOut); } else if (in[0]->isPoly()) { types::Polynom* pPolyIn = in[0]->getAs<types::Polynom>(); types::Polynom* pPolyOut = new types::Polynom(pPolyIn->getVariableName(), pPolyIn->getDims(), pPolyIn->getDimsArray()); double* dataImg = NULL; double* dataReal = NULL; if (pPolyIn->isComplex()) { for (int i = 0; i < pPolyIn->getSize(); i++) { int rank = pPolyIn->get(i)->getRank(); types::SinglePoly* pSP = new types::SinglePoly(&dataReal, &dataImg, rank); for (int j = 0; j < rank + 1; j++) { dataReal[j] = dfloors(pPolyIn->get(i)->get()[j]); dataImg[j] = dfloors(pPolyIn->get(i)->getImg()[j]); } pPolyOut->set(i, pSP); delete pSP; pSP = NULL; } } else { for (int i = 0; i < pPolyIn->getSize(); i++) { int rank = pPolyIn->get(i)->getRank(); types::SinglePoly* pSP = new types::SinglePoly(&dataReal, rank); for (int j = 0; j < rank + 1; j++) { dataReal[j] = dfloors(pPolyIn->get(i)->get()[j]); } pPolyOut->set(i, pSP); delete pSP; pSP = NULL; } } out.push_back(pPolyOut); } else if (in[0]->isInt()) { out.push_back(in[0]); } else { std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_floor"; return Overload::call(wstFuncName, in, _iRetCount, out); } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_xset(types::typed_list &in, int _iRetCount, types::typed_list &out) { wchar_t* pwcsWhat = NULL; std::list<types::Double*> lpDblInputs; int iSubwinUID = 0; if (in.size() == 0) { return Overload::call(L"%_xset", in, _iRetCount, out); } if (in.size() > 6) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "xset", 1, 6); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "xset", 1); return types::Function::Error; } if (in[0]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 1); return types::Function::Error; } types::String* pStr = in[0]->getAs<types::String>(); if (pStr->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 1); return types::Function::Error; } pwcsWhat = pStr->get(0); if (ConfigGraphicVariable::bPropertyFound(pwcsWhat) == false) { char* pstWhat = wide_string_to_UTF8(pwcsWhat); Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), "xset", pstWhat); FREE(pstWhat); return types::Function::Error; } // Only in case of "fpf" and "auto clear", the second argument is a string // Only "default" case have one input argument if (ConfigGraphicVariable::getPropertyValue(pwcsWhat) != 15 && // fpf ConfigGraphicVariable::getPropertyValue(pwcsWhat) != 2 && // auto clear ConfigGraphicVariable::getPropertyValue(pwcsWhat) != 10) // default { for (unsigned int i = 1 ; i < in.size() ; i++) { if (in[i]->isDouble() == false) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), "xset", i + 1); } } } switch (ConfigGraphicVariable::getPropertyValue(pwcsWhat)) { case 15 : // fpf { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 2); return types::Function::Error; } types::String* pStrValue = in[1]->getAs<types::String>(); if (pStrValue->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 2); return types::Function::Error; } ConfigGraphicVariable::setFPF(pStrValue->get(0)); } break; case 2 : // auto clear { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } if (in[1]->isString() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 2); return types::Function::Error; } types::String* pStrValue = in[1]->getAs<types::String>(); if (pStrValue->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A single string expected.\n"), "xset", 2); return types::Function::Error; } int bAutoClear = 0; if (wcscmp(pStrValue->get(0), L"on") == 0) { bAutoClear = 1; } setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTO_CLEAR__, &bAutoClear, jni_bool, 1); } break; case 5 : // clipping { int clipState = 2; double dvalues[4]; if (in.size() == 2) { types::Double* pDblArg = in[1]->getAs<types::Double>(); if (pDblArg->getSize() != 4) { Scierror(999, _("%s: Wrong size for input argument #%d: A %d-element vector expected.\n"), "xset", 2, 4); return types::Function::Error; } memcpy(dvalues, pDblArg->get(), 4 * sizeof(double)); } else if (in.size() != 5) { Scierror(77, _("%s: Wrong number of input arguments: %d or %d expected.\n"), "xset", 2, 5); return types::Function::Error; } else { for (int i = 0; i < 4 ; i++) { dvalues[i] = in[i + 1]->getAs<types::Double>()->get(0); } } iSubwinUID = getOrCreateDefaultSubwin(); setGraphicObjectProperty(iSubwinUID, __GO_CLIP_BOX__, dvalues, jni_double_vector, 4); setGraphicObjectProperty(iSubwinUID, __GO_CLIP_STATE__, &clipState, jni_int, 1); } break; case 8 : // colormap { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "xset", 2); return types::Function::Error; } types::Double* pDblArg = in[1]->getAs<types::Double>(); getOrCreateDefaultSubwin(); setGraphicObjectProperty(getCurrentFigure(), __GO_COLORMAP__, pDblArg->get(), jni_double_vector, pDblArg->getSize()); } break; case 21 : // mark size { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "xset", 2); return types::Function::Error; } int markSize = (int)in[1]->getAs<types::Double>()->get(0); int markSizeUnit = 1; /* force switch to tabulated mode : old syntax / 0 : point, 1 : tabulated */ iSubwinUID = getOrCreateDefaultSubwin(); setGraphicObjectProperty(iSubwinUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1); setGraphicObjectProperty(iSubwinUID, __GO_MARK_SIZE__, &markSize, jni_int, 1); } break; case 20 : // mark { if (in.size() != 3) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 3); return types::Function::Error; } int markStyle = (int) in[1]->getAs<types::Double>()->get(0); int markSize = (int) in[2]->getAs<types::Double>()->get(0); int markSizeUnit = 1; /* force switch to tabulated mode : old syntax / 0 : point, 1 : tabulated */ int markMode = 1; iSubwinUID = getOrCreateDefaultSubwin(); setGraphicObjectProperty(iSubwinUID, __GO_MARK_MODE__, &markMode, jni_bool, 1); setGraphicObjectProperty(iSubwinUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1); /* force switch to tabulated mode : old syntax */ setGraphicObjectProperty(iSubwinUID, __GO_MARK_STYLE__, &markStyle, jni_int, 1); setGraphicObjectProperty(iSubwinUID, __GO_MARK_SIZE__, &markSize, jni_int, 1); } break; case 13 : // font size { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } double fontSize = in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1); } break; case 10 : // default { if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 1); return types::Function::Error; } unsigned short* defcolors = ConfigGraphicVariable::getDefaultColormap(); int piFigurePosition[2] = {200, 200}; int piFigureSize[2] = {500, 500}; int piAxesSize[2] = {498, 366}; int piViewPort[2] = {0, 0}; int piEmptyMatrix[4] = {1, 0, 0, 0}; // init variables int iZero = 0; BOOL bTrue = TRUE; BOOL bFalse = FALSE; int m = NUMCOLORS_SCI; int i = 0; int iCopy = 3; int defaultBackground = -2; // reset format ConfigGraphicVariable::setFPF(L""); double* pdblColorMap = new double[m * 3]; if (pdblColorMap == NULL) { Scierror(999, _("%s: No more memory.\n"), "xset"); return types::Function::Error; } // Create figure if it not exist. int iFigureUID = getCurrentFigure(); if (iFigureUID == 0) { iFigureUID = createNewFigureWithAxes(); setCurrentFigure(iFigureUID); delete[] pdblColorMap; return types::Function::OK; } // Create new axes and set it in current figure int iSubWinUID = getCurrentSubWin(); if (iSubWinUID != 0) { int iChildrenCount = 0; int* childrencount = &iChildrenCount; int* childrenUID = 0; int iHidden = 0; int *piHidden = &iHidden; getGraphicObjectProperty(iFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&childrencount); getGraphicObjectProperty(iFigureUID, __GO_CHILDREN__, jni_string_vector, (void **)&childrenUID); for (i = 0; i < childrencount[0]; ++i) { getGraphicObjectProperty(childrenUID[i], __GO_HIDDEN__, jni_bool, (void **)&piHidden); if (iHidden == 0) { deleteGraphicObject(childrenUID[i]); } } } cloneAxesModel(iFigureUID); // Set default figure properties setGraphicObjectProperty(iFigureUID, __GO_POSITION__, piFigurePosition, jni_int_vector, 2); setGraphicObjectProperty(iFigureUID, __GO_SIZE__, piFigureSize, jni_int_vector, 2); setGraphicObjectProperty(iFigureUID, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2); setGraphicObjectProperty(iFigureUID, __GO_AUTORESIZE__, &bTrue, jni_bool, 1); setGraphicObjectProperty(iFigureUID, __GO_VIEWPORT__, piViewPort, jni_int_vector, 2); setGraphicObjectProperty(iFigureUID, __GO_NAME__, _("Figure n°%d"), jni_string, 1); setGraphicObjectProperty(iFigureUID, __GO_INFO_MESSAGE__, "", jni_string, 1); setGraphicObjectProperty(iFigureUID, __GO_PIXEL_DRAWING_MODE__, &iCopy, jni_int, 1); setGraphicObjectProperty(iFigureUID, __GO_ANTIALIASING__, &iZero, jni_int, 1); setGraphicObjectProperty(iFigureUID, __GO_IMMEDIATE_DRAWING__, &bTrue, jni_bool, 1); setGraphicObjectProperty(iFigureUID, __GO_BACKGROUND__, &defaultBackground, jni_int, 1); setGraphicObjectProperty(iFigureUID, __GO_VISIBLE__, &bTrue, jni_bool, 1); setGraphicObjectProperty(iFigureUID, __GO_ROTATION_TYPE__, &iZero, jni_int, 1); setGraphicObjectProperty(iFigureUID, __GO_EVENTHANDLER__, "", jni_string, 1); setGraphicObjectProperty(iFigureUID, __GO_EVENTHANDLER_ENABLE__, &bFalse, jni_bool, 1); setGraphicObjectProperty(iFigureUID, __GO_USER_DATA__, piEmptyMatrix, jni_int_vector, 4); setGraphicObjectProperty(iFigureUID, __GO_RESIZEFCN__, "", jni_string, 1); setGraphicObjectProperty(iFigureUID, __GO_TAG__, "", jni_string, 1); for (i = 0; i < m; i++) { pdblColorMap[i] = (double)(defcolors[3 * i] / 255.0); pdblColorMap[i + m] = (double)(defcolors[3 * i + 1] / 255.0); pdblColorMap[i + 2 * m] = (double)(defcolors[3 * i + 2] / 255.0); } setGraphicObjectProperty(iFigureUID, __GO_COLORMAP__, pdblColorMap, jni_double_vector, 3 * m); setGraphicObjectProperty(iFigureUID, __GO_PARENT__, "", jni_string, 1); delete[] pdblColorMap; } break; case 6 : // clipgrf { int clipState = 1; /* special treatement for xset("cligrf") */ setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1); } break; case 4 : // clipoff { int clipState = 0; /* special treatement for xset("clipoff") */ setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1); } break; case 16 : // hidden3d { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int hiddenColor = (int) in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_HIDDEN_COLOR__, &hiddenColor, jni_int, 1); } break; case 12 : // font { if (in.size() != 3) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 3); return types::Function::Error; } int fontStyle = (int) in[1]->getAs<types::Double>()->get(0); double fontSize = in[2]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_STYLE__, &fontStyle, jni_int, 1); } break; case 11 : // window case 30 : // figure { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } // Find if window already exists, if not create a new one int iID = (int)in[1]->getAs<types::Double>()->get(0); int iFigureUID = getFigureFromIndex(iID); int iAxesUID = 0; int* piAxesUID = &iAxesUID; if (iFigureUID == 0) { iFigureUID = createNewFigureWithAxes(); setGraphicObjectProperty(iFigureUID, __GO_ID__, &iID, jni_int, 1); } setCurrentFigure(iFigureUID); getGraphicObjectProperty(iFigureUID, __GO_SELECTED_CHILD__, jni_int, (void**)&piAxesUID); setCurrentSubWin(iAxesUID); } break; case 14 : // foreground case 7 : // color case 23 : // pattern { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int iColor = (int) in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_COLOR__, &iColor, jni_int, 1); } break; case 3 : // background { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int iColor = (int) in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_BACKGROUND__, &iColor, jni_int, 1); } break; case 25 : // thickness { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } sciSetLineWidth(getOrCreateDefaultSubwin(), (int)in[1]->getAs<types::Double>()->get(0)); } break; case 19 : // line style { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int lineStyle = (int) in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1); } break; case 9 : // dashes { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int lineStyle = (int) in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1); } break; case 33 : // wresize { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int iAutoResizeMode = (int)in[1]->getAs<types::Double>()->get(0); setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTORESIZE__, &iAutoResizeMode, jni_bool, 1); } break; case 32 : // wpos { int figurePosition[2]; if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } getOrCreateDefaultSubwin(); figurePosition[0] = (int)in[1]->getAs<types::Double>()->get(0); figurePosition[1] = (int)in[1]->getAs<types::Double>()->get(1); setGraphicObjectProperty(getCurrentFigure(), __GO_POSITION__, figurePosition, jni_int_vector, 2); } break; case 31 : // wpdim case 28 : // wdim { int figureSize[2] = {0, 0}; if (in.size() != 2 && in.size() != 3) { Scierror(77, _("%s: Wrong number of input arguments: %d or %d expected.\n"), "xset", 2, 3); return types::Function::Error; } figureSize[0] = (int)in[1]->getAs<types::Double>()->get(0); if (in.size() == 3) { figureSize[1] = (int)in[2]->getAs<types::Double>()->get(0); } /* Xwindows limits dimensions to 2^16 */ if ((figureSize[0] > 65535) || (figureSize[1] > 65535)) { figureSize[0] = std::min(figureSize[0], 65535); figureSize[1] = std::min(figureSize[1], 65535); if (ConfigVariable::getWarningMode()) { sciprint(_("%s: window dimensions have been set less than 2^16.\n"), "xset"); } } getOrCreateDefaultSubwin(); setGraphicObjectProperty(getCurrentFigure(), __GO_SIZE__, figureSize, jni_int_vector, 2); } break; case 27 : // viewport { if (in.size() != 3) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 3); return types::Function::Error; } int viewport[4] = {0, 0, 0, 0}; viewport[0] = (int)in[1]->getAs<types::Double>()->get(0); viewport[1] = (int)in[2]->getAs<types::Double>()->get(0); getOrCreateDefaultSubwin(); setGraphicObjectProperty(getCurrentFigure(), __GO_VIEWPORT__, viewport, jni_int_vector, 2); } break; case 18 : // line mode { if (in.size() != 2) { Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), "xset", 2); return types::Function::Error; } int iSubwinUID = getOrCreateDefaultSubwin(); int iZero = 0; int iOne = 1; if (in[1]->getAs<types::Double>()->get(0) == 0) { setGraphicObjectProperty(iSubwinUID, __GO_LINE_MODE__, &iZero, jni_bool, 1); } else { setGraphicObjectProperty(iSubwinUID, __GO_LINE_MODE__, &iOne, jni_bool, 1); } } break; default : { char* pstWhat = wide_string_to_UTF8(pwcsWhat); Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), "xset", pstWhat); FREE(pstWhat); return types::Function::Error; } } return types::Function::OK; }
bool getDimsFromArguments(types::typed_list& in, const std::string& _pstName, int* _iDims, int** _piDims, bool* _alloc) { types::Double* pOut = 0; *_alloc = false; *_iDims = 0; *_piDims = NULL; if (in.size() == 0) { *_iDims = 2; *_piDims = new int[*_iDims]; (*_piDims)[0] = 1; (*_piDims)[1] = 1; *_alloc = true; return true; } else if (in.size() == 1) { *_iDims = 1; // : if (in[0]->isColon()) { *_iDims = -1; return false; } if (in[0]->isArrayOf() == false) { if (in[0]->isSparse()) { types::Sparse* sp = in[0]->getAs<types::Sparse>(); *_iDims = sp->getDims(); *_piDims = sp->getDimsArray(); return true; } else if (in[0]->isSparseBool()) { types::SparseBool* sp = in[0]->getAs<types::SparseBool>(); *_iDims = sp->getDims(); *_piDims = sp->getDimsArray(); return true; } return false; } types::GenericType* pIn = in[0]->getAs<types::GenericType>(); *_iDims = pIn->getDims(); *_piDims = pIn->getDimsArray(); return true; } else { *_iDims = static_cast<int>(in.size()); *_piDims = new int[*_iDims]; *_alloc = true; for (int i = 0; i < *_iDims; i++) { if (in[i]->isArrayOf() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1); delete[] * _piDims; return false; } types::GenericType* pGTIn = in[i]->getAs<types::GenericType>(); if (pGTIn->isScalar() == false || pGTIn->isComplex()) { Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1); delete[] * _piDims; return false; } switch (in[i]->getType()) { case types::InternalType::ScilabDouble: { double dValue = in[i]->getAs<types::Double>()->get(0); if (dValue >= INT_MAX) { Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX); delete[] * _piDims; return false; } (*_piDims)[i] = static_cast<int>(dValue); } break; case types::InternalType::ScilabInt8: (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::Int8>()->get()[0]); break; case types::InternalType::ScilabUInt8: (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt8>()->get()[0]); break; case types::InternalType::ScilabInt16: (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::Int16>()->get()[0]); break; case types::InternalType::ScilabUInt16: (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt16>()->get()[0]); break; case types::InternalType::ScilabInt32: (*_piDims)[i] = in[i]->getAs<types::Int32>()->get()[0]; break; case types::InternalType::ScilabUInt32: (*_piDims)[i] = static_cast<int>(in[i]->getAs<types::UInt32>()->get()[0]); break; case types::InternalType::ScilabInt64: { long long llValue = in[i]->getAs<types::Int64>()->get(0); if (llValue >= INT_MAX) { Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX); delete[] * _piDims; return false; } (*_piDims)[i] = static_cast<int>(llValue); break; } case types::InternalType::ScilabUInt64: { unsigned long long ullValue = in[i]->getAs<types::UInt64>()->get(0); if (ullValue >= INT_MAX) { Scierror(999, _("%s: variable size exceeded : less than %d expected.\n"), _pstName.c_str(), INT_MAX); delete[] * _piDims; return false; } (*_piDims)[i] = static_cast<int>(ullValue); break; } default: Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), _pstName.c_str(), i + 1); delete[] * _piDims; return false; } } return true; } return false; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_fft(types::typed_list &in, int _iRetCount, types::typed_list &out) { int iDimLength = 0; int iDimCount = 0; int iInc = 0; int iWay = -1; int iSize = 0; int iOne = 1; int iErr = 0; double dblZero = 0; //workspace int iWS = 0; int* piWS = NULL; types::Double* pIn1 = NULL; //check input parameters if (in.size() != 1 && in.size() != 2 && in.size() != 4) { Scierror(77, _("%s: Wrong number of input argument(s): %d or %d expected.\n"), "fft", 1, 4); return types::Function::Error; } switch (in.size()) { case 4 : //check fourth input parameter : inc if (in[3]->isDouble() == false || in[3]->getAs<types::Double>()->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), "fft", 4); return types::Function::Error; } iInc = (int)in[3]->getAs<types::Double>()->get(0); //check third input parameter : dim if (in[2]->isDouble() == false || in[2]->getAs<types::Double>()->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), "fft", 3); return types::Function::Error; } iDimLength = (int)in[2]->getAs<types::Double>()->get(0); iDimCount = 3; //any value > 2 (used as a flag) case 2 : //check third input parameter : way if (in[1]->isDouble() == false || in[1]->getAs<types::Double>()->isScalar() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), "fft", 2); return types::Function::Error; } iWay = (int)in[1]->getAs<types::Double>()->get(0); if (iWay != -1 && iWay != 1) { Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "fft", 2, "-1 1"); return types::Function::Error; } case 1: if (in[0]->isDouble() == false) { Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), "fft", 1); return types::Function::Error; } pIn1 = in[0]->getAs<types::Double>(); iDimCount = std::max(iDimCount, ((pIn1->getRows() == 1 || pIn1->getCols() == 1) ? 1 : 2)); iSize = pIn1->getSize(); break; default : { Scierror(77, _("%s: Wrong number of input argument(s): %d or %d expected.\n"), "fft", 1, 4); return types::Function::Error; } } types::Double* pOut = pIn1->clone()->getAs<types::Double>(); pOut->setComplex(true); //alloc workspace required by dfft2 iWS = 8 * maxfactor(iDimLength == 0 ? iSize : iDimLength) + 24; piWS = (int*)MALLOC(iWS * sizeof(int)); if (piWS == NULL) { Scierror(999, _("%s : Memory allocation error.\n"), "fft"); return types::Function::Error; } switch (iDimCount) { case 1 : iErr = fft_1dim(pOut->getReal(), pOut->getImg(), iSize, iWay, piWS, iWS); break; case 2 : iErr = fft_2dim(pOut->getReal(), pOut->getImg(), pOut->getRows(), pOut->getCols(), iWay, piWS, iWS); if (iErr == 1) { Scierror(999, _("%s : Memory allocation error.\n"), "fft"); return types::Function::Error; } break; default : iErr = fft_ndim(pOut->getReal(), pOut->getImg(), iSize, iDimLength, iInc, iWay, piWS, iWS); break; } double *df = pOut->getImg(); bool cplx = false; for (int i = 0; i < iSize; i++) { if (df[i] != 0) { cplx = true; break; } } if (cplx == false) { pOut->setComplex(false); } FREE(piWS); out.push_back(pOut); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_mget(types::typed_list &in, int _iRetCount, types::typed_list &out) { char* pstType = os_strdup("l");//default type value : long int iSize = 0; int iFile = -1; //default file : last opened file int iErr = 0; if (in.size() < 1 || in.size() > 3) { Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "mget", 1, 3); return types::Function::Error; } //check parameter 1 if (in[0]->isDouble() == false || in[0]->getAs<types::Double>()->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: A positive integer value expected.\n"), "mget", 1); return types::Function::Error; } types::Double* pDoubleTest = in[0]->getAs<types::Double>(); if ((pDoubleTest->get(0) != (int)pDoubleTest->get(0)) || (pDoubleTest->get(0) < 0)) { Scierror(999, _("%s: Wrong value for input argument #%d: A positive integer value expected.\n"), "mget", 1); return types::Function::Error; } iSize = static_cast<int>(in[0]->getAs<types::Double>()->get(0)); if (in.size() >= 2) { //export format if (in[1]->isString() == false || in[1]->getAs<types::String>()->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), "mget", 2); return types::Function::Error; } FREE(pstType); pstType = wide_string_to_UTF8(in[1]->getAs<types::String>()->get(0)); } if (in.size() == 3) { if (in[2]->isDouble() == false || in[2]->getAs<types::Double>()->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: A integer expected.\n"), "mget", 3); return types::Function::Error; } iFile = static_cast<int>(in[2]->getAs<types::Double>()->get(0)); } switch (iFile) { case 0: // stderr case 6: // stdout FREE(pstType); Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mget", iFile); return types::Function::Error; } types::File* pFile = FileManager::getFile(iFile); // file opened with fortran open function if (pFile == NULL || pFile->getFileType() == 1) { FREE(pstType); Scierror(999, _("%s: Wrong file descriptor: %d.\n"), "mget", iFile); return types::Function::Error; } types::Double* pD = new types::Double(1, iSize); double* pData = pD->get(); C2F(mget)(&iFile, pData, &iSize, pstType, &iErr); FREE(pstType); if (iErr > 0) { return types::Function::Error; } if (iErr < 0) //no error { int iNewSize = (-iErr) - 1; if (iNewSize < iSize) { //read data are smaller then excepted size types::Double* pNewD = new types::Double(1, iNewSize); double* pNewData = pNewD->getReal(); for (int i = 0 ; i < iNewSize ; i++) { pNewData[i] = pData[i]; } delete pD; pD = pNewD; } } out.push_back(pD); return types::Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_imag(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() != 1) { Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), "imag", 1); return types::Function::Error; } if (_iRetCount > 1) { Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), "imag", 1); return types::Function::Error; } if (in[0]->isDouble()) { types::Double* pDblIn = in[0]->getAs<types::Double>(); int iSize = pDblIn->getSize(); int iOne = 1; types::Double* pDblOut = new types::Double(pDblIn->getDims(), pDblIn->getDimsArray()); if (pDblIn->isComplex() == false) { memset(pDblOut->get(), 0x00, iSize * sizeof(double)); } else { C2F(dcopy)(&iSize, pDblIn->getImg(), &iOne, pDblOut->getReal(), &iOne); } out.push_back(pDblOut); } else if (in[0]->isSparse()) { types::Sparse* pSparseIn = in[0]->getAs<types::Sparse>(); types::Sparse* pSparseOut = new types::Sparse(pSparseIn->getRows(), pSparseIn->getCols()); if (pSparseIn->isComplex() == false) { out.push_back(pSparseOut); return types::Function::OK; } int const nonZeros = static_cast<int>(pSparseIn->nonZeros()); int* pRows = new int[nonZeros * 2]; pSparseIn->outputRowCol(pRows); int* pCols = pRows + nonZeros; for (int i = 0 ; i < nonZeros ; i++) { std::complex<double> cplx = pSparseIn->getImg(pRows[i] - 1, pCols[i] - 1); pSparseOut->set(pRows[i] - 1, pCols[i] - 1, cplx.imag(), false); } pSparseOut->finalize(); delete[] pRows; out.push_back(pSparseOut); } else if (in[0]->isPoly()) { types::Polynom* pPolyIn = in[0]->getAs<types::Polynom>(); types::Polynom* pPolyOut = NULL; if (pPolyIn->isComplex()) { pPolyOut = new types::Polynom(pPolyIn->getVariableName(), pPolyIn->getDims(), pPolyIn->getDimsArray()); for (int i = 0; i < pPolyIn->getSize(); i++) { int rank = pPolyIn->get(i)->getRank(); int iNewRank = rank; // Reduce the rank of output polynom if the last ranks are null for (int j = rank ; j > 0 ; j--) { if (pPolyIn->get(i)->getImg()[j] == 0.0) { iNewRank--; } else { break; } } double* dataReal = NULL; types::SinglePoly* pSP = new types::SinglePoly(&dataReal, iNewRank); for (int j = 0; j < iNewRank + 1; j++) { dataReal[j] = pPolyIn->get(i)->getImg()[j]; } pPolyOut->set(i, pSP); delete pSP; pSP = NULL; } } else { int iSize = pPolyIn->getSize(); int* piRanks = new int[iSize]; memset(piRanks, 0x00, iSize * sizeof(int)); pPolyOut = new types::Polynom(pPolyIn->getVariableName(), pPolyIn->getDims(), pPolyIn->getDimsArray(), piRanks); pPolyOut->setZeros(); delete[] piRanks; } out.push_back(pPolyOut); } else { ast::ExecVisitor exec; std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_imag"; return Overload::call(wstFuncName, in, _iRetCount, out, &exec); } return types::Function::OK; }
/*--------------------------------------------------------------------------*/ Function::ReturnValue sci_testAnalysis(types::typed_list &in, int _iRetCount, types::typed_list &out) { if (in.size() == 0) { Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), "testAnalysis", 1); return Function::Error; } // check that arguments are a string unsigned int i = 1; Location loc; ast::exps_t * args = new exps_t(); args->reserve(in.size() - 1); for (const auto arg : in) { if (!arg->isString() || arg->getAs<types::String>()->getSize() != 1) { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "testAnalysis", i); return Function::Error; } if (i > 1) { symbol::Symbol sym(arg->getAs<types::String>()->get(0)); args->emplace_back(new ast::SimpleVar(loc, sym)); } ++i; } symbol::Symbol sym(in[0]->getAs<types::String>()->get(0)); ast::SimpleVar * var = new ast::SimpleVar(loc, sym); ast::CallExp ce(loc, *var, *args); analysis::AnalysisVisitor analysis; ce.accept(analysis); //analysis.print_info(); analysis::TIType & t = analysis.getResult().getType(); Struct * pOut = new Struct(1, 1); pOut->addField(L"type"); pOut->get(0)->set(L"type", new String(analysis::TIType::toString(t.type).c_str())); pOut->addField(L"rows"); if (t.rows.isConstant()) { pOut->get(0)->set(L"rows", new Double(t.rows.getConstant())); } else { pOut->get(0)->set(L"rows", new Double(analysis::tools::NaN())); } pOut->addField(L"cols"); if (t.cols.isConstant()) { pOut->get(0)->set(L"cols", new Double(t.cols.getConstant())); } else { pOut->get(0)->set(L"cols", new Double(analysis::tools::NaN())); } out.push_back(pOut); //ast::DebugVisitor debugMe; //pExp->accept(debugMe); //ast::PrintVisitor printMe(std::wcout); //pExp->accept(printMe); return Function::OK; }
/*--------------------------------------------------------------------------*/ types::Function::ReturnValue sci_slint(types::typed_list & in, int _iRetCount, types::typed_list & out) { slint::SLintResult * results = nullptr; bool printResults = false; const int size = (int)in.size(); types::String * conf = nullptr; types::String * outFile = nullptr; if (size == 0 || size >= 4) { Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), "slint", 1); return types::Function::Error; } if (!in[0]->isString()) { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "slint", 1); return types::Function::Error; } switch (size) { case 1: { printResults = true; break; } case 2: { if (in[1]->isBool()) { if (in[1]->getAs<types::Bool>()->getSize() == 1) { printResults = in[1]->getAs<types::Bool>()->get(0) == 0 ? false : true; } else { Scierror(999, _("%s: Wrong type for input argument #%d: A single boolean expected.\n"), "slint", 2); return types::Function::Error; } } else if (in[1]->isString()) { outFile = in[1]->getAs<types::String>(); } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a boolean expected.\n"), "slint", 2); return types::Function::Error; } break; } case 3: { if (in[2]->isBool()) { if (in[2]->getAs<types::Bool>()->getSize() == 1) { printResults = in[2]->getAs<types::Bool>()->get(0) == 0 ? false : true; } else { Scierror(999, _("%s: Wrong type for input argument #%d: A single boolean expected.\n"), "slint", 3); return types::Function::Error; } } else if (in[2]->isString()) { outFile = in[2]->getAs<types::String>(); } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a boolean expected.\n"), "slint", 3); return types::Function::Error; } if (!in[1]->isString()) { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "slint", 3); return types::Function::Error; } conf = in[1]->getAs<types::String>(); break; } } try { slint::SLintOptions options; if (conf) { if (conf->getSize() == 1) { slint::XMLConfig::getOptions(conf->get(0), options); } else { slint::XMLConfig::getOptions(*conf, options); } } else { slint::XMLConfig::getOptions(L"SCI/modules/slint/etc/slint.xml", options); } if (outFile) { if (conf && conf->getSize() >= 2 && (std::wstring(conf->get(0)) == L"cnes")) { const slint::CNES::ToolConfiguration tc = slint::CNES::ToolConfiguration::createFromXml(conf->get(1)); const std::wstring out(outFile->get(0)); const std::size_t pos = out.find_last_of(L'.'); if (pos != std::string::npos && out.substr(pos) == L".csv") { results = new slint::CNES::CNESCsvResult(tc, conf, options.getId(), outFile->get(0)); } else { results = new slint::CNES::CNESXmlResult(tc, conf, options.getId(), outFile->get(0)); } } else { results = new slint::SLintXmlResult(outFile->get(0)); } } else { if (printResults) { results = new slint::SLintScilabResult(); } else { results = new slint::SLintScilabOut(); } } slint::SLint slint(options, *results); slint.setFiles(in[0]->getAs<types::String>()); slint.check(); results->finalize(); if (!outFile && !printResults) { out.emplace_back(static_cast<slint::SLintScilabOut *>(results)->getStruct()); } } catch (slint::PCREException & e) { delete results; Scierror(999, _("%s: %s\n"), "slint", e.what(), 1); return types::Function::Error; } catch (slint::FileException & e) { delete results; Scierror(999, _("%s: %s\n"), "slint", e.what(), 1); return types::Function::Error; } catch (slint::SLintXMLException & e) { delete results; Scierror(999, _("%s: %s\n"), "slint", e.what(), 1); return types::Function::Error; } delete results; if (contributionMsg) { sciprint("%s\n", _("Module developed with the contribution of CNES.")); contributionMsg = false; } return types::Function::OK; }