add some Scierror after printError to create an error in Scilab
[scilab.git] / scilab / modules / signal_processing / sci_gateway / c / sci_conv2.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - INRIA - Serge STEER
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 /*--------------------------------------------------------------------------*/
13 #include "core_math.h"
14 #include "stack-c.h"
15 #include "gw_signal.h"
16 #include "MALLOC.h"
17 #include "api_scilab.h"
18 #include "localization.h"
19 #include "Scierror.h"
20 #include "conv2.h"
21 /*--------------------------------------------------------------------------*/
22 int sci_conv2(char *fname,unsigned long fname_len)
23 {
24     SciErr sciErr;
25     int *piAddr = NULL;
26     char *option = NULL;
27     int iopt = 1;
28     double *Outr = NULL,*Outi = NULL;
29     int mOut = 0, nOut = 0;
30     int iType = 0;
31     int edgM = 0, edgN = 0;
32     int rhs = Rhs;
33
34     /* Check if last argument is one of the string "full", "same","valid" */
35     sciErr = getVarAddressFromPosition(pvApiCtx, Rhs, &piAddr);
36     if(sciErr.iErr)
37     {
38         printError(&sciErr, 0);
39         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, Rhs);
40         return 0;
41     }
42
43     if (isStringType(pvApiCtx, piAddr)) 
44     {
45         CheckRhs(3,4);
46         if(isScalar(pvApiCtx, piAddr)) 
47         {
48             if (getAllocatedSingleString(pvApiCtx, piAddr, &option)==0) 
49             {
50                 if (strcmp("full", option) == 0) 
51                 {
52                     iopt=1;
53                 }
54                 else if (strcmp("same", option) == 0) 
55                 {
56                     iopt=2;
57                 }
58                 else if (strcmp("valid", option) == 0) 
59                 {
60                     iopt=3;
61                 }
62                 else 
63                 {
64                     Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), 
65                         fname, Rhs, "\"full\", \"same\"","\"valid\"");
66                     freeAllocatedSingleString(option);
67                     option = NULL;
68                     return 0;
69                 }
70                 freeAllocatedSingleString(option);
71                 option = NULL;
72                 rhs=Rhs-1;
73             }
74             else 
75             {
76                 Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), 
77                     fname, Rhs, "\"full\", \"same\"","\"valid\"");
78                 return 0;
79             }
80         }
81     }
82     else 
83     {
84         CheckRhs(2,3); 
85     }
86
87     if (rhs==3) 
88     { 
89         /*separable conv2(C,R,A)*/
90         double *Cr = NULL,*Ci = NULL;
91         double *Rr = NULL,*Ri = NULL;
92         double *Ar = NULL,*Ai = NULL;
93         int mC = 0, nC = 0, mR = 0, nR = 0, mA = 0, nA = 0;
94
95         /* get and check C */
96         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
97         if(sciErr.iErr)
98         {
99             printError(&sciErr, 0);
100             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
101             return 0;
102         }
103
104         //check type
105         sciErr = getVarType(pvApiCtx, piAddr, &iType);
106         if(sciErr.iErr)
107         {
108             printError(&sciErr, 0);
109             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
110             return 0;
111         }
112
113         if(iType != sci_matrix)
114         {
115             Scierror(999,_("%s: Wrong type for argument %d: Real vector expected.\n"), 
116                 fname, 1);
117             return 0;
118         }
119
120         //get complexity
121         if (isVarComplex(pvApiCtx, piAddr)) 
122         {
123             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mC, &nC, &Cr, &Ci);
124             if(sciErr.iErr)
125             {
126                 printError(&sciErr, 0);
127                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
128                 return 0;
129             }
130
131         }
132         else 
133         {
134             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mC, &nC, &Cr);
135             if(sciErr.iErr)
136             {
137                 printError(&sciErr, 0);
138                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
139                 return 0;
140             }
141
142         }
143         if (mC>1 && nC>1) 
144         { 
145             /*check if vector*/
146             Scierror(999,_("%s: Wrong type for argument %d: Real or complex vector expected.\n"), 
147                 fname, 1);
148             return 0;
149         }
150         mC = mC*nC;
151
152         /* get and check R */
153         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
154         if(sciErr.iErr)
155         {
156             printError(&sciErr, 0);
157             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
158             return 0;
159         }
160
161         //check type
162         sciErr = getVarType(pvApiCtx, piAddr, &iType);
163         if(sciErr.iErr)
164         {
165             printError(&sciErr, 0);
166             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
167             return 0;
168         }
169
170         if(iType != sci_matrix)
171         {
172             Scierror(999,_("%s: Wrong type for argument %d: Real or complex vector expected.\n"), 
173                 fname, 2);
174             return 0;
175         }
176
177         //get complexity
178         if (isVarComplex(pvApiCtx, piAddr)) 
179         {
180             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mR, &nR, &Rr, &Ri);
181             if(sciErr.iErr)
182             {
183                 printError(&sciErr, 0);
184                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
185                 return 0;
186             }
187
188         }
189         else 
190         {
191             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mR, &nR, &Rr);
192             if(sciErr.iErr)
193             {
194                 printError(&sciErr, 0);
195                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
196                 return 0;
197             }
198
199         }
200
201         if (mR>1 && nR>1) 
202         { 
203             /*check if vector*/
204             Scierror(999,_("%s: Wrong type for argument %d: Real vector expected.\n"), 
205                 fname, 2);
206             return 0;
207         }
208
209         nR = nR*mR;
210         /* get and check A */
211         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
212         if(sciErr.iErr)
213         {
214             printError(&sciErr, 0);
215             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
216             return 0;
217         }
218
219         //check type
220         sciErr = getVarType(pvApiCtx, piAddr, &iType);
221         if(sciErr.iErr)
222         {
223             printError(&sciErr, 0);
224             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
225             return 0;
226         }
227
228         if(iType != sci_matrix)
229         {
230             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), 
231                 fname, 3);
232             return 0;
233         }
234
235         //get complexity
236         if (isVarComplex(pvApiCtx, piAddr)) 
237         {
238             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar, &Ai);
239             if(sciErr.iErr)
240             {
241                 printError(&sciErr, 0);
242                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
243                 return 0;
244             }
245
246         }
247         else 
248         {
249             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar);
250             if(sciErr.iErr)
251             {
252                 printError(&sciErr, 0);
253                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
254                 return 0;
255             }
256
257         }
258
259         //Compute result sizes
260         if (iopt == 1 ) 
261         {
262             if (mC==0||nR==0) 
263             {
264                 mOut= mA;
265                 nOut= nA;
266             }
267             else 
268             {
269                 mOut= mA + mC - 1;
270                 nOut= nA + nR - 1;
271             }
272             edgM= mC - 1;
273             edgN= nR - 1;
274         } 
275         else if ( iopt == 2 ) 
276         {
277             mOut= mA;
278             nOut= nA;
279             edgM= ( mC - 1) /2;
280             edgN= ( nR - 1) /2;
281         }
282         else if (iopt==3) 
283         {
284             if (mC==0||nR==0) 
285             {
286                 mOut= mA;
287                 nOut= nA;
288             }
289             else 
290             {
291                 mOut= Max(0,mA - mC + 1);
292                 nOut= Max(0,nA - nR + 1);
293             }
294             edgM = edgN= 0;
295         }
296
297         if (Ri==NULL&&Ci==NULL&&Ai==NULL)
298         { 
299             //real case
300             double *Tr = NULL;
301             //Allocate result
302             sciErr = allocMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr);
303             if(sciErr.iErr)
304             {
305                 printError(&sciErr, 0);
306                 return 0;
307             }
308
309             sciErr = allocMatrixOfDouble(pvApiCtx,Rhs+2,1,nA,&Tr);
310             if(sciErr.iErr)
311             {
312                 printError(&sciErr, 0);
313                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
314                 return 0;
315             }
316
317             conv2_separable_R(Rr,nR,Cr,mC,Ar,mA,nA,Outr,mOut,nOut,edgM,edgN,Tr);
318         }
319         else 
320         {
321             double *Tr = NULL,*Ti = NULL;
322             //Allocate result
323             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr,&Outi);
324             if(sciErr.iErr)
325             {
326                 printError(&sciErr, 0);
327                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
328                 return 0;
329             }
330
331             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+2,1,nA,&Tr,&Ti);
332             if(sciErr.iErr)
333             {
334                 printError(&sciErr, 0);
335                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
336                 return 0;
337             }
338
339             conv2_separable_C(Rr,Ri,nR,Cr,Ci,mC,Ar,Ai,mA,nA,Outr,Outi,mOut,nOut,edgM,edgN,Tr,Ti);
340         }
341     }
342     else 
343     {
344         /*conv2(A,B)*/
345         double *Ar = NULL,*Ai = NULL;
346         double *Br = NULL,*Bi = NULL;
347         int mA,nA,mB,nB;
348
349         /* get and check A */
350         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
351         if(sciErr.iErr)
352         {
353             printError(&sciErr, 0);
354             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
355             return 0;
356         }
357
358         //check type
359         sciErr = getVarType(pvApiCtx, piAddr, &iType);
360         if(sciErr.iErr)
361         {
362             printError(&sciErr, 0);
363             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
364             return 0;
365         }
366
367         if(iType != sci_matrix)
368         {
369             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), 
370                 fname, 1);
371             return 0;
372         }
373
374         //get complexity
375         if (isVarComplex(pvApiCtx, piAddr)) 
376         {
377             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar, &Ai);
378             if(sciErr.iErr)
379             {
380                 printError(&sciErr, 0);
381                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
382                 return 0;
383             }
384
385         }
386         else 
387         {
388             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar);
389             if(sciErr.iErr)
390             {
391                 printError(&sciErr, 0);
392                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
393                 return 0;
394             }
395
396         }
397
398         /* get and check B */
399         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
400         if(sciErr.iErr)
401         {
402             printError(&sciErr, 0);
403             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
404             return 0;
405         }
406
407         //check type
408         sciErr = getVarType(pvApiCtx, piAddr, &iType);
409         if(sciErr.iErr)
410         {
411             printError(&sciErr, 0);
412             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
413             return 0;
414         }
415
416         if(iType != sci_matrix)
417         {
418             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"), 
419                 fname, 2);
420             return 0;
421         }
422
423         //get complexity
424         if (isVarComplex(pvApiCtx, piAddr)) 
425         {
426             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mB, &nB, &Br, &Bi);
427             if(sciErr.iErr)
428             {
429                 printError(&sciErr, 0);
430                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
431                 return 0;
432             }
433
434         }
435         else 
436         {
437             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mB, &nB, &Br);
438             if(sciErr.iErr)
439             {
440                 printError(&sciErr, 0);
441                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
442                 return 0;
443             }
444
445         }
446
447         if (iopt==1) 
448         {
449             if (mA==0) 
450             {
451                 mOut= mB;
452                 nOut= nB;
453             }
454             else if (mB ==0) 
455             {
456                 mOut= mA;
457                 nOut= nA;
458             }
459             else  
460             { 
461                 mOut= mA + Max(0,mB - 1);
462                 nOut= nA +  Max(0,nB - 1);
463             }
464             edgM= mB - 1;
465             edgN= nB - 1;
466         } 
467         else if (iopt==2) 
468         {
469             mOut= mA;
470             nOut= nA;
471             edgM= ( mB - 1) /2;
472             edgN= ( nB - 1) /2;
473         } 
474         else if (iopt==3) 
475         {
476             if (mB ==0) 
477             {
478                 mOut=mA;
479                 nOut=nA;
480             }
481             else 
482             {
483                 mOut= Max(0,mA - mB + 1);
484                 nOut= Max(0,nA - nB + 1);
485             }
486             edgM= edgN= 0;
487         } 
488
489         if (Ai==NULL&&Bi==NULL)
490         { 
491             //real case
492             //Allocate result
493             sciErr = allocMatrixOfDouble(pvApiCtx, Rhs+1,mOut,nOut,&Outr);
494             if(sciErr.iErr)
495             {
496                 printError(&sciErr, 0);
497                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
498                 return 0;
499             }
500
501             conv2_R(Ar,mA,nA,Br,mB,nB,Outr,mOut,nOut,edgM,edgN);
502         }
503         else 
504         {
505             //Allocate result
506             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr,&Outi);
507             if(sciErr.iErr)
508             {
509                 printError(&sciErr, 0);
510                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
511                 return 0;
512             }
513
514             conv2_C(Ar,Ai,mA,nA,Br,Bi,mB,nB,Outr,Outi,mOut,nOut,edgM,edgN);
515         }
516     }
517
518     LhsVar(1) = Rhs+1; 
519     PutLhsVar();
520     return 0;
521 }
522 /*--------------------------------------------------------------------------*/