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