/*--------------------------------------------------------------------------*/ int get_optional_int_arg(void* _pvCtx, char* fname, int pos, char* name, int** value, int sz, rhs_opts opts[]) { int m, n, first_opt = FirstOpt(_pvCtx), kopt; if (pos < first_opt) { int* piAddr = 0; int iType = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, pos, &piAddr); getVarType(_pvCtx, piAddr, &iType); if (iType) { getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (m * n != sz) { return 1; } *value = piData; } } else if ((kopt = FindOpt(_pvCtx, name, opts)) >= 0) { int* piData = NULL; getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData); if (m * n < 1) { return 1; } *value = piData; } return 1; }
/*--------------------------------------------------------------------------*/ int get_nax_arg(void* _pvCtx, int pos, rhs_opts opts[], int ** nax, BOOL * flagNax) { int i, m, n, first_opt = FirstOpt(_pvCtx), kopt; if (pos < first_opt) { int* piAddr = 0; int iType = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, pos, &piAddr); getVarType(_pvCtx, piAddr, &iType); if (iType) { getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (n * m != 4) { return 1; } for (i = 0 ; i < 4; ++i) { // When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks' piData[i] = Max(piData[i], -(i % 2)); } *nax = piData; *flagNax = TRUE; } else { *nax = getDefNax(); *flagNax = FALSE; } } else if ((kopt = FindOpt(_pvCtx, "nax", opts)) >= 0) { int* piData = NULL; getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData); if (m * n != 4) { return 1; } for (i = 0 ; i < 4; ++i) { // When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks' piData[i] = Max(piData[i], -(i % 2)); } *nax = piData; *flagNax = TRUE; } else { *nax = getDefNax(); *flagNax = FALSE; } return 1; }
/*--------------------------------------------------------------------------*/ int get_colout_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], int ** colout) { int m, n, first_opt = FirstOpt(), kopt; if (pos < first_opt) { int* piAddr = 0; int iType = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, pos, &piAddr); getVarType(_pvCtx, piAddr, &iType); if (iType) { getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (m * n != 2) { return 1; } *colout = piData; } else { /** global value can be modified **/ int newDefCO[2] = { -1, -1 }; setDefColOut(newDefCO); *colout = getDefColOut(); } } else if ((kopt = FindOpt("colout", opts))) { int* piAddr = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, kopt, &piAddr); getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (m * n != 2) { return 1; } *colout = piData; } else { /** global value can be modified **/ int newDefCO[2] = { -1, -1 }; setDefColOut(newDefCO); *colout = getDefColOut(); } return 1; }
/*--------------------------------------------------------------------------*/ int get_colminmax_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], int ** colminmax) { int m, n, first_opt = FirstOpt(_pvCtx), kopt; if (pos < first_opt) { int* piAddr = 0; int iType = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, pos, &piAddr); getVarType(_pvCtx, piAddr, &iType); if (iType) { getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (m * n != 2) { return 1; } *colminmax = piData; } else { /** global value can be modified **/ int zeros[2] = { 0, 0 }; setDefColMinMax(zeros); *colminmax = getDefColMinMax(); } } else if ((kopt = FindOpt(_pvCtx, "colminmax", opts)) >= 0) { int* piData = NULL; getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData); if (m * n != 2) { return 1; } *colminmax = piData; } else { /** global value can be modified **/ int zeros[2] = { 0, 0 }; setDefColMinMax(zeros); *colminmax = getDefColMinMax(); } return 1; }
/*--------------------------------------------------------------------------*/ int sci_xfarcs(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddr2 = NULL; int* l2 = NULL; int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; long hdl = 0; int iCurrentSubWin = 0; int i = 0; double angle1 = 0.0; double angle2 = 0.0; CheckInputArgument(pvApiCtx, 1, 2); 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; } if (m1 != 6) { Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(6,n)"); return 0; } if (nbInputArgument(pvApiCtx) == 2) { 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; } //CheckVector if (m2 != 1 && n2 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2); return 1; } if (n1 != m2 * n2) { Scierror(999, _("%s: Wrong size for input arguments #%d and #%d.\n"), fname, 1, 2); return 0; } } else { m2 = 1; n2 = n1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 2, m2, n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (i = 0; i < n2; ++i) { *((int*)(l2 + i)) = i + 1; } } iCurrentSubWin = getOrCreateDefaultSubwin(); for (i = 0; i < n1; ++i) { angle1 = DEG2RAD(*(l1 + (6 * i) + 4) / 64.0); angle2 = DEG2RAD(*(l1 + (6 * i) + 5) / 64.0); Objarc(&angle1, &angle2, (l1 + (6 * i)), (l1 + (6 * i) + 1), (l1 + (6 * i) + 2), (l1 + (6 * i) + 3), (int*)(l2 + i), (int*)(l2 + i), TRUE, FALSE, &hdl); } /** Construct Compound and make it current object **/ { int o = createCompoundSeq(iCurrentSubWin, n1); setCurrentObject(o); } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_xrects(char *fname, void *pvApiCtx) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddr2 = NULL; int* l2 = NULL; int m1 = 0, n1 = 0, m2 = 0, n2 = 0; long hdl = 0; int i = 0; int iSubwinUID = 0; int foreground = 0; int *piForeground = &foreground; int iCompoundUID = 0; CheckInputArgument(pvApiCtx, 1, 2); 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; } if (m1 != 4) { Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(4,n)"); return 0; } if (nbInputArgument(pvApiCtx) == 2) { 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; } //CheckVector if (m2 != 1 && n2 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2); return 1; } if (m2 * n2 != n1) { Scierror(999, _("%s: Incompatible length for input arguments #%d and #%d.\n"), fname, 1, 2); return 0; } } else { m2 = 1; n2 = n1; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 2, m2, n2, &l2); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (i = 0; i < n2; ++i) { l2[i] = 0; } } iSubwinUID = getOrCreateDefaultSubwin(); // Create compound. iCompoundUID = createGraphicObject(__GO_COMPOUND__); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(iSubwinUID, iCompoundUID); /** Get Subwin line color */ getGraphicObjectProperty(iSubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeground); for (i = 0; i < n1; ++i) { /* j = (i==0) ? 0 : 1; */ if (l2[i] == 0) { /** fil(i) = 0 rectangle i is drawn using the current line style (or color).**/ /* color setting is done now */ Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), &foreground, NULL, FALSE, TRUE, &hdl); } else { if (l2[i] < 0) { /** fil(i) < 0 rectangle i is drawn using the line style (or color) **/ int tmp = - (*(int*)(l2 + i)); Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), &tmp, NULL, FALSE, TRUE, &hdl); } else { /** fil(i) > 0 rectangle i is filled using the pattern (or color) **/ Objrect((l1 + (4 * i)), (l1 + (4 * i) + 1), (l1 + (4 * i) + 2), (l1 + (4 * i) + 3), NULL, l2 + i, TRUE, FALSE, &hdl); } } // Add newly created object to Compound setGraphicObjectRelationship(iCompoundUID, getObjectFromHandle(hdl)); } /** make Compound current object **/ setCurrentObject(iCompoundUID); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_xfpolys(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; int* piAddr3 = NULL; int* l3 = NULL; int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; int m3 = 0, n3 = 0; int mn2 = 0; int v1 = 0; /* v1 is the flag used for flat (v1==1) or interpolated (v1==2) shading */ int i = 0; long hdl = 0; char *pstSubWinUID = NULL; char *pstFigureUID = NULL; char *pstCompoundUID = NULL; int iSubWinForeground = 0; int iImmediateDrawing = 0; int *piImmediateDrawing = &iImmediateDrawing; int iFalse = 0; int iColorMapSize = 0; int* piColorMapSize = &iColorMapSize; int iForeGround = 0; int* piForeGround = &iForeGround; int iVisible = 0; int *piVisible = &iVisible; CheckInputArgument(pvApiCtx, 2, 3); 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; } mn2 = m2 * n2; if (mn2 == 0) { AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr3, &m3, &n3, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } if (m3 * n3 == m1 * n1) { //CheckSameDims if (m1 != m3 || n1 != n3) { Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1); return 1; } v1 = 2; /* interpolated shading */ if (m3 != 3 && m3 != 4) { Scierror(999, _("%s: Interpolated shading only works for polygons of size %d or %d\n"), fname, 3, 4); return 0; } } else { //CheckVector if (m3 != 1 && n3 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 3); return 1; } //CheckDimProp if (m3 * n3 != n2) { Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname); return 1; } v1 = 1; /* flat shading */ } } else { int un = 1, ix = 0; sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 3, un, n2, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (ix = 0; ix < n2; ++ix) { *(int*)(l3 + ix) = 0; } m3 = n3 = 1; } pstSubWinUID = (char*)getOrCreateDefaultSubwin(); getGraphicObjectProperty(pstSubWinUID, __GO_PARENT__, jni_string, (void**)&pstFigureUID); getGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, jni_bool, (void **)&piImmediateDrawing); setGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, &iFalse, jni_bool, 1); //get color map size getGraphicObjectProperty(pstFigureUID, __GO_COLORMAP_SIZE__, jni_int, (void**)&piColorMapSize); //get current foreground color getGraphicObjectProperty(pstSubWinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeGround); // Create compound. pstCompoundUID = createGraphicObject(__GO_COMPOUND__); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iFalse, jni_bool, 1); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(pstSubWinUID, pstCompoundUID); for (i = 0; i < n1; ++i) { if (m3 == 1 || n3 == 1) /* color vector specified */ { if (*(int*)(l3 + i) == 0) { if (iForeGround == -1) { iSubWinForeground = iColorMapSize + 1; } else if (iForeGround == -2) { iSubWinForeground = iColorMapSize + 2; } else { iSubWinForeground = iForeGround; } Objpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, 1, iSubWinForeground, &hdl); } else { Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i), &hdl, v1); } } else /* we have a color matrix used for interpolated shading : one color per vertex */ { Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i * m3), &hdl, v1); } // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } setCurrentObject(pstCompoundUID); setGraphicObjectProperty(pstFigureUID, __GO_IMMEDIATE_DRAWING__, &piImmediateDrawing, jni_bool, 1); getGraphicObjectProperty(pstFigureUID, __GO_VISIBLE__, jni_bool, (void **)&piVisible); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iVisible, jni_bool, 1); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int get_style_arg(void* _pvCtx, char *fname, int pos, int n1, rhs_opts opts[], int ** style) { int m = 0, n = 0, first_opt = FirstOpt(_pvCtx), kopt = 0, un = 1, ix = 0, i = 0, l1 = 0; if ( pos < first_opt ) /* regular argument */ { int* piAddr = 0; int iType = 0; int* piData = NULL; getVarAddressFromPosition(_pvCtx, pos, &piAddr); getVarType(_pvCtx, piAddr, &iType); if (iType) { getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData); if (m * n < n1) { Scierror(999, _("%s: Wrong size for input argument #%d: %d < %d expected.\n"), fname, pos, m * n, n1); return 0; } if ( n1 == 1 && m * n == 1 ) { *style = (int*)MALLOC(2 * sizeof(int)); (*style)[0] = piData[0]; (*style)[1] = 1; } else { *style = (int*)MALLOC(m * n * sizeof(int)); for (i = 0; i < m * n; i++) { (*style)[i] = piData[i]; } } } else /* zero type argument --> default value */ { ix = Max(n1, 2); *style = (int*)MALLOC(ix * sizeof(int)); (*style)[1] = 1; for ( i = 0 ; i < n1 ; ++i ) { (*style)[i] = i + 1; } } } else if ((kopt = FindOpt(_pvCtx, "style", opts)) >= 0) { /* optinal argument: style=value */ int* piData = NULL; getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData); if (m * n < n1) { Scierror(999, _("%s: Wrong size for input argument #%d: %d < %d expected.\n"), fname, kopt, m * n, n1); return 0; } if (n1 == 1 && m * n == 1) { *style = (int*)MALLOC(2 * sizeof(int)); (*style)[0] = piData[0]; (*style)[1] = 1; } else { *style = (int*)MALLOC(m * n * sizeof(int)); for (i = 0; i < m * n; i++) { (*style)[i] = piData[i]; } } } else /* unspecified argument --> default value */ { ix = Max(n1, 2); *style = (int*)MALLOC(ix * sizeof(int)); (*style)[1] = 1; for (i = 0 ; i < n1 ; ++i) { (*style)[i] = i + 1; } } return 1; }
/*--------------------------------------------------------------------------*/ 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_toolbar(char *fname, unsigned long l) { SciErr sciErr; int* piAddr1 = NULL; int* piStkAdr = NULL; int* piAddrstkAdr = NULL; long long* stkAdr = NULL; int* piAddrparam = NULL; int nbCol = 0; int nbRow = 0; char *Output = NULL; char **param = NULL; int figNum = -2; int iIsVisible = 0; int *piIsVisible = NULL; int iParentUID = 0; int iParentType = -1; int *piParentType = &iParentType; CheckInputArgument(pvApiCtx, 1, 2); CheckOutputArgument(pvApiCtx, 0, 1); /* Figure number */ if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { 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, &nbRow, &nbCol, &piStkAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1); return FALSE; } figNum = *piStkAdr; if (figNum < -1) { Scierror(999, _("%s: Wrong value for input argument #%d: Must be > %d expected.\n"), fname, 1, -1); return FALSE; } if (figNum != -1) /* Check that the figure exists */ { if (getFigureFromIndex(figNum) == 0) { Scierror(999, _("%s: Wrong value for input argument #%d: 'Graphic Window Number %d' does not exist.\n"), fname, 1, figNum); return FALSE; } } if (figNum == -1) { iParentUID = getConsoleIdentifier(); } else { iParentUID = getFigureFromIndex(figNum); } } else if (checkInputArgumentType(pvApiCtx, 1, sci_handles)) { sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstkAdr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of handle at position 1. sciErr = getMatrixOfHandle(pvApiCtx, piAddrstkAdr, &nbRow, &nbCol, &stkAdr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1); return 1; } if (nbRow * nbCol != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1); return FALSE; } iParentUID = getObjectFromHandle((long) * stkAdr); if (iParentUID == 0) { Scierror(999, _("%s: Wrong value for input argument #%d: this handle does not exist.\n"), fname, 1); return FALSE; } getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType); if (iParentType != __GO_FIGURE__) { Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A real or a Figure handle expected.\n"), fname, 1); return FALSE; } if (nbInputArgument(pvApiCtx) == 2) /* New status */ { if ((checkInputArgumentType(pvApiCtx, 2, sci_strings))) { sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrparam); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrparam, &nbRow, &nbCol, ¶m)) { Scierror(202, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2); return 1; } if (nbRow * nbCol != 1) { freeAllocatedMatrixOfString(nbRow, nbCol, param); Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } if ((strcmp(param[0], "off") == 0) || (strcmp(param[0], "on") == 0)) { iIsVisible = strcmp(param[0], "on") == 0; if (iParentUID != getConsoleIdentifier() || getScilabMode() == SCILAB_STD) { setGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, &iIsVisible, jni_bool, 1); } freeAllocatedMatrixOfString(nbRow, nbCol, param); } else { freeAllocatedMatrixOfString(nbRow, nbCol, param); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "on", "off"); return FALSE; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2); return FALSE; } } /* Returned value */ piIsVisible = &iIsVisible; getGraphicObjectProperty(iParentUID, __GO_TOOLBAR_VISIBLE__, jni_bool, (void **)&piIsVisible); if (iIsVisible) { Output = strdup("on"); } else { Output = strdup("off"); } nbCol = 1; nbRow = (int)strlen(Output); if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, Output)) { Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; if (Output) { FREE(Output); Output = NULL; } ReturnArguments(pvApiCtx); return TRUE; }
/*--------------------------------------------------------------------------*/ int sci_xpolys(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrl1 = NULL; double* l1 = NULL; int* piAddrl2 = NULL; double* l2 = NULL; int* piAddr3 = NULL; int* l3 = NULL; int m1 = 0, n1 = 0; int m2 = 0, n2 = 0; int m3 = 0, n3 = 0; int i = 0; long hdl = 0; char *pstFigureUID = NULL; char *pstSubWinUID = NULL; char *pstCompoundUID = NULL; int iFalse = 0; int iVisible = 0; int *piVisible = &iVisible; CheckInputArgument(pvApiCtx, 2, 3); 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; } if (m1 * n1 == 0 || m2 * n2 == 0) { /* dimension 0, 0 polyline to draw */ AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; } pstSubWinUID = (char*)getOrCreateDefaultSubwin(); pstFigureUID = (char*)getCurrentFigure(); // Create compound. pstCompoundUID = createGraphicObject(__GO_COMPOUND__); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iFalse, jni_bool, 1); /* Sets the parent-child relationship for the Compound */ setGraphicObjectRelationship(pstSubWinUID, pstCompoundUID); if (nbInputArgument(pvApiCtx) == 3) { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr3, &m3, &n3, &l3); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } //CheckVector if (m3 != 1 && n3 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 3); return 1; } //CheckDimProp if (m3 * n3 < n1) { Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname); return 1; } /* Construct the polylines */ for (i = 0; i < n1; ++i) { Objpoly((l1 + (i * m1)), (l2 + (i * m2)), m1, 0, *(int*)(l3 + i), &hdl); // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } } else { for (i = 0; i < n1; ++i) { Objpoly((l1 + (i * m1)), (l2 + (i * m2)), m1, 0, 1, &hdl); // Add newly created object to Compound setGraphicObjectRelationship(pstCompoundUID, getObjectFromHandle(hdl)); } } getGraphicObjectProperty(pstFigureUID, __GO_VISIBLE__, jni_bool, (void **)&piVisible); setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iVisible, jni_bool, 1); setCurrentObject(pstCompoundUID); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_xtitle(char * fname, unsigned long fname_len) { SciErr sciErr; int* piAddr4 = NULL; int* boxPtr = NULL; int* piAddrStr = NULL; int narg = 0; int nbLabels = 0; /* number of modified labels */ int box = 0; BOOL isBoxSpecified = FALSE; int iSubwinUID = 0; static rhs_opts opts[] = { { -1, "boxed", -1, 0, 0, NULL}, { -1, NULL, -1, 0, 0, NULL} }; if (nbInputArgument(pvApiCtx) <= 0) { sci_demo(fname, fname_len); return 0; } CheckInputArgument(pvApiCtx, 1, 5); nbLabels = nbInputArgument(pvApiCtx); /* get the given options from the name in opts */ if (!getOptionals(pvApiCtx, fname, opts)) { /* error */ return 0; } /* compatibility with previous version in which box was put */ /* at the fourth position */ if (nbInputArgument(pvApiCtx) == 4) { int type = getInputArgumentType(pvApiCtx, 4); if (type == 1 || type == 8)/* double or int */ { int n = 0, m = 0; sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr4, &m, &n, &boxPtr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4); return 1; } //CheckScalar if (m != 1 || n != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4); return 1; } box = *boxPtr; nbLabels--; /* it is not a label text */ isBoxSpecified = TRUE; } } if (opts[0].iPos != -1 && !isBoxSpecified) { /* check if "box" is in the options */ getScalarBoolean(pvApiCtx, opts[0].piAddr, &box); if (opts[0].iRows != 1 || opts[0].iCols != 1) { /* check size */ Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname); return 1; } nbLabels--; /* it is not a label text */ } iSubwinUID = getOrCreateDefaultSubwin(); for (narg = 1 ; narg <= nbLabels ; narg++) { int m = 0, n = 0; char **Str = NULL; int iModifiedLabel = 0; int* piModifiedLabel = &iModifiedLabel; sciErr = getVarAddressFromPosition(pvApiCtx, narg, &piAddrStr); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position narg. if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m, &n, &Str)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, narg); return 1; } if (m * n == 0) { continue; } switch (narg) { case 1: getGraphicObjectProperty(iSubwinUID, __GO_TITLE__, jni_int, (void **)&piModifiedLabel); break; case 2: getGraphicObjectProperty(iSubwinUID, __GO_X_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; case 3: getGraphicObjectProperty(iSubwinUID, __GO_Y_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; case 4: getGraphicObjectProperty(iSubwinUID, __GO_Z_AXIS_LABEL__, jni_int, (void **)&piModifiedLabel); break; default: break; } #if 0 startFigureDataWriting(pFigure); #endif sciSetText(iModifiedLabel, Str, m, n); setGraphicObjectProperty(iModifiedLabel, __GO_FILL_MODE__, &box, jni_bool, 1); #if 0 endFigureDataWriting(pFigure); #endif freeArrayOfString(Str, m * n); } setCurrentObject(iSubwinUID); #if 0 sciDrawObj(pFigure); #endif AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int xs2file(char * fname, ExportFileType fileType ) { SciErr sciErr; int* piAddrl1 = NULL; int* piAddrfileName = NULL; int* piAddrsciOrientation = NULL; int* piAddrquality = NULL; double* quality = NULL; /* Check input and output sizes */ CheckOutputArgument(pvApiCtx, 0, 1); if (isVectorialExport(fileType) || fileType == JPG_EXPORT) { CheckInputArgument(pvApiCtx, 2, 3); } else { CheckInputArgument(pvApiCtx, 2, 2); } if ((!checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (!checkInputArgumentType(pvApiCtx, 1, sci_handles))) { Scierror(999, _("%s: Wrong type for input argument #%d: An integer or a handle expected.\n"), fname, 1); AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 1; } if ( (checkInputArgumentType(pvApiCtx, 2, sci_strings)) ) { char **fileName = NULL; char *real_filename = NULL; float jpegCompressionQuality = 0.95f; ExportOrientation orientation = EXPORT_PORTRAIT; /* default orientation */ int m1 = 0, n1 = 0; int figurenum = -1; char* figureUID = NULL; char *status = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } /* get handle by figure number */ if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) { // Retrieve a matrix of double at position 1. int* l1 = NULL; sciErr = getMatrixOfDoubleAsInteger(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; } if (m1 * n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 1); return 1; } figurenum = *l1; if (!sciIsExistingFigure(figurenum)) { Scierror(999, "%s: Input argument #%d must be a valid figure_id.\n", fname, 1); return 1; } figureUID = (char*)getFigureFromIndex(figurenum); } /* check given handle */ else if (checkInputArgumentType(pvApiCtx, 1, sci_handles)) { int iHandleType = -1; int* piHandleType = &iHandleType; long long* l1 = NULL; // Retrieve a matrix of handle at position 1. sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1); return 1; } if (m1 * n1 != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1); return 1; } figureUID = (char*)getObjectFromHandle((unsigned long) * l1); if (figureUID == NULL) { Scierror(999, _("%s: Input argument #%d must be a valid handle.\n"), fname, 1); return 1; } getGraphicObjectProperty(figureUID, __GO_TYPE__, jni_int, (void**)&piHandleType); if (iHandleType != __GO_FIGURE__) { Scierror(999, _("%s: Wrong type for input argument #%d: A ''%s'' handle expected.\n"), fname, 1, "Figure"); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: A scalar or figure handle expected.\n"), fname, 1); return 1; } /* get file name */ sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfileName); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 2. if (getAllocatedMatrixOfString(pvApiCtx, piAddrfileName, &m1, &n1, &fileName)) { Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2); return 1; } if (m1 * n1 == 1) { if (nbInputArgument(pvApiCtx) == 3) { int nbCol = 0; int nbRow = 0; if (isVectorialExport(fileType)) { char **sciOrientation = NULL; if ((!checkInputArgumentType(pvApiCtx, 3, sci_strings))) { freeAllocatedMatrixOfString(m1, n1, fileName); Scierror(999, _("%s: Wrong type for input argument #%d: Single character string expected.\n"), fname, 3); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsciOrientation); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of string at position 3. if (getAllocatedMatrixOfString(pvApiCtx, piAddrsciOrientation, &nbRow, &nbCol, &sciOrientation)) { freeAllocatedMatrixOfString(m1, n1, fileName); Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3); return 1; } if (nbRow * nbCol == 1) { /* Value should be 'landscape' or 'portrait' but check only the first character */ /* for compatibility with Scilab 4*/ if (strcmp(sciOrientation[0], "landscape") == 0 || strcmp(sciOrientation[0], "l") == 0) { freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation); orientation = EXPORT_LANDSCAPE; } else if (strcmp(sciOrientation[0], "portrait") == 0 || strcmp(sciOrientation[0], "p") == 0) { freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation); orientation = EXPORT_PORTRAIT; } else { freeAllocatedMatrixOfString(m1, n1, fileName); freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation); Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 3, "portrait", "landscape"); return 1; } } else { freeAllocatedMatrixOfString(m1, n1, fileName); freeAllocatedMatrixOfString(nbRow, nbCol, sciOrientation); Scierror(999, _("%s: Wrong size for input argument #%d: Single character string expected.\n"), fname, 3); return 1; } } else { sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrquality); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddrquality, &nbRow, &nbCol, &quality); if (sciErr.iErr) { freeAllocatedMatrixOfString(m1, n1, fileName); printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } if (nbRow != 1 || nbCol != 1 || *quality < 0 || *quality > 1) { freeAllocatedMatrixOfString(m1, n1, fileName); Scierror(999, _("%s: Wrong type for input argument #%d: A real between 0 and 1 expected.\n"), fname, 3); return 1; } jpegCompressionQuality = (float) * quality; } } /* Replaces SCI, ~, HOME, TMPDIR by the real path */ real_filename = expandPathVariable(fileName[0]); /* Call the function for exporting file */ status = exportToFile(figureUID, real_filename, fileType, jpegCompressionQuality, orientation); /* free pointers no more used */ if (real_filename) { FREE(real_filename); real_filename = NULL; } freeAllocatedMatrixOfString(m1, n1, fileName); /* treat errors */ if (strlen(status) != 0) { Scierror(999, _("%s: %s\n"), fname, status); return 1; } } else { freeAllocatedMatrixOfString(m1, n1, fileName); Scierror(999, _("%s: Wrong size for input argument #%d: Single character string expected.\n"), fname, 2); return 1; } } else { Scierror(999, _("%s: Wrong type for input argument #%d: Single character string expected.\n"), fname, 2); return 1; } AssignOutputVariable(pvApiCtx, 1) = 0; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_qld(char *fname, unsigned long fname_len) { SciErr sciErr; static int un = 1, zero = 0; static int n = 0, nbis = 0; static int unbis = 0; static int mmax = 0, m = 0, mnn = 0; static int mbis = 0; static int pipo = 0; static int ifail = 0; int next = 0; static int lwar = 0, iout = 0, k = 0, l = 0; static double eps1 = 0; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr4 = NULL; int* piAddr5 = NULL; int* piAddr6 = NULL; int* piAddr7 = NULL; double* Q = NULL; double* p = NULL; double* C = NULL; double* b = NULL; double* lb = NULL; double* ub = NULL; int* me = NULL; double* x = NULL; double* lambda = NULL; int* inform = NULL; double* war = NULL; int* iwar = NULL; /* Check rhs and lhs */ CheckInputArgument(pvApiCtx, 7, 8) ; CheckOutputArgument(pvApiCtx, 1, 3) ; /* RhsVar: qld(Q,p,C,b,lb,ub,me,eps) */ /* 1,2,3,4,5 ,6 ,7, 8 */ eps1 = C2F(dlamch)("e", 1L); next = nbInputArgument(pvApiCtx) + 1; /* Variable 1 (Q) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &n, &nbis, &Q); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1); printError(&sciErr, 0); return 1; } //CheckSquare if (n != nbis) { Scierror(999, _("%s: Wrong size for input argument #%d: A square matrix expected.\n"), fname, 1); return 1; } /* Variable 2 (p) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &nbis, &unbis, &p); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2); printError(&sciErr, 0); return 1; } //CheckLength if (nbis * unbis != n) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 2, nbis * unbis); return 1; } /* Variable 3 (C) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m, &nbis, &C); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } if (( nbis != n ) && (m > 0)) { Scierror(205, _("%s: Wrong size for input argument #%d: number of columns %d expected.\n"), fname, 3, n); return 0; } mmax = m; mnn = m + n + n; /* Variable 4 (b) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &mbis, &unbis, &b); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4); printError(&sciErr, 0); return 1; } //CheckLength if (mbis * unbis != m) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 4, mbis * unbis); return 1; } /* Variable 5 (lb) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getMatrixOfDouble(pvApiCtx, piAddr5, &nbis, &unbis, &lb); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 5); printError(&sciErr, 0); return 1; } if (nbis*unbis == 0) { sciErr = allocMatrixOfDouble(pvApiCtx, next, n, un, &lb); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (k = 0; k < n; k++) { (lb)[k] = -C2F(dlamch)("o", 1L); } next = next + 1; } else if (nbis * unbis != n) //CheckLength { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 5, nbis * unbis); return 1; } /* Variable 6 (ub) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr6); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 6. sciErr = getMatrixOfDouble(pvApiCtx, piAddr6, &nbis, &unbis, &ub); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 6); printError(&sciErr, 0); return 1; } if (nbis*unbis == 0) { sciErr = allocMatrixOfDouble(pvApiCtx, next, n, un, &ub); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } for (k = 0; k < n; k++) { (ub)[k] = C2F(dlamch)("o", 1L); } next = next + 1; } else if (nbis * unbis != n)//CheckLength { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 6, nbis * unbis); return 1; } /* Variable 7 (me) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddr7); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 7. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr7, &pipo, &unbis, &me); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 7); printError(&sciErr, 0); return 1; } //CheckScalar if (pipo != 1 || unbis != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 7); return 1; } if ((*(me) < 0) || (*(me) > n)) { Err = 7; SciError(116); return 0; } if (nbInputArgument(pvApiCtx) == 8) { /* Variable 8 (eps1) */ //get variable address int* piAddr8 = NULL; double* leps = NULL; sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddr8); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 8. sciErr = getMatrixOfDouble(pvApiCtx, piAddr8, &pipo, &unbis, &leps); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 8); printError(&sciErr, 0); return 1; } //CheckScalar if (pipo != 1 || unbis != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 8); return 1; } eps1 = Max(eps1, *leps); } /* Internal variables: x, lambda, inform, C_mmax, b_mmax */ sciErr = allocMatrixOfDouble(pvApiCtx, next, n, un, &x); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, next + 1, mnn, un, &lambda); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 2, un, un, &inform); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } lwar = 3 * n * n / 2 + 10 * n + 2 * mmax + 2; sciErr = allocMatrixOfDouble(pvApiCtx, next + 3, lwar, un, &war); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 4, n, un, &iwar); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } (iwar)[0] = 1; /*Cholesky factorisation required*/ /* Change the sign of C*/ for (k = 0; k < n; k++) { for (l = 0; l < m; l++) { (C)[k * m + l] = -(C)[k * m + l]; } } iout = 0; ifail = 0; C2F(ql0001)(&m, (me), &mmax, &n, &n, &mnn, (Q), (p), (C), (b), (lb), (ub), (x), (lambda), &iout, &ifail, &zero, (war), &lwar, (iwar), &n, &eps1); /* LhsVar: [x, lambda, inform] = qld(...) */ if (ifail == 0) { AssignOutputVariable(pvApiCtx, 1) = next; AssignOutputVariable(pvApiCtx, 2) = next + 1; if (nbOutputArgument(pvApiCtx) == 3) { AssignOutputVariable(pvApiCtx, 3) = next + 2; *(inform) = ifail; } ReturnArguments(pvApiCtx); } else if (ifail == 1) { Scierror(24, _("%s: Too many iterations (more than %d).\n"), fname, 40 * (n + m)); } else if (ifail == 2) { Scierror(24, _("%s: Accuracy insufficient to satisfy convergence criterion.\n"), fname); } else if (ifail == 5) { Scierror(999, _("%s: Length of working array is too short.\n"), fname); } else if (ifail > 10) { Scierror(999, _("%s: The constraints are inconsistent.\n"), fname); } else { } return 0; }
/*--------------------------------------------------------------------------*/ int sci_qp_solve(char *fname, unsigned long fname_len) { SciErr sciErr; static int un = 1, deux = 2; // n : first dimension of Q // nbis : second dimension of Q (nbis is expected to be equal to n) static int n = 0, nbis = 0; static int unbis = 0; static int m = 0, next = 0; static int mbis = 0; static int pipo = 0; static int nact = 0; int r = 0; static int lw = 0, k = 0; static SciSparse Sp; static int issparse = 0; double *work = NULL; int* piAddr1 = NULL; int* piAddr2 = NULL; int* piAddr3 = NULL; int* piAddr4 = NULL; int* piAddr5 = NULL; double* Q = NULL; double* C = NULL; double* p = NULL; double* b = NULL; int* me = NULL; double* x = NULL; int* iact = NULL; int* iter = NULL; double* crval = NULL; int *ierr = NULL; /* Check rhs and lhs */ CheckInputArgument(pvApiCtx, 5, 5) ; CheckOutputArgument(pvApiCtx, 1, 5) ; /*Warning this interface does not support arguments passed by reference */ /* RhsVar: qp_solve(Q,p,C,b,me) */ /* 1,2,3,4,5 */ next = nbInputArgument(pvApiCtx) + 1; /* Variable 1 (Q) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &n, &nbis, &Q); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); printError(&sciErr, 0); return 1; } //CheckSquare if (n != nbis) { Scierror(999, _("%s: Wrong size for input argument #%d: A square matrix expected.\n"), fname, 1); return 1; } /* Variable 2 (p) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &nbis, &unbis, &p); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2); printError(&sciErr, 0); return 1; } //CheckLength if (nbis * unbis != n) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 2, nbis * unbis); return 1; } /* Variable 3 (C) */ issparse = (checkInputArgumentType(pvApiCtx, 3, 5)); //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } if (!issparse) { // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &nbis, &m, &C); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); printError(&sciErr, 0); return 1; } } else { if (isVarComplex(pvApiCtx, piAddr3)) { Sp.it = 1; sciErr = getComplexSparseMatrix(pvApiCtx, piAddr3, &(Sp.m), &(Sp.n), &(Sp.nel), &(Sp.mnel), &(Sp.icol), &(Sp.R), &(Sp.I)); } else { Sp.it = 0; sciErr = getSparseMatrix(pvApiCtx, piAddr3, &(Sp.m), &(Sp.n), &(Sp.nel), &(Sp.mnel), &(Sp.icol), &(Sp.R)); } if (sciErr.iErr) { printError(&sciErr, 0); return 1; } nbis = Sp.m; m = Sp.n; } if ( nbis != n ) // car C est passee en transposee dans la macro qpsolve { Scierror(999, _("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), fname, 3, n, "C"); return 0; } /* Variable 4 (b) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &mbis, &unbis, &b); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4); printError(&sciErr, 0); return 1; } //CheckLength if (mbis * unbis != m) { Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 4, mbis * unbis); return 1; } /* Variable 5 (me) */ //get variable address sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr5, &pipo, &unbis, &me); if (sciErr.iErr) { Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5); printError(&sciErr, 0); return 1; } //CheckScalar if (pipo != 1 || unbis != 1) { Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5); return 1; } if ((*(me) < 0) || (*(me) > n)) { Scierror(999, _("%s: Wrong value for input argument #%d: %s must be an integer in the range 0 to %d.\n"), fname, 5, "me", n); return 0; } /* nbOutputArgument(pvApiCtx) variables: x, iact, iter, crval */ next = Rhs; sciErr = allocMatrixOfDouble(pvApiCtx, next + 1, n, un, &x); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 2, m, un, &iact); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 3, deux, un, &iter); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDouble(pvApiCtx, next + 4, un, un, &crval); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, next + 5, un, un, &ierr); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(999, _("%s: Memory allocation error.\n"), fname); return 1; } r = Min(n, m); lw = 2 * n + r * (r + 5) / 2 + 2 * m + 1; if ((work = (double *)MALLOC(lw * sizeof(double))) == NULL) { Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } /* change the sign of C and b.*/ *ierr = 0; if (!issparse) { /* linear constraints matrix is stored full */ C2F(qpgen2)((Q), (p), &n, &n, (x), (crval), (C), (b), &n, &m, (me), (iact), &nact, (iter), work, (ierr)); } else { /* linear constraints matrix is a sparse matrix */ /* Change the linear constraints matrix representation: qpgen1sci requires column-compressed sparse matrix internal representation while Scilab sparse matrices are row-compressed */ double *R = NULL, *I = NULL; int *ind = NULL; if ((R = (double *)MALLOC(Sp.nel * sizeof(double))) == NULL) { FREE(work); work = NULL; Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } if ((ind = (int *)MALLOC((m + Sp.nel) * sizeof(int))) == NULL) { FREE(work); work = NULL; FREE(R); R = NULL; Scierror(999, _("%s: Cannot allocate more memory.\n"), fname); return 1; } // Transpose the sparse matrix A C2F(spt)(&n, &m, &(Sp.nel) , &(Sp.it), (int *)work, Sp.R, Sp.I, Sp.mnel, Sp.icol, R, I, ind, ind + m); C2F(qpgen1sci)((Q), (p), &n, &n, (x), (crval), ind, ind + m, R, (b), &m, (me), (iact), &nact, (iter), work, (ierr)); FREE(work); work = NULL; FREE(R); R = NULL; FREE(ind); ind = NULL; } for (k = nact; k < m; k++) { (iact)[k] = 0; } /* LhsVar: [x, iact, iter, f] = qp_solve(...) */ if (Lhs != 5) { if (*ierr == 0) { for (k = 0; k < Lhs; k++) { AssignOutputVariable(pvApiCtx, 1 + k) = next + 1 + k; } ReturnArguments(pvApiCtx); } else if (*ierr == 1) { Scierror(999, _("%s: The minimization problem has no solution.\n"), fname); } else if (*ierr == 2) { Scierror(999, _("%s: Q is not symmetric positive definite.\n"), fname); } } else { for (k = 0; k < Lhs; k++) { AssignOutputVariable(pvApiCtx, 1 + k) = next + 1 + k; } if (*ierr == 1) { if (getWarningMode()) { sciprint(_("\n%s: Warning: The minimization problem has no solution. The results may be inaccurate.\n\n"), fname); } } else if (*ierr == 2) { if (getWarningMode()) { sciprint(_("\n%s: Warning: Q is not symmetric positive definite. The results may be inaccurate.\n\n"), fname); } } ReturnArguments(pvApiCtx); } return 0; }
/*--------------------------------------------------------------------------*/ int sci_zneupd(char *fname, unsigned long fname_len) { SciErr sciErr; int* piAddrpRVEC = NULL; int* pRVEC = NULL; int* piAddrpHOWMANY = NULL; char* pHOWMANY = NULL; int* piAddrpSELECT = NULL; int* pSELECT = NULL; int* piAddrpBMAT = NULL; char* pBMAT = NULL; int* piAddrpN = NULL; int* pN = NULL; int* piAddrpWHICH = NULL; char* pWHICH = NULL; int* piAddrpNEV = NULL; int* pNEV = NULL; int* piAddrpTOL = NULL; double* pTOL = NULL; int* piAddrpNCV = NULL; int* pNCV = NULL; int* piAddrpIPARAM = NULL; int* pIPARAM = NULL; int* piAddrpIPNTR = NULL; int* pIPNTR = NULL; int* piAddrpRWORK = NULL; double* pRWORK = NULL; int* piAddrpINFO = NULL; int* pINFO = NULL; int* piAddrpD = NULL; doublecomplex* pD = NULL; int* piAddrpZ = NULL; doublecomplex* pZ = NULL; int* piAddrpSIGMA = NULL; doublecomplex* pSIGMA = NULL; int* piAddrpWORKev = NULL; doublecomplex* pWORKev = NULL; int* piAddrpRESID = NULL; doublecomplex* pRESID = NULL; int* piAddrpWORKD = NULL; doublecomplex* pV = NULL; int* piAddrpV = NULL; doublecomplex* pWORKD = NULL; int* piAddrpWORKL = NULL; doublecomplex* pWORKL = NULL; int mRVEC, nRVEC; int mHOWMANY, nHOWMANY; int mSELECT, nSELECT; int D, mD, nD; int Z, mZ, nZ; int mSIGMA, nSIGMA; int mWORKev, nWORKev; int mBMAT, nBMAT; int mN, nN; int mWHICH, nWHICH; int mNEV, nNEV; int mTOL, nTOL; int RESID, mRESID, nRESID; int mNCV, nNCV; int mV, nV; int IPARAM, mIPARAM, nIPARAM; int IPNTR, mIPNTR, nIPNTR; int WORKD, mWORKD, nWORKD; int WORKL, mWORKL, nWORKL; int RWORK, mRWORK, nRWORK; int INFO, mINFO, nINFO; int minlhs = 1, minrhs = 21, maxlhs = 9, maxrhs = 21; int LDZ, LDV, LWORKL; int sizeWORKL = 0; CheckInputArgument(pvApiCtx, minrhs, maxrhs); CheckOutputArgument(pvApiCtx, minlhs, maxlhs); /* VARIABLE = NUMBER */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpRVEC); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpRVEC, &mRVEC, &nRVEC, &pRVEC); 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, 3, &piAddrpSELECT); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpSELECT, &mSELECT, &nSELECT, &pSELECT); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrpD); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpD, &mD, &nD, &pD); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4); return 1; } D = 4; sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrpZ); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpZ, &mZ, &nZ, &pZ); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 5); return 1; } Z = 5; sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddrpSIGMA); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 6. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpSIGMA, &mSIGMA, &nSIGMA, &pSIGMA); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 6); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddrpWORKev); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 7. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpWORKev, &mWORKev, &nWORKev, &pWORKev); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 7); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 9, &piAddrpN); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 9. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpN, &mN, &nN, &pN); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 9); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 11, &piAddrpNEV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 11. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpNEV, &mNEV, &nNEV, &pNEV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 11); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 12, &piAddrpTOL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 12. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpTOL, &mTOL, &nTOL, &pTOL); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 12); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 13, &piAddrpRESID); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 13. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpRESID, &mRESID, &nRESID, &pRESID); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 13); return 1; } RESID = 13; sciErr = getVarAddressFromPosition(pvApiCtx, 14, &piAddrpNCV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 14. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpNCV, &mNCV, &nNCV, &pNCV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 14); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 15, &piAddrpV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 15. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpV, &mV, &nV, &pV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 15); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 16, &piAddrpIPARAM); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 16. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpIPARAM, &mIPARAM, &nIPARAM, &pIPARAM); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 16); return 1; } IPARAM = 16; sciErr = getVarAddressFromPosition(pvApiCtx, 17, &piAddrpIPNTR); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 17. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpIPNTR, &mIPNTR, &nIPNTR, &pIPNTR); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 17); return 1; } IPNTR = 17; sciErr = getVarAddressFromPosition(pvApiCtx, 18, &piAddrpWORKD); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 18. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpWORKD, &mWORKD, &nWORKD, &pWORKD); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 18); return 1; } WORKD = 18; sciErr = getVarAddressFromPosition(pvApiCtx, 19, &piAddrpWORKL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 19. sciErr = getComplexZMatrixOfDouble(pvApiCtx, piAddrpWORKL, &mWORKL, &nWORKL, &pWORKL); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 19); return 1; } WORKL = 19; sciErr = getVarAddressFromPosition(pvApiCtx, 20, &piAddrpRWORK); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 20. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpRWORK, &mRWORK, &nRWORK, &pRWORK); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 20); return 1; } RWORK = 20; sciErr = getVarAddressFromPosition(pvApiCtx, 21, &piAddrpINFO); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 21. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpINFO, &mINFO, &nINFO, &pINFO); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 21); return 1; } INFO = 21; LWORKL = mWORKL * nWORKL; LDV = Max(1, pN[0]); LDZ = LDV; /* Check some sizes */ if (mIPARAM*nIPARAM != 11) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "IPARAM", 11); return 1; } if (mIPNTR*nIPNTR != 14) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "IPNTR", 14); return 1; } if (mRESID*nRESID != pN[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "RESID", pN[0]); return 1; } if (mWORKD * nWORKD < 3 * pN[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "WORKD", 3 * pN[0]); return 1; } if (mSELECT*nSELECT != pNCV[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "SELECT", pNCV[0]); return 1; } if (mD*nD != (pNEV[0] + 1)) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "D", pNEV[0] + 1); return 1; } if ((mZ != pN[0]) || (nZ != pNEV[0])) { Scierror(999, _("%s: Wrong size for input argument %s: A matrix of size %dx%d expected.\n"), fname, "Z", pN[0], pNEV[0]); return 1; } if (mWORKev*nWORKev != 2 * pNCV[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "WORKev", 2 * pNCV[0]); return 1; } if ((mV != pN[0]) || (nV != pNCV[0])) { Scierror(999, _("%s: Wrong size for input argument %s: A matrix of size %dx%d expected.\n"), fname, "V", pN[0], pNCV[0]); return 1; } sizeWORKL = 3 * pNCV[0] * pNCV[0] + 5 * pNCV[0]; if ((mWORKL * nWORKL < sizeWORKL)) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "WORKL", sizeWORKL); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrpHOWMANY); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrpHOWMANY, &pHOWMANY)) { Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddrpBMAT); if (sciErr.iErr) { freeAllocatedSingleString(pHOWMANY); printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 8. if (getAllocatedSingleString(pvApiCtx, piAddrpBMAT, &pBMAT)) { freeAllocatedSingleString(pHOWMANY); Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 8); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 10, &piAddrpWHICH); if (sciErr.iErr) { freeAllocatedSingleString(pHOWMANY); freeAllocatedSingleString(pBMAT); printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 10. if (getAllocatedSingleString(pvApiCtx, piAddrpWHICH, &pWHICH)) { freeAllocatedSingleString(pHOWMANY); freeAllocatedSingleString(pBMAT); Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 10); return 1; } C2F(zneupd)(pRVEC, pHOWMANY, pSELECT, pD, pZ, &LDZ, pSIGMA, pWORKev, pBMAT, pN, pWHICH, pNEV, pTOL, pRESID, pNCV, pV, &LDV, pIPARAM, pIPNTR, pWORKD, pWORKL, &LWORKL, pRWORK, pINFO); freeAllocatedSingleString(pHOWMANY); freeAllocatedSingleString(pBMAT); freeAllocatedSingleString(pWHICH); if (pINFO[0] < 0) { C2F(errorinfo)("zneupd", pINFO, 6L); return 0; } AssignOutputVariable(pvApiCtx, 1) = D; AssignOutputVariable(pvApiCtx, 2) = Z; AssignOutputVariable(pvApiCtx, 3) = RESID; AssignOutputVariable(pvApiCtx, 4) = IPARAM; AssignOutputVariable(pvApiCtx, 5) = IPNTR; AssignOutputVariable(pvApiCtx, 6) = WORKD; AssignOutputVariable(pvApiCtx, 7) = WORKL; AssignOutputVariable(pvApiCtx, 8) = RWORK; AssignOutputVariable(pvApiCtx, 9) = INFO; ReturnArguments(pvApiCtx); return 0; }
/*--------------------------------------------------------------------------*/ int sci_dnaupd(char *fname, void *pvApiCtx) { SciErr sciErr; int* piAddrpIDO = NULL; int* pIDO = NULL; int* piAddrpBMAT = NULL; char* pBMAT = NULL; int* piAddrpN = NULL; int* pN = NULL; int* piAddrpWHICH = NULL; char* pWHICH = NULL; int* piAddrpNEV = NULL; int* pNEV = NULL; int* piAddrpTOL = NULL; double* pTOL = NULL; int* piAddrpRESID = NULL; double* pRESID = NULL; int* piAddrpNCV = NULL; int* pNCV = NULL; int* piAddrpV = NULL; double* pV = NULL; int* piAddrpIPARAM = NULL; int* pIPARAM = NULL; int* piAddrpIPNTR = NULL; int* pIPNTR = NULL; int* piAddrpWORKD = NULL; double* pWORKD = NULL; int* piAddrpWORKL = NULL; double* pWORKL = NULL; int* piAddrpINFO = NULL; int* pINFO = NULL; int IDO, mIDO, nIDO; int mN, nN; int mNEV, nNEV; int mTOL, nTOL; int RESID, mRESID, nRESID; int mNCV, nNCV; int V, mV, nV; int IPARAM, mIPARAM, nIPARAM; int IPNTR, mIPNTR, nIPNTR; int WORKD, mWORKD, nWORKD; int WORKL, mWORKL, nWORKL; int INFO, mINFO, nINFO; int minlhs = 1, minrhs = 14, maxlhs = 8, maxrhs = 14; int LDV, LWORKL; int sizeWORKL = 0; /* [IDO,RESID,V,IPARAM,IPNTR,WORKD,WORKL,INFO]=dnaupd... (ID0,BMAT,N,WHICH,NEV,TOL,RESID,NCV,V,IPARAM,IPNTR,WORKD,WORKL,INFO) */ CheckInputArgument(pvApiCtx, minrhs, maxrhs); CheckOutputArgument(pvApiCtx, minlhs, maxlhs); /* VARIABLE = NUMBER */ sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpIDO); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 1. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpIDO, &mIDO, &nIDO, &pIDO); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1); return 1; } IDO = 1; sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrpN); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 3. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpN, &mN, &nN, &pN); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrpNEV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 5. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpNEV, &mNEV, &nNEV, &pNEV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddrpTOL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 6. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpTOL, &mTOL, &nTOL, &pTOL); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 6); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddrpRESID); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 7. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpRESID, &mRESID, &nRESID, &pRESID); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 7); return 1; } RESID = 7; sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddrpNCV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 8. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpNCV, &mNCV, &nNCV, &pNCV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 8); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 9, &piAddrpV); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 9. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpV, &mV, &nV, &pV); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 9); return 1; } V = 9; sciErr = getVarAddressFromPosition(pvApiCtx, 10, &piAddrpIPARAM); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 10. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpIPARAM, &mIPARAM, &nIPARAM, &pIPARAM); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 10); return 1; } IPARAM = 10; sciErr = getVarAddressFromPosition(pvApiCtx, 11, &piAddrpIPNTR); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 11. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpIPNTR, &mIPNTR, &nIPNTR, &pIPNTR); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 11); return 1; } IPNTR = 11; sciErr = getVarAddressFromPosition(pvApiCtx, 12, &piAddrpWORKD); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 12. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpWORKD, &mWORKD, &nWORKD, &pWORKD); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 12); return 1; } WORKD = 12; sciErr = getVarAddressFromPosition(pvApiCtx, 13, &piAddrpWORKL); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 13. sciErr = getMatrixOfDouble(pvApiCtx, piAddrpWORKL, &mWORKL, &nWORKL, &pWORKL); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 13); return 1; } WORKL = 13; sciErr = getVarAddressFromPosition(pvApiCtx, 14, &piAddrpINFO); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 14. sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddrpINFO, &mINFO, &nINFO, &pINFO); if (sciErr.iErr) { printError(&sciErr, 0); Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 14); return 1; } INFO = 14; LWORKL = mWORKL * nWORKL; LDV = Max(1, pN[0]); /* Don't call dnaupd if ido == 99 */ if (pIDO[0] == 99) { Scierror(999, _("%s: the computation is already terminated\n"), fname); return 1; } /* Check some sizes */ if (mIPARAM*nIPARAM != 11) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "IPARAM", 11); return 1; } if (mIPNTR*nIPNTR != 14) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "IPNTR", 14); return 1; } if (mRESID*nRESID != pN[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "RESID", *(int*)(pN)); return 1; } if ((mV != pN[0]) || (nV != pNCV[0])) { Scierror(999, _("%s: Wrong size for input argument %s: A matrix of size %dx%d expected.\n"), fname, "V", *(int*)(pN), *(int*)(pNCV)); return 1; } if (mWORKD * nWORKD < 3 * pN[0]) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "WORKD", 3 * *(int*)(pN)); return 1; } sizeWORKL = 3 * pNCV[0] * pNCV[0] + 6 * pNCV[0]; if (mWORKL * nWORKL < sizeWORKL) { Scierror(999, _("%s: Wrong size for input argument %s: An array of size %d expected.\n"), fname, "WORKL", sizeWORKL); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrpBMAT); if (sciErr.iErr) { printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 2. if (getAllocatedSingleString(pvApiCtx, piAddrpBMAT, &pBMAT)) { Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2); return 1; } sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrpWHICH); if (sciErr.iErr) { freeAllocatedSingleString(pBMAT); printError(&sciErr, 0); return 1; } // Retrieve a matrix of double at position 4. if (getAllocatedSingleString(pvApiCtx, piAddrpWHICH, &pWHICH)) { freeAllocatedSingleString(pBMAT); Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4); return 1; } C2F(dnaupd)(pIDO, pBMAT, pN, pWHICH, pNEV, pTOL, pRESID, pNCV, pV, &LDV, pIPARAM, pIPNTR, pWORKD, pWORKL, &LWORKL, pINFO, 1L, 2L); freeAllocatedSingleString(pBMAT); freeAllocatedSingleString(pWHICH); if (*pINFO < 0) { Scierror(998, _("%s: internal error, info=%d.\n"), fname, *pINFO); return 0; } AssignOutputVariable(pvApiCtx, 1) = IDO; AssignOutputVariable(pvApiCtx, 2) = RESID; AssignOutputVariable(pvApiCtx, 3) = V; AssignOutputVariable(pvApiCtx, 4) = IPARAM; AssignOutputVariable(pvApiCtx, 5) = IPNTR; AssignOutputVariable(pvApiCtx, 6) = WORKD; AssignOutputVariable(pvApiCtx, 7) = WORKL; AssignOutputVariable(pvApiCtx, 8) = INFO; 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; }