/*--------------------------------------------------------------------------*/ int sci_legendre(char *fname, unsigned long fname_len) { /* * Interface onto the (Slatec) dxleg.f code. * Scilab calling sequence : * * p = legendre(n, m, x [, norm_flag] ) * * x is a vector with mnx elements (it is better to * have a row vector but this is not forced) * * n : a non negative int scalar (or a vector of such * int regularly speced with an increment of 1) * m : same constraints than for n * * n and m may not be both vectors * * norm_flag : optionnal. When it is present and equal to "norm" * it is a normalised version which is computed * AUTHOR * Bruno Pincon <*****@*****.**> */ int it = 0, lc = 0, mM = 0, nM = 0, m1 = 0, m2 = 0, mN = 0, nN = 0; int n1 = 0, n2 = 0, mx = 0, nx = 0, mnx = 0, ms = 0, ns = 0; int M_is_scalar = 0, N_is_scalar = 0, normalised = 0, MNp1 = 0, *ipqa = NULL; double xx = 0., dnu1 = 0.; int id = 0, ierror = 0, i = 0, j = 0, nudiff = 0; SciErr sciErr; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr4 = NULL; int nbInputArg = nbInputArgument(pvApiCtx); double* pdblN = NULL; double* pdblM = NULL; double* pdblX = NULL; double* pdblPQA = NULL; int* piPQA = NULL; CheckInputArgument(pvApiCtx, 3, 4); CheckOutputArgument(pvApiCtx, 1, 1); /* get N */ //get variable address of the input argument sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &mN, &nN, &pdblN); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (verify_cstr(pdblN, mN * nN, &n1, &n2) == 0) { Scierror(999, _("%s: Wrong type for first input argument.\n"), fname); return 1; } if ( mN == 1 && nN == 1) { N_is_scalar = 1; } /* get M */ //get variable address of the input argument sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &mM, &nM, &pdblM); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (verify_cstr(pdblM, mM * nM, &m1, &m2) == 0) { Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 2); return 1; } if ( mM == 1 && nM == 1) { M_is_scalar = 1; } if ( ! M_is_scalar && ! N_is_scalar ) { Scierror(999, _("%s: Only one of arg1 and arg2 may be a vector.\n"), fname); return 1; } /* get X */ //get variable address of the input argument sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (isVarComplex(pvApiCtx, piAddr3)) { Scierror(999, _("%s: Wrong type for input argument #%d: No complex input argument expected.\n"), fname, 3); return 1; } sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &mx, &nx, &pdblX); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } mnx = mx * nx; for ( i = 0 ; i < mnx ; i++ ) { if ((fabs(pdblX[i]) < 1.0) == 0) { Scierror(999, _("%s: Wrong value for input argument #%d: Matrix with elements in (%d,%d) expected.\n"), fname, 3, -1, 1); return 1; } } if ( nbInputArg == 4 ) { //get variable address int iRet = 0; char* lschar = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a single string at position 4 iRet = getAllocatedSingleString(pvApiCtx, piAddr4, &lschar); if (iRet) { freeAllocatedSingleString(lschar); return iRet; } if ( strcmp(lschar, "norm") == 0) { normalised = 1; } else { normalised = 0; } } else { normalised = 0; } MNp1 = Max (n2 - n1, m2 - m1) + 1; allocMatrixOfDouble(pvApiCtx, nbInputArg + 1, MNp1, mnx, &pdblPQA); piPQA = (int*)MALLOC(MNp1 * mnx * sizeof(int)); if ( normalised ) { id = 4; } else { id = 3; } nudiff = n2 - n1; dnu1 = (double) n1; for ( i = 0 ; i < mnx ; i++ ) { xx = fabs(pdblX[i]); /* dxleg computes only for x in [0,1) */ C2F(dxlegf) (&dnu1, &nudiff, &m1, &m2, &xx, &id, pdblPQA + i * MNp1, piPQA + i * MNp1, &ierror); if ( ierror != 0 ) { if ( ierror == 207 ) /* @TODO what is 207 ? */ { Scierror(999, _("%s: overflow or underflow of an extended range number\n"), fname); } else { Scierror(999, _("%s: error number %d\n"), fname, ierror); } return 0; } } /* dxlegf returns the result under a form (pqa,ipqa) (to * compute internaly with an extended exponent range) * When the "exponent" part (ipqa) is 0 then the number is exactly * given by pqa else it leads to an overflow or an underflow. */ for ( i = 0 ; i < mnx * MNp1 ; i++ ) { if ( piPQA[i] < 0 ) { pdblPQA[i] = 0.0; } if ( piPQA[i] > 0 ) { pdblPQA[i] = pdblPQA[i] * return_an_inf(); /* pqa[i] * Inf to have the sign */ } } FREE(piPQA); /* complete the result by odd/even symmetry for negative x */ for ( i = 0 ; i < mnx ; i++ ) { if ( pdblX[i] < 0.0 ) { if ( (n1 + m1) % 2 == 1 ) { for ( j = 0 ; j < MNp1 ; j += 2 ) { pdblPQA[i * MNp1 + j] = -pdblPQA[i * MNp1 + j]; } } else { for ( j = 1 ; j < MNp1 ; j += 2 ) { pdblPQA[i * MNp1 + j] = -pdblPQA[i * MNp1 + j]; } } } } AssignOutputVariable(pvApiCtx, 1) = nbInputArg + 1; ReturnArguments(pvApiCtx); return 0; }
int sci_listvar_in_hdf5_v1(char *fname, int* pvCtx) { SciErr sciErr; int *piAddr = NULL; char* pstFile = NULL; int iFile = 0; int iNbItem = 0; VarInfo_v1* pInfo = NULL; CheckInputArgument(pvCtx, 1, 1); CheckOutputArgument(pvCtx, 1, 4); sciErr = getVarAddressFromPosition(pvCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (getAllocatedSingleString(pvCtx, piAddr, &pstFile)) { if (pstFile) { FREE(pstFile); } Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1); return 1; } char* pstFileName = expandPathVariable(pstFile); iFile = openHDF5File(pstFileName, 0); if (iFile < 0) { FREE(pstFileName); Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile); FREE(pstFile); return 1; } FREE(pstFileName); FREE(pstFile); iNbItem = getVariableNames_v1(iFile, NULL); if (iNbItem != 0) { char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem); bool b; pInfo = (VarInfo_v1*)MALLOC(iNbItem * sizeof(VarInfo_v1)); if (nbOutputArgument(pvCtx) == 1) { sciprint("Name Type Size Bytes\n"); sciprint("---------------------------------------------------------------\n"); } iNbItem = getVariableNames_v1(iFile, pstVarNameList); for (int i = 0; i < iNbItem; i++) { int iDataSetId = getDataSetIdFromName_v1(iFile, pstVarNameList[i]); if (iDataSetId == 0) { break; } strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName)); b = read_data_v1(pvCtx, iDataSetId, 0, NULL, &pInfo[i]) == false; closeDataSet_v1(iDataSetId); if (b) { break; } if (nbOutputArgument(pvCtx) == 1) { sciprint("%s\n", pInfo[i].pstInfo); } } freeArrayOfString(pstVarNameList, iNbItem); } else { //no variable returms [] for each Lhs for (int i = 0 ; i < nbOutputArgument(pvCtx) ; i++) { createEmptyMatrix(pvCtx, nbInputArgument(pvCtx) + i + 1); AssignOutputVariable(pvCtx, i + 1) = nbInputArgument(pvCtx) + i + 1; } ReturnArguments(pvCtx); return 0; } closeHDF5File(iFile); //1st Lhs char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem); for (int i = 0 ; i < iNbItem ; i++) { pstVarName[i] = pInfo[i].varName; } sciErr = createMatrixOfString(pvCtx, nbInputArgument(pvCtx) + 1, iNbItem, 1, pstVarName); FREE(pstVarName); if (sciErr.iErr) { FREE(pInfo); printError(&sciErr, 0); return 1; } AssignOutputVariable(pvCtx, 1) = nbInputArgument(pvCtx) + 1; if (nbOutputArgument(pvCtx) > 1) { //2nd Lhs double* pdblType; sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 2, iNbItem, 1, &pdblType); if (sciErr.iErr) { FREE(pInfo); printError(&sciErr, 0); return 1; } for (int i = 0 ; i < iNbItem ; i++) { pdblType[i] = pInfo[i].iType; } AssignOutputVariable(pvCtx, 2) = nbInputArgument(pvCtx) + 2; if (nbOutputArgument(pvCtx) > 2) { //3rd Lhs int* pList = NULL; sciErr = createList(pvCtx, nbInputArgument(pvCtx) + 3, iNbItem, &pList); for (int i = 0 ; i < iNbItem ; i++) { double* pdblDims = NULL; allocMatrixOfDoubleInList(pvCtx, nbInputArgument(pvCtx) + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims); for (int j = 0 ; j < pInfo[i].iDims ; j++) { pdblDims[j] = pInfo[i].piDims[j]; } } AssignOutputVariable(pvCtx, 3) = nbInputArgument(pvCtx) + 3; } if (nbOutputArgument(pvCtx) > 3) { //4th Lhs double* pdblSize; sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 4, iNbItem, 1, &pdblSize); for (int i = 0 ; i < iNbItem ; i++) { pdblSize[i] = pInfo[i].iSize; } AssignOutputVariable(pvCtx, 4) = nbInputArgument(pvCtx) + 4; } } FREE(pInfo); ReturnArguments(pvCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_xchange(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl3 = NULL; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddrl1 = NULL; int* piAddrl2 = NULL; char* l3Input = NULL; double* l5 = NULL; int m1 = 0, n1 = 0, m2 = 0, n2 = 0; int four = VIEWING_RECT_SIZE; int one = 1; int * xPixCoords = NULL; int * yPixCoords = NULL; double* xCoords = NULL; double* yCoords = NULL; int viewingRect[VIEWING_RECT_SIZE]; CheckInputArgument(pvApiCtx, 3, 3); CheckOutputArgument(pvApiCtx, 1, 3); sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. if (getAllocatedSingleString(pvApiCtx, piAddrl3, &l3Input)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 3); return 1; } /* Convert coordinates */ if (strcmp(l3Input, "i2f") == 0) { int* l1 = NULL; int* l2 = NULL; double* l3 = NULL; double* l4 = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr2, &m2, &n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2); return 1; } //CheckSameDims if (m1 != m2 || n1 != n2) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m1, n1, &l4); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* Get rectangle */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, one, four, &l5); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } xPixCoords = (int*)(l1); yPixCoords = (int*)(l2); xCoords = (l3); yCoords = (l4); convertPixelCoordsToUserCoords(xPixCoords, yPixCoords, xCoords, yCoords, m1 * n1, viewingRect); } else { double* l1 = NULL; double* l2 = NULL; int* l3 = NULL; int* l4 = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2); return 1; } //CheckSameDims if (m1 != m2 || n1 != n2) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m1, n1, &l4); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* Get rectangle */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, one, four, &l5); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } xCoords = (l1); yCoords = (l2); xPixCoords = (int*)(l3); yPixCoords = (int*)(l4); convertUserCoordToPixelCoords(xCoords, yCoords, xPixCoords, yPixCoords, m1 * n1, viewingRect); } l5[0] = viewingRect[0]; l5[1] = viewingRect[1]; l5[2] = viewingRect[2]; l5[3] = viewingRect[3]; freeAllocatedSingleString(l3Input); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_x_choose_modeless(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddritemsAdr = NULL; int* piAddrmessageAdr = NULL; int* piAddrbuttonLabelAdr = NULL; double* userValueAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowItems = 0, nbColItems = 0; int messageBoxID = 0; char **itemsAdr = NULL; char **buttonLabelAdr = NULL; char **messageAdr = NULL; int userValue = 0; CheckInputArgument(pvApiCtx, 2, 3); CheckOutputArgument(pvApiCtx, 0, 1); if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddritemsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddritemsAdr, &nbRowItems, &nbColItems, &itemsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRow, &nbCol, &messageAdr)) { freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } } else { freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Choose Message")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbCol * nbRow); /* ListBox Items */ setMessageBoxListBoxItems(messageBoxID, itemsAdr, nbColItems * nbRowItems); /* Modality */ setMessageBoxModal(messageBoxID, FALSE); freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr); freeAllocatedMatrixOfString(nbRow, nbCol, messageAdr); if (nbInputArgument(pvApiCtx) == 3) { if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrbuttonLabelAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonLabelAdr, &nbRow, &nbCol, &buttonLabelAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow*nbCol != 1) { freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr); Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3); return FALSE; } setMessageBoxButtonsLabels(messageBoxID, buttonLabelAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValue = getMessageBoxSelectedItem(messageBoxID); nbRow = 1; nbCol = 1; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &userValueAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } *userValueAdr = userValue; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
int sci_umf_lusolve(char* fname, unsigned long l) { SciErr sciErr; int mb = 0; int nb = 0; int it_flag = 0; int i = 0; int j = 0; int NoTranspose = 0; int NoRaffinement = 0; SciSparse AA; CcsSparse A; /* umfpack stuff */ double Info[UMFPACK_INFO]; // double *Info = (double *) NULL; double Control[UMFPACK_CONTROL]; void* Numeric = NULL; int lnz = 0, unz = 0, n = 0, n_col = 0, nz_udiag = 0, umf_flag = 0; int* Wi = NULL; int mW = 0; double *W = NULL; int iComplex = 0; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr4 = NULL; double* pdblBR = NULL; double* pdblBI = NULL; double* pdblXR = NULL; double* pdblXI = NULL; int mA = 0; // rows int nA = 0; // cols int iNbItem = 0; int* piNbItemRow = NULL; int* piColPos = NULL; double* pdblSpReal = NULL; double* pdblSpImg = NULL; /* Check numbers of input/output arguments */ CheckInputArgument(pvApiCtx, 2, 4); CheckOutputArgument(pvApiCtx, 1, 1); /* First get arg #1 : the pointer to the LU factors */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getPointer(pvApiCtx, piAddr1, &Numeric); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } /* Check if this pointer is a valid ref to a umfpack LU numeric object */ if ( ! IsAdrInList(Numeric, ListNumeric, &it_flag) ) { Scierror(999, _("%s: Wrong value for input argument #%d: Must be a valid reference to (umf) LU factors.\n"), fname, 1); return 1; } /* get some parameters of the factorization (for some checking) */ if ( it_flag == 0 ) { umfpack_di_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric); } else { iComplex = 1; umfpack_zi_get_lunz(&lnz, &unz, &n, &n_col, &nz_udiag, Numeric); } if ( n != n_col ) { Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("This is not a factorization of a square matrix")); return 1; } if ( nz_udiag < n ) { Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("This is a factorization of a singular matrix")); return 1; } /* Get now arg #2 : the vector b */ sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (isVarComplex(pvApiCtx, piAddr2)) { iComplex = 1; sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr2, &mb, &nb, &pdblBR, &pdblBI); } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &mb, &nb, &pdblBR); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (mb != n || nb < 1) /* test if the right hand side is compatible */ { Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2); return 1; } /* allocate memory for the solution x */ if (iComplex) { sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, mb, nb, &pdblXR, &pdblXI); } else { sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, mb, nb, &pdblXR); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } /* selection between the different options : * -- solving Ax=b or A'x=b (Note: we could add A.'x=b) * -- with or without raffinement */ if (nbInputArgument(pvApiCtx) == 2) { NoTranspose = 1; NoRaffinement = 1; } else /* 3 or 4 input arguments but the third must be a string */ { char* pStr = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } getAllocatedSingleString(pvApiCtx, piAddr3, &pStr); if (strcmp(pStr, "Ax=b") == 0) { NoTranspose = 1; } else if ( strcmp(pStr, "A'x=b") == 0 ) { NoTranspose = 0; } else { Scierror(999, _("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"), fname, 3, "Ax=b", "A'x=b"); return 1; } if (nbInputArgument(pvApiCtx) == 4) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (isVarComplex(pvApiCtx, piAddr4)) { AA.it = 1; sciErr = getComplexSparseMatrix(pvApiCtx, piAddr4, &mA, &nA, &iNbItem, &piNbItemRow, &piColPos, &pdblSpReal, &pdblSpImg); } else { AA.it = 0; sciErr = getSparseMatrix(pvApiCtx, piAddr4, &mA, &nA, &iNbItem, &piNbItemRow, &piColPos, &pdblSpReal); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // fill struct sparse AA.m = mA; AA.n = nA; AA.nel = iNbItem; AA.mnel = piNbItemRow; AA.icol = piColPos; AA.R = pdblSpReal; AA.I = pdblSpImg; /* some check... but we can't be sure that the matrix corresponds to the LU factors */ if ( mA != nA || mA != n || AA.it != it_flag ) { Scierror(999, _("%s: Wrong size for input argument #%d: %s.\n"), fname, 4, _("Matrix is not compatible with the given LU factors")); return 1; } NoRaffinement = 0; } else { NoRaffinement = 1; /* only 3 input var => no raffinement */ } } /* allocate memory for umfpack_di_wsolve usage or umfpack_zi_wsolve usage*/ Wi = (int*)MALLOC(n * sizeof(int)); if (it_flag == 1) { if (NoRaffinement) { mW = 4 * n; } else { mW = 10 * n; } } else { if (NoRaffinement) { mW = n; } else { mW = 5 * n; } } W = (double*)MALLOC(mW * sizeof(double)); if (NoRaffinement == 0) { SciSparseToCcsSparse(&AA, &A); } else { A.p = NULL; A.irow = NULL; A.R = NULL; A.I = NULL; } /* get the pointer for b */ if (it_flag == 1 && pdblBI == NULL) { int iSize = mb * nb * sizeof(double); pdblBI = (double*)MALLOC(iSize); memset(pdblBI, 0x00, iSize); } /* init Control */ if (it_flag == 0) { umfpack_di_defaults(Control); } else { umfpack_zi_defaults(Control); } if (NoRaffinement) { Control[UMFPACK_IRSTEP] = 0; } if (NoTranspose) { umf_flag = UMFPACK_A; } else { umf_flag = UMFPACK_At; } if (it_flag == 0) { for (j = 0; j < nb ; j++) { umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &pdblXR[j * mb], &pdblBR[j * mb], Numeric, Control, Info, Wi, W); } if (iComplex == 1) { for (j = 0; j < nb ; j++) { umfpack_di_wsolve(umf_flag, A.p, A.irow, A.R, &pdblXI[j * mb], &pdblBI[j * mb], Numeric, Control, Info, Wi, W); } } } else { for (j = 0; j < nb ; j++) { umfpack_zi_wsolve(umf_flag, A.p, A.irow, A.R, A.I, &pdblXR[j * mb], &pdblXI[j * mb], &pdblBR[j * mb], &pdblBI[j * mb], Numeric, Control, Info, Wi, W); } } if (isVarComplex(pvApiCtx, piAddr2) == 0) { FREE(pdblBI); } freeCcsSparse(A); FREE(W); FREE(Wi); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_messagebox(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrmessageAdr = NULL; int* piAddrtitleAdr = NULL; int* piAddriconAdr = NULL; int* piAddrbuttonsTextAdr = NULL; int* piAddrmodalOptionAdr = NULL; double* buttonNumberAdr = NULL; int messageBoxID = 0; /* Used to read input arguments */ int nbRow = 0, nbCol = 0; int nbRowButtons = 0, nbColButtons = 0; int nbRowMessage = 0, nbColMessage = 0; char **buttonsTextAdr = 0; char **messageAdr = 0; char **titleAdr = 0; char **modalOptionAdr = 0; char **iconAdr = 0; /* Used to write output argument */ int buttonNumber = 0; CheckInputArgument(pvApiCtx, 1, 5); CheckOutputArgument(pvApiCtx, 0, 1); /* Message to be displayed */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return FALSE; } /* Title to be displayed */ if (nbInputArgument(pvApiCtx) >= 2) { if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrtitleAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrtitleAdr, &nbRow, &nbCol, &titleAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } /* The title argument can be used to give the modal option */ if (isModalOption(titleAdr[0])) { modalOptionAdr = titleAdr; titleAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } } /* Icon to be displayed */ if (nbInputArgument(pvApiCtx) >= 3) { if ((checkInputArgumentType(pvApiCtx, 3, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddriconAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddriconAdr, &nbRow, &nbCol, &iconAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow*nbCol == 1) { /* The icon argument can be used to give the modal option or the buttons names */ if (isModalOption(iconAdr[0])) { modalOptionAdr = (char **)iconAdr; iconAdr = NULL; } else if (!isIconName(iconAdr[0])) { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else /* More than one string --> buttons names */ { buttonsTextAdr = (char **)iconAdr; nbRowButtons = nbRow; nbColButtons = nbCol; iconAdr = NULL; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a string vector expected.\n"), fname, 3); return FALSE; } } /* Buttons names */ if (nbInputArgument(pvApiCtx) >= 4) { if ((checkInputArgumentType(pvApiCtx, 4, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrbuttonsTextAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 4. if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonsTextAdr, &nbRowButtons, &nbColButtons, &buttonsTextAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 4); return 1; } if (nbRow*nbCol == 1) { /* The buttons names argument can be used to give the modal option */ if (isModalOption(buttonsTextAdr[0])) { modalOptionAdr = buttonsTextAdr; buttonsTextAdr = NULL; } } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string or a string vector expected.\n"), fname, 3); return FALSE; } } /* Modal option */ if (nbInputArgument(pvApiCtx) == 5) { if ((checkInputArgumentType(pvApiCtx, 5, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrmodalOptionAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 5. if (getAllocatedMatrixOfString(pvApiCtx, piAddrmodalOptionAdr, &nbRow, &nbCol, &modalOptionAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 5); return 1; } if (nbRow*nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 5); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 5); return FALSE; } } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbColMessage * nbRowMessage); freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr); /* Title */ if (titleAdr != NULL) { setMessageBoxTitle(messageBoxID, titleAdr[0]); freeAllocatedMatrixOfString(nbRow, nbCol, titleAdr); } else { setMessageBoxTitle(messageBoxID, _("Scilab Message")); } /* Icon */ if (iconAdr != NULL) { setMessageBoxIcon(messageBoxID, iconAdr[0]); freeAllocatedMatrixOfString(nbRow, nbCol, iconAdr); } /* Buttons */ if (buttonsTextAdr != NULL) { setMessageBoxButtonsLabels(messageBoxID, buttonsTextAdr, nbColButtons * nbRowButtons); freeAllocatedMatrixOfString(nbRowButtons, nbColButtons, buttonsTextAdr); } /* Modal ? */ if (modalOptionAdr != NULL) { setMessageBoxModal(messageBoxID, !stricmp(modalOptionAdr[0], "modal")); freeAllocatedMatrixOfString(nbRow, nbCol, modalOptionAdr); } else { setMessageBoxModal(messageBoxID, FALSE); } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Return the index of the button selected */ if (nbOutputArgument(pvApiCtx) == 1) { /* Read the user answer */ buttonNumber = getMessageBoxSelectedButton(messageBoxID); nbRow = 1; nbCol = 1; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &buttonNumberAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } buttonNumberAdr[0] = buttonNumber; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; } else { AssignOutputVariable(pvApiCtx, 1) = 0; } ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_x_mdialog(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddrlabelsAdr = NULL; int* piAddrlineLabelsAdr = NULL; int* piAddrdefaultValuesAdr = NULL; int* piAddrcolumnLabelsAdr = NULL; double* emptyMatrixAdr = NULL; int nbRow = 0, nbCol = 0; int nbRowDefaultValues = 0, nbColDefaultValues = 0; int nbRowLineLabels = 0, nbColLineLabels = 0; int nbRowColumnLabels = 0, nbColColumnLabels = 0; int messageBoxID = 0; char **labelsAdr = NULL; char **lineLabelsAdr = NULL; char **columnLabelsAdr = NULL; char **defaultValuesAdr = NULL; int userValueSize = 0; char **userValue = NULL; CheckInputArgument(pvApiCtx, 3, 4); CheckOutputArgument(pvApiCtx, 0, 1); /* READ THE LABELS */ if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1); return FALSE; } /* Create the Java Object */ messageBoxID = createMessageBox(); /* Title is a default title */ setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request")); /* Message */ setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow); freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr); /* READ THE LINE LABELS */ if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (nbRowLineLabels != 1 && nbColLineLabels != 1) { freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels); freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2); return FALSE; } /* READ THE COLUMN LABELS or DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 3, sci_strings)) { if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels)) { freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions as argument #%d.\n"), fname, 3, 2); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr); } else { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3); return 1; } if (nbRowColumnLabels != 1 && nbColColumnLabels != 1) { freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels); freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr); } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3); return FALSE; } if (nbInputArgument(pvApiCtx) == 4) { /* READ DEFAULT VALUES */ if (checkInputArgumentType(pvApiCtx, 4, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 4. // DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr). if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4); return 1; } if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels)) { Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); return FALSE; } setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues); } else { Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 4); return FALSE; } } /* Display it and wait for a user input */ messageBoxDisplayAndWait(messageBoxID); /* Read the user answer */ userValueSize = getMessageBoxValueSize(messageBoxID); if (userValueSize == 0) { nbRow = 0; nbCol = 0; // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr". sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else { userValue = getMessageBoxValue(messageBoxID); nbCol = 1; nbRowDefaultValues = nbColLineLabels * nbRowLineLabels; nbColDefaultValues = 1; if (nbInputArgument(pvApiCtx) == 4) { nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels; } createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValue); delete[] userValue; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_xgraduate(char *fname, void *pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; double* lr = NULL; double xa = 0., xi = 0.; int m1 = 0, n1 = 0, m2 = 0, n2 = 0, i = 0; int kMinr = 0, kMaxr = 0, ar = 0, np1 = 0, np2 = 0, un = 1; CheckInputArgument(pvApiCtx, 2, 2); CheckOutputArgument(pvApiCtx, 2, 7); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } //CheckScalar if (m1 != 1 || n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 1); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); return 1; } //CheckScalar if (m2 != 1 || n2 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2); return 1; } C2F(graduate)((l1), (l2), &xi, &xa, &np1, &np2, &kMinr, &kMaxr, &ar); *l1 = xi; *l2 = xa; if (nbOutputArgument(pvApiCtx) >= 3) { sciErr = allocMatrixOfDouble(pvApiCtx, 3, un, un, &lr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lr[0] = (double) np1; } if (nbOutputArgument(pvApiCtx) >= 4) { sciErr = allocMatrixOfDouble(pvApiCtx, 4, un, un, &lr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lr[0] = (double) np2; } if (nbOutputArgument(pvApiCtx) >= 5) { sciErr = allocMatrixOfDouble(pvApiCtx, 5, un, un, &lr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lr[0] = (double) kMinr; } if (nbOutputArgument(pvApiCtx) >= 6) { sciErr = allocMatrixOfDouble(pvApiCtx, 6, un, un, &lr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lr[0] = (double) kMaxr; } if (nbOutputArgument(pvApiCtx) >= 7) { sciErr = allocMatrixOfDouble(pvApiCtx, 7, un, un, &lr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lr[0] = (double) ar; } for (i = 1; i <= nbOutputArgument(pvApiCtx) ; i++) { AssignOutputVariable(pvApiCtx, i) = i; } ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_getcallbackobject(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrpObjUID = NULL; int nbRow = 0; int nbCol = 0; char** pObjUID = NULL; unsigned long graphicHandle = 0; CheckInputArgument(pvApiCtx, 1, 1); CheckOutputArgument(pvApiCtx, 0, 1); if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpObjUID); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrpObjUID, &nbRow, &nbCol, &pObjUID)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } if (nbCol != 1 || nbRow == 0) { Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1); return FALSE; } graphicHandle = getHandle(pObjUID[0]); freeAllocatedMatrixOfString(nbRow, nbCol, pObjUID); /* Create return variable */ if (graphicHandle == 0) /* Non-existing object --> return [] */ { double* stkAdr = NULL; nbRow = 0; nbCol = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } } else /* Return the handle */ { long long* stkAdr = NULL; nbRow = 1; nbCol = 1; sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } *stkAdr = (long long)graphicHandle; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; }
int sci_umfpack(char* fname, void* pvApiCtx) { SciErr sciErr; int mb = 0; int nb = 0; int i = 0; int num_A = 0; int num_b = 0; int mW = 0; int Case = 0; int stat = 0; SciSparse AA; CcsSparse A; int* piAddrA = NULL; int* piAddr2 = NULL; int* piAddrB = NULL; double* pdblBR = NULL; double* pdblBI = NULL; double* pdblXR = NULL; double* pdblXI = NULL; int iComplex = 0; int mA = 0; // rows int nA = 0; // cols int iNbItem = 0; int* piNbItemRow = NULL; int* piColPos = NULL; double* pdblSpReal = NULL; double* pdblSpImg = NULL; /* umfpack stuff */ double Info[UMFPACK_INFO]; double* Control = NULL; void* Symbolic = NULL; void* Numeric = NULL; int* Wi = NULL; double* W = NULL; char* pStr = NULL; int iType2 = 0; int iTypeA = 0; int iTypeB = 0; /* Check numbers of input/output arguments */ CheckInputArgument(pvApiCtx, 3, 3); CheckOutputArgument(pvApiCtx, 1, 1); /* First get arg #2 : a string of length 1 */ sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddr2, &iType2); if (sciErr.iErr || iType2 != sci_strings) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return 1; } getAllocatedSingleString(pvApiCtx, piAddr2, &pStr); /* select Case 1 or 2 depending (of the first char of) the string ... */ if (pStr[0] == '\\') // compare pStr[0] with '\' { Case = 1; num_A = 1; num_b = 3; } else if (pStr[0] == '/') { Case = 2; num_A = 3; num_b = 1; } else { Scierror(999, _("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "\\", "/"); FREE(pStr); return 1; } FREE(pStr); /* get A */ sciErr = getVarAddressFromPosition(pvApiCtx, num_A, &piAddrA); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddrA, &iTypeA); if (sciErr.iErr || iTypeA != sci_sparse) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), fname, 1); return 1; } if (isVarComplex(pvApiCtx, piAddrA)) { AA.it = 1; iComplex = 1; sciErr = getComplexSparseMatrix(pvApiCtx, piAddrA, &mA, &nA, &iNbItem, &piNbItemRow, &piColPos, &pdblSpReal, &pdblSpImg); } else { AA.it = 0; sciErr = getSparseMatrix(pvApiCtx, piAddrA, &mA, &nA, &iNbItem, &piNbItemRow, &piColPos, &pdblSpReal); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // fill struct sparse AA.m = mA; AA.n = nA; AA.nel = iNbItem; AA.mnel = piNbItemRow; AA.icol = piColPos; AA.R = pdblSpReal; AA.I = pdblSpImg; if ( mA != nA || mA < 1 ) { Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, num_A); return 1; } /* get B*/ sciErr = getVarAddressFromPosition(pvApiCtx, num_b, &piAddrB); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } sciErr = getVarType(pvApiCtx, piAddrB, &iTypeB); if (sciErr.iErr || iTypeB != sci_matrix) { printError(&sciErr, 0); Scierror(999, _("%s: Wrong type for input argument #%d: A matrix expected.\n"), fname, 3); return 1; } if (isVarComplex(pvApiCtx, piAddrB)) { iComplex = 1; sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddrB, &mb, &nb, &pdblBR, &pdblBI); } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddrB, &mb, &nb, &pdblBR); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if ( (Case == 1 && ( mb != mA || nb < 1 )) || (Case == 2 && ( nb != mA || mb < 1 )) ) { Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, num_b); return 1; } SciSparseToCcsSparse(&AA, &A); /* allocate memory for the solution x */ if (iComplex) { sciErr = allocComplexMatrixOfDouble(pvApiCtx, 4, mb, nb, &pdblXR, &pdblXI); } else { sciErr = allocMatrixOfDouble(pvApiCtx, 4, mb, nb, &pdblXR); } if (sciErr.iErr) { freeCcsSparse(A); printError(&sciErr, 0); return 1; } /* allocate memory for umfpack_di_wsolve usage or umfpack_zi_wsolve usage*/ Wi = (int*)MALLOC(mA * sizeof(int)); if (A.it == 1) { mW = 10 * mA; } else { mW = 5 * mA; } W = (double*)MALLOC(mW * sizeof(double)); if (A.it == 1 && pdblBI == NULL) { int iSize = mb * nb * sizeof(double); pdblBI = (double*)MALLOC(iSize); memset(pdblBI, 0x00, iSize); } /* Now calling umfpack routines */ if (A.it == 1) { stat = umfpack_zi_symbolic(mA, nA, A.p, A.irow, A.R, A.I, &Symbolic, Control, Info); } else { stat = umfpack_di_symbolic(mA, nA, A.p, A.irow, A.R, &Symbolic, Control, Info); } if ( stat != UMFPACK_OK ) { freeCcsSparse(A); Scierror(999, _("%s: An error occurred: %s: %s\n"), fname, _("symbolic factorization"), UmfErrorMes(stat)); return 1; } if (A.it == 1) { stat = umfpack_zi_numeric(A.p, A.irow, A.R, A.I, Symbolic, &Numeric, Control, Info); } else { stat = umfpack_di_numeric(A.p, A.irow, A.R, Symbolic, &Numeric, Control, Info); } if (A.it == 1) { umfpack_zi_free_symbolic(&Symbolic); } else { umfpack_di_free_symbolic(&Symbolic); } if ( stat != UMFPACK_OK ) { if (A.it == 1) { umfpack_zi_free_numeric(&Numeric); } else { umfpack_di_free_numeric(&Numeric); } freeCcsSparse(A); Scierror(999, _("%s: An error occurred: %s: %s\n"), fname, _("numeric factorization"), UmfErrorMes(stat)); return 1; } if ( Case == 1 ) /* x = A\b <=> Ax = b */ { if (A.it == 0) { for ( i = 0 ; i < nb ; i++ ) { umfpack_di_wsolve(UMFPACK_A, A.p, A.irow, A.R, &pdblXR[i * mb], &pdblBR[i * mb], Numeric, Control, Info, Wi, W); } if (isVarComplex(pvApiCtx, piAddrB)) { for ( i = 0 ; i < nb ; i++ ) { umfpack_di_wsolve(UMFPACK_A, A.p, A.irow, A.R, &pdblXI[i * mb], &pdblBI[i * mb], Numeric, Control, Info, Wi, W); } } } else /* A.it == 1 */ { for ( i = 0 ; i < nb ; i++ ) { umfpack_zi_wsolve(UMFPACK_A, A.p, A.irow, A.R, A.I, &pdblXR[i * mb], &pdblXI[i * mb], &pdblBR[i * mb], &pdblBI[i * mb], Numeric, Control, Info, Wi, W); } } } else /* Case == 2, x = b/A <=> x A = b <=> A.'x.' = b.' */ { if (A.it == 0) { TransposeMatrix(pdblBR, mb, nb, pdblXR); /* put b in x (with transposition) */ for ( i = 0 ; i < mb ; i++ ) { umfpack_di_wsolve(UMFPACK_At, A.p, A.irow, A.R, &pdblBR[i * nb], &pdblXR[i * nb], Numeric, Control, Info, Wi, W); /* the solutions are in br */ } TransposeMatrix(pdblBR, nb, mb, pdblXR); /* put now br in xr with transposition */ if (isVarComplex(pvApiCtx, piAddrB)) { TransposeMatrix(pdblBI, mb, nb, pdblXI); /* put b in x (with transposition) */ for ( i = 0 ; i < mb ; i++ ) { umfpack_di_wsolve(UMFPACK_At, A.p, A.irow, A.R, &pdblBI[i * nb], &pdblXI[i * nb], Numeric, Control, Info, Wi, W); /* the solutions are in bi */ } TransposeMatrix(pdblBI, nb, mb, pdblXI); /* put now bi in xi with transposition */ } } else /* A.it==1 */ { TransposeMatrix(pdblBR, mb, nb, pdblXR); TransposeMatrix(pdblBI, mb, nb, pdblXI); for ( i = 0 ; i < mb ; i++ ) { umfpack_zi_wsolve(UMFPACK_Aat, A.p, A.irow, A.R, A.I, &pdblBR[i * nb], &pdblBI[i * nb], &pdblXR[i * nb], &pdblXI[i * nb], Numeric, Control, Info, Wi, W); } TransposeMatrix(pdblBR, nb, mb, pdblXR); TransposeMatrix(pdblBI, nb, mb, pdblXI); } } if (A.it == 1) { umfpack_zi_free_numeric(&Numeric); } else { umfpack_di_free_numeric(&Numeric); } if (piNbItemRow != NULL) { FREE(piNbItemRow); } if (piColPos != NULL) { FREE(piColPos); } if (pdblSpReal != NULL) { FREE(pdblSpReal); } if (pdblSpImg != NULL) { FREE(pdblSpImg); } FREE(W); FREE(Wi); freeCcsSparse(A); AssignOutputVariable(pvApiCtx, 1) = 4; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_ClipBoard(char *fname, void* pvApiCtx) { SciErr sciErr; int* piAddr1 = NULL; int* piAddrl1 = NULL; int* piAddrStr = NULL; double* pdbll1 = NULL; int* pil1 = NULL; static int n1 = 0, m1 = 0; char* param1 = NULL; char* param2 = NULL; nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx)); CheckInputArgument(pvApiCtx, 0, 2); CheckOutputArgument(pvApiCtx, 0, 1); if ( getScilabMode() != SCILAB_NWNI ) { /*--------------------*/ /* clipboard("paste") */ /*--------------------*/ if (nbInputArgument(pvApiCtx) == 1) { if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m1)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } if ( ( strcmp(param1, "paste") == 0 ) || ( strcmp(param1, "pastespecial") == 0 ) ) { /* Use the Java clipboard (CallScilabBridge.java returns "" if clipboard could not be read) */ char *output = getClipboardContents(); m1 = (int)strlen(output); n1 = 1; if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, output)) { freeAllocatedSingleString(param1); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } /* TO DO a delete [] and not a FREE */ FREE(output); AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; freeAllocatedSingleString(param1); ReturnArguments(pvApiCtx); return TRUE; } else { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "paste", "pastespecial"); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1); return FALSE; } } else if (nbInputArgument(pvApiCtx) == 2) { if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) { /* Get the first argument: should be "copy" or "do" */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m1)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1); return 1; } if (( strcmp(param1, "do") != 0 ) && ( strcmp(param1, "copy") != 0 )) { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "do", "copy"); return FALSE; } if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { /*-------------------------------------------*/ /* clipboard("do", {"paste","copy","empty"}) */ /*-------------------------------------------*/ /* @TODO : should be remplaced by an enum */ if ( strcmp(param1, "do") == 0 ) { freeAllocatedSingleString(param1); sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m2)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if ( strcmp(param2, "paste") == 0 ) { /* Call Java to do the job */ pasteClipboardIntoConsole(); } else if ( strcmp(param2, "copy") == 0 ) { /* Call Java to do the job */ copyConsoleSelection(); } else if ( strcmp(param2, "empty") == 0 ) { /* Call Java to do the job */ emptyClipboard(); } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s' or '%s' expected.\n"), fname, 2, "copy", "paste", "empty"); return FALSE; } m1 = 0; n1 = 0; freeAllocatedSingleString(param2); sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } /*-------------------------*/ /* clipboard("copy", data) */ /*-------------------------*/ else if ( strcmp(param1, "copy") == 0 ) { char *TextToPutInClipboard = NULL; char **Str = NULL; int m2 = 0, n2 = 0; freeAllocatedSingleString(param1); sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrStr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m2, &n2, &Str)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if (m2 * n2 == 1) /* Single line copy */ { TextToPutInClipboard = Str[0]; /* Call Java to do the job */ setClipboardContents(TextToPutInClipboard); } else /* Multi-line copy */ { int i = 0, j = 0, l2 = 0; char *TextToSendInClipboard = NULL; int SizeofTextToSendInClipboard = 0; char **buffer = (char**)MALLOC( (m2 * n2) * sizeof(char *) ); if (buffer == NULL) { freeAllocatedMatrixOfString(m2, n2, Str); Scierror(999, _("%s: No more memory.\n"), fname); return FALSE; } for (i = 0; i < m2; i++) { for (j = 0; j < n2; j++) { SizeofTextToSendInClipboard = SizeofTextToSendInClipboard + (int)strlen(Str[j * m2 + i]) + (int)strlen("\n") + (int)strlen(" "); buffer[i * n2 + j] = os_strdup(Str[j * m2 + i]); } } TextToSendInClipboard = (char*)MALLOC( (SizeofTextToSendInClipboard) * sizeof(char) ); if (TextToSendInClipboard == NULL) { freeAllocatedMatrixOfString(m2, n2, Str); Scierror(999, _("%s: No more memory.\n"), fname); freeArrayOfString(buffer, m2 * n2); return FALSE; } strcpy(TextToSendInClipboard, ""); for (i = 0; i < m2; i++) { for (j = 0; j < n2; j++) { strcat(TextToSendInClipboard, buffer[l2++]); strcat(TextToSendInClipboard, " "); } if ( i != (m2 - 1) ) { strcat(TextToSendInClipboard, "\n"); } } /* Call Java to do the job */ setClipboardContents(TextToSendInClipboard); FREE(buffer); buffer = NULL; freeArrayOfString(buffer, m2 * n2); FREE(TextToSendInClipboard); TextToSendInClipboard = NULL; } freeAllocatedMatrixOfString(m2, n2, Str); m1 = 0; n1 = 0; sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } } else { freeAllocatedSingleString(param1); Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } } /*----------------------------------*/ /* clipboard(fignum, {"EMF","DIB"}) */ /*----------------------------------*/ else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { int num_win = -2; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &m1, &n1, &pil1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } num_win = pil1[0]; if (m1 * n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1); return FALSE; } if (checkInputArgumentType(pvApiCtx, 2, sci_strings)) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrl1, ¶m2)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } if ( ( strcmp(param2, "EMF") == 0 ) || ( strcmp(param2, "DIB") == 0 ) ) { if (num_win >= 0) { /* Call Java */ if ( strcmp(param2, "EMF") == 0) { /* @TODO create EMF */ copyFigureToClipBoard(getFigureFromIndex(num_win)); } else { /* @TODO create DIB */ copyFigureToClipBoard(getFigureFromIndex(num_win)); } m1 = 0; n1 = 0; freeAllocatedSingleString(param2); sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return TRUE; } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: Must be >= %d expected.\n"), fname, 1, 0); return FALSE; } } else { freeAllocatedSingleString(param2); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "EMF", "DIB"); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: string or real expected.\n"), fname, 1); return FALSE; } } } else { Scierror(999, _("%s: Function not available in NWNI mode.\n"), fname); return FALSE; } return FALSE; }
/*--------------------------------------------------------------------------*/ int sci_stringbox(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddrstackPointer = NULL; long long* stackPointer = NULL; char** strStackPointer = NULL; double* pdblStackPointer = NULL; int type = -1; int *piType = &type; char* parentAxes = NULL; double* textCorners = NULL; int two = 2; int four = 4; double corners[4][2]; /* the four edges of the boundingRect */ /* The function should be called with stringbox(handle) */ CheckInputArgument(pvApiCtx, 1, 6); CheckOutputArgument(pvApiCtx, 0, 1); if (nbInputArgument(pvApiCtx) == 1) { int m; int n; /* A text handle should be specified */ char * pTextUID = NULL; if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles))) { Scierror(999, _("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1); return 0; } /* get the handle */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of handle at position 1. sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1); return 1; } if (m * n != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A 'Text' handle expected.\n"), fname, 1); return 0; } /* Get the handle and check that this is a text handle */ pTextUID = (char*)getObjectFromHandle((long int) * stackPointer); if (pTextUID == NULL) { Scierror(999, _("%s: The handle is not valid.\n"), fname); return 0; } getGraphicObjectProperty(pTextUID, __GO_TYPE__, jni_int, (void **)&piType); if (type != __GO_LABEL__ && type != __GO_TEXT__) { Scierror(999, _("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1); return 0; } getGraphicObjectProperty(pTextUID, __GO_PARENT_AXES__, jni_string, (void **)&parentAxes); updateTextBounds(pTextUID); /* * To do: performs a projection/unprojection to obtain the bounding box in object coordinates * but using a rotation matrix corresponding to the default rotation angles (view == 2d) */ getGraphicObjectProperty(pTextUID, __GO_CORNERS__, jni_double_vector, (void **)&textCorners); corners[1][0] = textCorners[0]; corners[1][1] = textCorners[1]; corners[0][0] = textCorners[3]; corners[0][1] = textCorners[4]; corners[3][0] = textCorners[6]; corners[3][1] = textCorners[7]; corners[2][0] = textCorners[9]; corners[2][1] = textCorners[10]; } else if (nbInputArgument(pvApiCtx) == 2) { Scierror(999, _("%s: Wrong number of input arguments: %d or %d to %d expected.\n"), fname, 1, 3, 6); return 0; } else { char * parentSubwinUID = (char*)getOrCreateDefaultSubwin(); char ** text = NULL; int textNbRow; int textNbCol; double xPos; double yPos; double angle = DEFAULT_ANGLE; int fontId; int *pfontId = &fontId; double fontSize; double *pfontSize = &fontSize; getGraphicObjectProperty(parentSubwinUID, __GO_FONT_STYLE__, jni_int, (void**)&pfontId); getGraphicObjectProperty(parentSubwinUID, __GO_FONT_SIZE__, jni_double, (void **)&pfontSize); /* Check that first argument is a string */ if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings))) { Scierror(999, _("%s: Wrong type for input argument #%d: 2D array of strings expected.\n"), fname, 1); return 0; } sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 1. if (getAllocatedMatrixOfString(pvApiCtx, piAddrstackPointer, &textNbRow, &textNbCol, &strStackPointer)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1); return 1; } /* retrieve it */ text = strStackPointer; /* Second and third arguments should be scalars */ if (getScalarFromStack(2, fname, &xPos) < 0) { freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); return 0; } if (getScalarFromStack(3, fname, &yPos) < 0) { freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); return 0; } if (nbInputArgument(pvApiCtx) >= 4) { /* angle is defined */ if (getScalarFromStack(4, fname, &angle) < 0) { freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); return 0; } } if (nbInputArgument(pvApiCtx) >= 5) { double fontIdD; /* font style is defined */ if (getScalarFromStack(5, fname, &fontIdD) < 0) { freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); return 0; } fontId = (int) fontIdD; } if (nbInputArgument(pvApiCtx) >= 6) { /* font size is defined */ if (getScalarFromStack(6, fname, &fontSize) < 0) { freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); return 0; } } /* compute the box */ getTextBoundingBox(text, textNbRow, textNbCol, xPos, yPos, angle, fontId, fontSize, corners); freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer); } /* copy everything into the lhs */ sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, two, four, &pdblStackPointer); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } pdblStackPointer[0] = corners[1][0]; pdblStackPointer[1] = corners[1][1]; pdblStackPointer[2] = corners[0][0]; pdblStackPointer[3] = corners[0][1]; pdblStackPointer[4] = corners[3][0]; pdblStackPointer[5] = corners[3][1]; pdblStackPointer[6] = corners[2][0]; pdblStackPointer[7] = corners[2][1]; AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_prod(char *fname, void* pvApiCtx) { SciErr sciErr; int iRows = 0; int iCols = 0; int*piAddr = NULL; double* pdblReal = NULL; double* pdblImg = NULL; int iRowsRet = 0; int iColsRet = 0; double* pdblRealRet = NULL; double* pdblImgRet = NULL; int iMode = 0; CheckRhs(1, 2); CheckLhs(1, 1); sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } if (Rhs == 2) { sciErr = getProcessMode(pvApiCtx, 2, piAddr, &iMode); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } sciErr = getVarDimension(pvApiCtx, piAddr, &iRows, &iCols); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } if (iRows * iCols == 0) { double dblVal = 0; if (iMode == 0) { iRows = 1; iCols = 1; dblVal = 1; } else { iRows = 0; iCols = 0; } sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, 1, &dblVal); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } LhsVar(1) = Rhs + 1; PutLhsVar(); return 0; } switch (iMode) { case BY_ROWS : iRowsRet = 1; iColsRet = iCols; break; case BY_COLS : iRowsRet = iRows; iColsRet = 1; break; default : //BY_ALL iRowsRet = 1; iColsRet = 1; break; } if (isVarComplex(pvApiCtx, piAddr)) { sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = allocComplexMatrixOfDouble(pvApiCtx, Rhs + 1, iRowsRet, iColsRet, &pdblRealRet, &pdblImgRet); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } vWDmProd(iMode, pdblReal, pdblImg, iRows, iRows, iCols, pdblRealRet, pdblImgRet, 1); } else { sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = allocMatrixOfDouble(pvApiCtx, Rhs + 1, iRowsRet, iColsRet, &pdblRealRet); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } vDmProd(iMode, pdblReal, iRows, iRows, iCols, pdblRealRet, 1); } LhsVar(1) = Rhs + 1; PutLhsVar(); return 0; }