/*--------------------------------------------------------------------------*/
int sci_contour2di(char * fname, void* pvApiCtx)
{
SciErr sciErr;
int flagx = 0, nz = 10; /* default number of level curves : 10 */
int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
double* hl1 = NULL;
double* hl2 = NULL;
double* znz = NULL;
int ix4, i = 0, un = 1;
int* piAddr1 = NULL;
int* piAddr2 = NULL;
int* piAddr3 = NULL;
int* piAddr4 = NULL;
double* l1 = NULL;
double* l2 = NULL;
double* l3 = NULL;
double* l4 = NULL;
int* l5 = NULL;
CheckInputArgument(pvApiCtx, 4, 4);
CheckOutputArgument(pvApiCtx, 2, 2);
//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, &m1, &n1, &l1);
if (sciErr.iErr)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
printError(&sciErr, 0);
return 1;
}
//CheckVector
if (m1 != 1 && n1 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 1);
return 1;
}
//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, &m2, &n2, &l2);
if (sciErr.iErr)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
printError(&sciErr, 0);
return 1;
}
//CheckVector
if (m2 != 1 && n2 != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
return 1;
}
//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, &m3, &n3, &l3);
if (sciErr.iErr)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
printError(&sciErr, 0);
return 1;
}
if (m3 * n3 == 0)
{
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
if (m3 == 1 || n3 == 1)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix expected.\n"), fname, 3);
return 1;
}
//CheckDimProp
if (m1 * n1 != m3)
{
Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
return 1;
}
//CheckDimProp
if (m2 * n2 != n3)
{
Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
return 1;
}
/* number of level curves */
//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, &m4, &n4, &l4);
if (sciErr.iErr)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
printError(&sciErr, 0);
return 1;
}
if (m4 * n4 == 1)
{
flagx = 0;
nz = Max(1, (int) * (l4));
znz = (l4);
}
else
{
flagx = 1;
nz = m4 * n4;
znz = (l4);
}
ix4 = Max(nz, 2);
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 5, un, ix4, &l5);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
for (i = 0 ; i < ix4 ; ++i)
{
l5[i] = i + 1;
}
if (nz == 1)
{
l5[1] = 1;
}
if (C2F(contourif)(l1, l2, l3, &m3, &n3, &flagx, &nz, znz, l5) != 0)
{
/* Something wrong happened */
return -1;
}
C2F(getconts)(&hl1, &hl2, &m1, &n1);
if (n1 == 0)
{
sciErr = allocMatrixOfDouble(pvApiCtx, 6, n1, n1, &hl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = allocMatrixOfDouble(pvApiCtx, 7, n1, n1, &hl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, 6, m1, n1, hl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = createMatrixOfDouble(pvApiCtx, 7, m1, n1, hl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
AssignOutputVariable(pvApiCtx, 1) = 6;
AssignOutputVariable(pvApiCtx, 2) = 7;
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_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;
}
/*--------------------------------------------------------------------------*/
static int xlfont_one_rhs(char * fname)
{
SciErr sciErr;
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
int* piAddrl1 = NULL;
int* l1 = NULL;
char* strl1 = NULL;
int m1 = 0, n1 = 0;
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, &strl1))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
if (strcmp(strl1, "AVAILABLE_FONTS") == 0)
{
int nbElements = 0;
char **fontsname = getAvailableFontsName(&nbElements);
m1 = nbElements;
n1 = 1;
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, (const char * const*)fontsname);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
freeArrayOfString(fontsname, nbElements);
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else if (strcmp(strl1, "reset") == 0)
{
resetFontManager();
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
else
{
if (isAvailableFontsName(strl1))
{
int fontID = addFont(strl1);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = fontID;
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else if (FileExist(strl1))
{
int fontID = addFontFromFilename(strl1);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = fontID;
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: A valid fontname expected.\n"), fname, 1);
}
}
freeAllocatedSingleString(strl1);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
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;
}
/*--------------------------------------------------------------------------*/
static int xlfont_n_rhs(char * fname)
{
SciErr sciErr;
BOOL isBold = FALSE;
BOOL isItalic = FALSE;
if (nbInputArgument(pvApiCtx) == 3)
{
int m3 = 0, n3 = 0;
int* piAddrl3 = NULL;
int* l3 = NULL;
if ((!checkInputArgumentType(pvApiCtx, 3, sci_boolean)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 3.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrl3, &m3, &n3, &l3);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 3);
return 1;
}
isBold = (BOOL) * l3;
}
if (nbInputArgument(pvApiCtx) == 4)
{
int m4 = 0, n4 = 0;
int* piAddrl4 = NULL;
int* l4 = NULL;
if ((!checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 4.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrl4, &m4, &n4, &l4);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 4);
return 1;
}
isItalic = (BOOL) * l4;
}
if (((checkInputArgumentType(pvApiCtx, 1, sci_strings))) && ((checkInputArgumentType(pvApiCtx, 2, sci_matrix))))
{
int m1 = 0, n1 = 0;
int m2 = 0, n2 = 0;
char* strl1 = NULL;
double* l2 = NULL;
int* l1 = NULL;
int* piAddrl1 = NULL;
int* piAddrl2 = NULL;
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, &strl1))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string 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;
}
if ((m2 == 1) && (n2 == 1))
{
int fontIndex = (int)l2[0];
char *fontname = strl1;
if (fontIndex < 0)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Non-negative int expected.\n"), fname, 2);
return 0;
}
if ((nbInputArgument(pvApiCtx) == 2) && FileExist(fontname))
{
int Id = changeFontFromFilename(fontIndex, fontname);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = Id;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
}
else if (isAvailableFontsName(fontname))
{
int Id = changeFontWithProperty(fontIndex, fontname, isBold, isItalic);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = Id;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: A valid fontname expected.\n"), fname, 1);
}
}
else
{
Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 2);
}
freeAllocatedSingleString(strl1);
}
else
{
if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
{
Scierror(999, _("%s: Wrong type for input argument #%d: Non-negative int expected.\n"), fname, 2);
return 0;
}
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_glue(char * fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddrl1 = NULL;
long long* l1 = NULL;
double* l2 = NULL;
int* lind = NULL;
long long* outindex = NULL;
int numrow = 0, numcol = 0, n = 0, cx1 = 1;
int *pObj = NULL;
int i = 0;
int iCompoundUID = 0;
int iParentUID = 0;
int iCurrentParentUID = 0;
int* piCurrentParentUID = &iCurrentParentUID;
int iObjUID = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
/* set or create a graphic window */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &numrow, &numcol, &l1); /* We get the scalar value if it is ones */
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
n = numrow * numcol;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &l2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numrow, numcol, &lind);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
if (n > 1)
{
C2F(dcopy)(&n, (double*)l1, &cx1, l2, &cx1);
C2F(dsort)(l2, &n, (int*)(lind));
for (i = 1; i < n; i++)
{
long long i1 = ((long long*)l2)[i];
long long i2 = ((long long*)l2)[i - 1];
if (i1 == i2)
{
Scierror(999, _("%s: Each handle should not appear twice.\n"), fname);
return 0;
}
}
}
/* we must change the pobj to the Compound type */
pObj = (int*)MALLOC(n * sizeof(int));
for (i = 0 ; i < n ; i++)
{
iObjUID = getObjectFromHandle((long)l1[i]);
pObj[i] = iObjUID;
if (iObjUID == 0)
{
FREE(pObj);
Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
return 0;
}
iCurrentParentUID = getParentObject(iObjUID);
//getGraphicObjectProperty(iObjUID, __GO_PARENT__, jni_string, (void **)&piCurrentParentUID);
if (i == 0)
{
iParentUID = iCurrentParentUID;
}
if (iParentUID != iCurrentParentUID)
{
FREE(pObj);
Scierror(999, _("%s: Objects must have the same parent.\n"), fname);
return 0;
}
}
//ret = CheckForCompound (handelsvalue, n);
//if (ret>0)
//{
// MEM LEAK
// Scierror(999,_("%s: Handle %d cannot be glued (invalid parent).\n"),fname,ret);
// return 0;
//}
//if (ret<0)
//{
// MEM LEAK
// Scierror(999,_("%s: Handle %d cannot be glued (invalid type).\n"),fname,-ret);
// return 0;
//}
iCompoundUID = createCompound(iParentUID, pObj, n);
setCurrentObject(iCompoundUID);
numrow = 1;
numcol = 1;
sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 3, numrow, numcol, &outindex);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
outindex[0] = getHandle(iCompoundUID);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 3;
ReturnArguments(pvApiCtx);
FREE(pObj);
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_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;
}
