scilab/contrib/toolbox_skeleton/sci_gateway/c/sci_foo.c

   1 /* ==================================================================== */
   2 /* Template toolbox_skeleton */
   3 /* Example detail in "API_scilab getting started" help page */
   4 /* This file is released under the 3-clause BSD license. See COPYING-BSD. */
   5 /* ==================================================================== */
   6 #include "api_scilab.h"
   7 #include "BOOL.h"
   8 #include <localization.h>
   9
  10 /* ==================================================================== */
  11 int sci_foo(char *fname, unsigned long fname_len)
  12 {
  13     // Error management variable
  14     SciErr sciErr;
  15
  16     ////////// Variables declaration //////////
  17     int m1 = 0, n1 = 0;
  18     int *piAddressVarOne = NULL;
  19     double *matrixOfDouble = NULL;
  20     double *newMatrixOfDouble = NULL;
  21
  22     int m2 = 0, n2 = 0;
  23     int *piAddressVarTwo = NULL;
  24     int *matrixOfBoolean = NULL;
  25     int *newMatrixOfBoolean = NULL;
  26     int i = 0;
  27
  28
  29     ////////// Check the number of input and output arguments //////////
  30     /* --> [c, d] = foo(a, b) */
  31     /* check that we have only 2 input arguments */
  32     /* check that we have only 2 output argument */
  33     CheckInputArgument(pvApiCtx, 2, 2) ;
  34     CheckOutputArgument(pvApiCtx, 2, 2) ;
  35
  36
  37     ////////// Manage the first input argument (double) //////////
  38     /* get Address of inputs */
  39     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
  40     if (sciErr.iErr)
  41     {
  42         printError(&sciErr, 0);
  43         return 0;
  44     }
  45
  46     /* Check that the first input argument is a real matrix (and not complex) */
  47     if ( !isDoubleType(pvApiCtx, piAddressVarOne) ||  isVarComplex(pvApiCtx, piAddressVarOne) )
  48     {
  49         Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 1);
  50         return 0;
  51     }
  52
  53     /* get matrix */
  54     sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &matrixOfDouble);
  55     if (sciErr.iErr)
  56     {
  57         printError(&sciErr, 0);
  58         return 0;
  59     }
  60
  61     ////////// Manage the second input argument (boolean) //////////
  62
  63     /* get Address of inputs */
  64     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
  65     if (sciErr.iErr)
  66     {
  67         printError(&sciErr, 0);
  68         return 0;
  69     }
  70
  71     if ( !isBooleanType(pvApiCtx, piAddressVarTwo) )
  72     {
  73         Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, 2);
  74         return 0;
  75     }
  76
  77     /* get matrix */
  78     sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &matrixOfBoolean);
  79     if (sciErr.iErr)
  80     {
  81         printError(&sciErr, 0);
  82         return 0;
  83     }
  84
  85     ////////// Check the consistency of the two input arguments //////////
  86
  87     if ((m1 != m2) | - (n1 != n2))
  88     {
  89         Scierror(999, _("%s: Wrong size for input arguments: Same size expected.\n"), fname, 1);
  90         return 0;
  91     }
  92
  93
  94     newMatrixOfDouble = (double*)malloc(sizeof(double) * m1 * n1);
  95     ////////// Application code //////////
  96     // Could be replaced by a call to a library
  97
  98     for (i = 0; i < m1 * n1; i++)
  99     {
 100         /* For each element of the matrix, multiply by 2 */
 101         newMatrixOfDouble[i] = matrixOfDouble[i] * 2;
 102     }
 103
 104     newMatrixOfBoolean = (int*)malloc(sizeof(double) * m2 * n2);
 105     for (i = 0; i < m2 * n2; i++)
 106     {
 107         /* For each element of the matrix, invert the value */
 108         newMatrixOfBoolean[i] = matrixOfBoolean[i] == TRUE ? FALSE : TRUE;
 109     }
 110
 111     ////////// Create the output arguments //////////
 112
 113     /* Create the matrix as return of the function */
 114     sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, newMatrixOfDouble);
 115     if (sciErr.iErr)
 116     {
 117         printError(&sciErr, 0);
 118         return 0;
 119     }
 120
 121     /* Create the matrix as return of the function */
 122     sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m2, n2, newMatrixOfBoolean);
 123     if (sciErr.iErr)
 124     {
 125         printError(&sciErr, 0);
 126         return 0;
 127     }
 128
 129     ////////// Return the output arguments to the Scilab engine //////////
 130
 131     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
 132     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
 133
 134     ReturnArguments(pvApiCtx);
 135
 136     return 0;
 137 }
 138 /* ==================================================================== */
 139