1 /*
2 * -------------------------------------------------------------------------
3 * dwt_validate.c -- DWT validation
4 * SWT - Scilab wavelet toolbox
5 * Copyright (C) 2005-2006 Roger Liu
6 * Copyright (C) 20010-2012 Holger Nahrstaedt
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * -------------------------------------------------------------------------
22 */
23 #include "swtlib.h"
24 #include "swt_gwsupport.h"
25 #include "api_scilab.h"
26 #include "Scierror.h"
27 //#include "localization.h"
28 //#include "warningmode.h"
29 #include "sciprint.h"
30
31
32 void
dwt_print()33 dwt_print ()
34 {
35 sciprint("\n**********************************************\n");
36 switch (getdwtMode()) {
37 case ZPD:
38 {
39 sciprint("** DWT Extension Mode: Zero Padding **\n");
40 break;
41 }
42 case SYMH:
43 {
44 sciprint("** DWT Extension Mode: Half Symmetrization **\n");
45 break;
46 }
47 case SYMW:
48 {
49 sciprint("** DWT Extension Mode: Whole Symmetrization **\n");
50 break;
51 }
52 case ASYMH:
53 {
54 sciprint("** DWT Extension Mode: Half Asymmetrization **\n");
55 break;
56 }
57 case ASYMW:
58 {
59 sciprint("** DWT Extension Mode: Whole Asymmetrization**\n");
60 break;
61 }
62 case SP0:
63 {
64 sciprint("** DWT Extension Mode: order 0 smooth padding*\n");
65 break;
66 }
67 case SP1:
68 {
69 sciprint("** DWT Extension Mode: order 1 smooth padding*\n");
70 break;
71 }
72 case PPD:
73 {
74 sciprint("** DWT Extension Mode: Periodic Padding **\n");
75 break;
76 }
77 case PER:
78 {
79 sciprint("** DWT Extension Mode: Periodization **\n");
80 break;
81 }
82 default:
83 break;
84 }
85 sciprint("**********************************************\n");
86 return;
87 }
88
89
90 /*-------------------------------------------
91 * orthfilt validation
92 *-----------------------------------------*/
93
94 void
orthfilt_form_validate(void * pvApiCtx,int * errCode)95 orthfilt_form_validate (void * pvApiCtx, int *errCode)
96 {
97 *errCode = SUCCESS;
98 if (!sci_matrix_vector_real(pvApiCtx,1))
99 *errCode = UNKNOWN_INPUT_ERR;
100 return;
101 }
102
103 /*-------------------------------------------
104 * biorthfilt validation
105 *-----------------------------------------*/
106
107 void
biorfilt_form_validate(void * pvApiCtx,int * errCode)108 biorfilt_form_validate (void * pvApiCtx, int *errCode)
109 {
110 *errCode = SUCCESS;
111 if ((!sci_matrix_vector_real(pvApiCtx,1)) || (!sci_matrix_vector_real(pvApiCtx,2)))
112 *errCode = UNKNOWN_INPUT_ERR;
113 return;
114 }
115
116 /*-------------------------------------------
117 * dbwavf validation
118 *-----------------------------------------*/
119
120 void
dbwavf_form_validate(void * pvApiCtx,int * errCode)121 dbwavf_form_validate (void * pvApiCtx, int *errCode)
122 {
123 *errCode = SUCCESS;
124 if (!sci_strings_scalar(pvApiCtx,1))
125 *errCode = UNKNOWN_INPUT_ERR;
126 return;
127 }
128
129 void
dbwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)130 dbwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
131 {
132 int type;
133 *errCode = SUCCESS;
134 wavelet_family_check(wname,DAUBECHIES,&type);
135 if (!type)
136 *errCode = WAVELET_NAME_NOT_VALID;
137 return;
138 }
139
140
141 /*-------------------------------------------
142 * coifwavf validation
143 *-----------------------------------------*/
144
145 void
coifwavf_form_validate(void * pvApiCtx,int * errCode)146 coifwavf_form_validate (void * pvApiCtx, int *errCode)
147 {
148 *errCode = SUCCESS;
149 if (!sci_strings_scalar(pvApiCtx,1))
150 *errCode = UNKNOWN_INPUT_ERR;
151 return;
152 }
153
154 void
coifwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)155 coifwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
156 {
157 int type;
158 *errCode = SUCCESS;
159 wavelet_family_check(wname,COIFLETS,&type);
160 if (!type)
161 *errCode = WAVELET_NAME_NOT_VALID;
162 return;
163 }
164
165
166
167 /*-------------------------------------------
168 * symwavf validation
169 *-----------------------------------------*/
170
171 void
symwavf_form_validate(void * pvApiCtx,int * errCode)172 symwavf_form_validate (void * pvApiCtx, int *errCode)
173 {
174 *errCode = SUCCESS;
175 if (!sci_strings_scalar(pvApiCtx,1))
176 *errCode = UNKNOWN_INPUT_ERR;
177 return;
178 }
179
180 void
symwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)181 symwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
182 {
183 int type;
184 *errCode = SUCCESS;
185 wavelet_family_check(wname,SYMLETS,&type);
186 if (!type)
187 *errCode = WAVELET_NAME_NOT_VALID;
188 return;
189 }
190
191 /*-------------------------------------------
192 * legdwavf validation
193 *-----------------------------------------*/
194
195 void
legdwavf_form_validate(void * pvApiCtx,int * errCode)196 legdwavf_form_validate (void * pvApiCtx, int *errCode)
197 {
198 *errCode = SUCCESS;
199 if (!sci_strings_scalar(pvApiCtx,1))
200 *errCode = UNKNOWN_INPUT_ERR;
201 return;
202 }
203
204 void
legdwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)205 legdwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
206 {
207 int type;
208 *errCode = SUCCESS;
209 wavelet_family_check(wname,LEGENDRE,&type);
210 if (!type)
211 *errCode = WAVELET_NAME_NOT_VALID;
212 return;
213 }
214
215
216 /*-------------------------------------------
217 * biorwavf validation
218 *-----------------------------------------*/
219
220 void
biorwavf_form_validate(void * pvApiCtx,int * errCode)221 biorwavf_form_validate (void * pvApiCtx, int *errCode)
222 {
223 *errCode = SUCCESS;
224 if (!sci_strings_scalar(pvApiCtx,1))
225 *errCode = UNKNOWN_INPUT_ERR;
226 return;
227 }
228
229 void
biorwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)230 biorwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
231 {
232 int type;
233 *errCode = SUCCESS;
234 wavelet_family_check(wname,SPLINE_BIORTH,&type);
235 if (!type)
236 *errCode = WAVELET_NAME_NOT_VALID;
237 return;
238 }
239
240 /*-------------------------------------------
241 * rbiorwavf validation
242 *-----------------------------------------*/
243
244 void
rbiorwavf_form_validate(void * pvApiCtx,int * errCode)245 rbiorwavf_form_validate (void * pvApiCtx, int *errCode)
246 {
247 *errCode = SUCCESS;
248 if (!sci_strings_scalar(pvApiCtx,1))
249 *errCode = UNKNOWN_INPUT_ERR;
250 return;
251 }
252
253 void
rbiorwavf_content_validate(void * pvApiCtx,int * errCode,char * wname)254 rbiorwavf_content_validate (void * pvApiCtx, int *errCode, char *wname)
255 {
256 int type;
257 *errCode = SUCCESS;
258 wavelet_family_check(wname,SPLINE_RBIORTH,&type);
259 if (!type)
260 *errCode = WAVELET_NAME_NOT_VALID;
261 return;
262 }
263
264
265 /*-------------------------------------------
266 * wfilters validation
267 *-----------------------------------------*/
268
269 void
wfilters_form_validate(void * pvApiCtx,int * errCode,int * flow,char * input_string1,int NInputArgument,int NOutputArgument)270 wfilters_form_validate (void * pvApiCtx, int *errCode, int *flow, char *input_string1, int NInputArgument, int NOutputArgument)
271 {
272
273 *errCode = SUCCESS;
274 if ((NInputArgument==2) && (!sci_strings_scalar(pvApiCtx,2)))
275 {
276 *errCode = UNKNOWN_INPUT_ERR;
277 return;
278 }
279 if ((NInputArgument==1) && sci_strings_scalar(pvApiCtx,1) && (NOutputArgument==4))
280 *flow = 1;
281 else if ((NInputArgument==2) && sci_strings_scalar(pvApiCtx,1) && (NOutputArgument==2) &&
282 input_string1[0]=='d')
283 *flow = 2;
284 else if ((NInputArgument==2) && sci_strings_scalar(pvApiCtx,1) && (NOutputArgument==2) &&
285 input_string1[0]=='r')
286 *flow = 3;
287 else if ((NInputArgument==2) && sci_strings_scalar(pvApiCtx,1) && (NOutputArgument==2) &&
288 input_string1[0]=='l')
289 *flow = 4;
290 else if ((NInputArgument==2) && sci_strings_scalar(pvApiCtx,1) && (NOutputArgument==2) &&
291 input_string1[0]=='h')
292 *flow = 5;
293 else
294 *errCode = UNKNOWN_INPUT_ERR;
295 return;
296 }
297
298 void
wfilters_content_validate(void * pvApiCtx,int * errCode,char * wname)299 wfilters_content_validate(void * pvApiCtx, int *errCode, char *wname)
300 {
301 int typ1, typ2, typ3, typ4, typ5, typ6, typ7, typ8, typ9, typ10, typ11;
302 *errCode = SUCCESS;
303 wavelet_family_check(wname,DAUBECHIES,&typ1);
304 wavelet_family_check(wname,COIFLETS,&typ2);
305 wavelet_family_check(wname,SYMLETS,&typ3);
306 wavelet_family_check(wname,SPLINE_BIORTH,&typ4);
307 wavelet_family_check(wname,HAAR,&typ5);
308 wavelet_family_check(wname,BEYLKIN,&typ6);
309 wavelet_family_check(wname,VAIDYANATHAN,&typ7);
310 wavelet_family_check(wname,DMEY,&typ8);
311 wavelet_family_check(wname,BATHLETS,&typ9);
312 wavelet_family_check(wname,LEGENDRE,&typ10);
313 wavelet_family_check(wname,SPLINE_RBIORTH,&typ11);
314 //wavelet_family_check(wname,FARRAS,&typ12);
315 //wavelet_family_check(wname,KINGSBURYQ,&typ13);
316 if ((!typ1) && (!typ2) && (!typ3) && (!typ4) && (!typ5) && (!typ6) && (!typ7) && (!typ8) && (!typ9) && (!typ10) && (!typ11))
317 *errCode = WAVELET_NAME_NOT_VALID;
318 return;
319 }
320
321 /*-------------------------------------------
322 * wmaxlev validation
323 *-----------------------------------------*/
324
325 void
wmaxlev_form_validate(void * pvApiCtx,int * errCode)326 wmaxlev_form_validate(void * pvApiCtx, int *errCode)
327 {
328 *errCode = UNKNOWN_INPUT_ERR;
329 if (sci_matrix_scalar_real(pvApiCtx,1) && sci_strings_scalar(pvApiCtx,2))
330 *errCode = SUCCESS;
331 else if (sci_matrix_vector_real(pvApiCtx,1) &&
332 sci_strings_scalar(pvApiCtx,2) && length_check(pvApiCtx,1,2))
333 *errCode = SUCCESS;
334 return;
335 }
336
337 /*-------------------------------------------
338 * dwt validation
339 *-----------------------------------------*/
340
341 void
dwt_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)342 dwt_form_validate(void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
343 {
344 *errCode = SUCCESS;
345 if ((NInputArgument==2) && sci_matrix_vector_real(pvApiCtx,1) &&
346 sci_strings_scalar(pvApiCtx,2))
347 *flow = 1;
348 else if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
349 sci_matrix_vector_real(pvApiCtx,2) &&
350 sci_matrix_vector_real(pvApiCtx,3) && vector_length_check(pvApiCtx,2,3))
351 *flow = 2;
352 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
353 sci_strings_scalar(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
354 sci_strings_scalar(pvApiCtx,4))
355 *flow = 3;
356 else if ((NInputArgument==5) && sci_matrix_vector_real(pvApiCtx,1) &&
357 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
358 vector_length_check(pvApiCtx,2,3) &&
359 sci_strings_scalar(pvApiCtx,4) && sci_strings_scalar(pvApiCtx,5))
360 *flow = 4;
361 else
362 *errCode = UNKNOWN_INPUT_ERR;
363 return;
364 }
365
366 void
dwt_content_validate(void * pvApiCtx,int * errCode,int flow,char * string1,char * string2,char * string3)367 dwt_content_validate(void * pvApiCtx, int *errCode, int flow, char * string1, char * string2, char * string3)
368 {
369 int type;
370
371 *errCode = SUCCESS;
372 switch (flow) {
373 case 1:
374 {
375 wfilters_content_validate(pvApiCtx,errCode, string1);
376 break;
377 }
378 case 2:
379 {
380 break;
381 }
382 case 3:
383 {
384 wfilters_content_validate(pvApiCtx,errCode, string1);
385 extension_check(string3,&type);
386 if (!type)
387 *errCode = EXTENSION_OPT_NOT_VALID;
388 if (strcmp(string2,"mode"))
389 *errCode = UNKNOWN_INPUT_ERR;
390 break;
391 }
392 case 4:
393 {
394 extension_check(string2,&type);
395 if (!type)
396 *errCode = EXTENSION_OPT_NOT_VALID;
397 if (strcmp(string1,"mode"))
398 *errCode = UNKNOWN_INPUT_ERR;
399 break;
400 }
401 default:
402 break;
403 }
404 return;
405 }
406
407
408 /*-------------------------------------------
409 * idwt validation
410 *-----------------------------------------*/
411
412 void
idwt_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)413 idwt_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
414 {
415 *errCode = SUCCESS;
416
417 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
418 sci_matrix_vector_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
419 vector_length_check(pvApiCtx,1,2))
420 *flow = 1;
421 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
422 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
423 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
424 vector_length_check(pvApiCtx,3,4))
425 *flow = 2;
426 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
427 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
428 sci_strings_scalar(pvApiCtx,3) && sci_matrix_scalar_real(pvApiCtx,4))
429 *flow = 3;
430 else if ((NInputArgument==5) && sci_matrix_vector_real(pvApiCtx,1) &&
431 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
432 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
433 vector_length_check(pvApiCtx,3,4) && sci_matrix_scalar_real(pvApiCtx,5))
434 *flow = 4;
435 else if ((NInputArgument==5) && sci_matrix_vector_real(pvApiCtx,1) &&
436 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
437 sci_strings_scalar(pvApiCtx,3) && sci_strings_scalar(pvApiCtx,4) &&
438 sci_strings_scalar(pvApiCtx,5))
439 *flow = 5;
440 else if ((NInputArgument==6) && sci_matrix_vector_real(pvApiCtx,1) &&
441 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
442 sci_strings_scalar(pvApiCtx,3) && sci_matrix_scalar_real(pvApiCtx,4) &&
443 sci_strings_scalar(pvApiCtx,5) && sci_strings_scalar(pvApiCtx,6))
444 *flow = 6;
445 else if ((NInputArgument==6) && sci_matrix_vector_real(pvApiCtx,1) &&
446 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
447 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
448 vector_length_check(pvApiCtx,3,4) && sci_strings_scalar(pvApiCtx,5) &&
449 sci_strings_scalar(pvApiCtx,6))
450 *flow = 7;
451 else if ((NInputArgument==7) && sci_matrix_vector_real(pvApiCtx,1) &&
452 sci_matrix_vector_real(pvApiCtx,2) && vector_length_check(pvApiCtx,1,2) &&
453 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
454 vector_length_check(pvApiCtx,3,4) && sci_matrix_scalar_real(pvApiCtx,5) &&
455 sci_strings_scalar(pvApiCtx,6) && sci_strings_scalar(pvApiCtx,7))
456 *flow = 8;
457 else if ((NInputArgument==3) &&
458 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
459 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
460 sci_strings_scalar(pvApiCtx,3))
461 *flow = 1;
462 else if ((NInputArgument==4) &&
463 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
464 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
465 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
466 vector_length_check(pvApiCtx,3,4))
467 *flow = 2;
468 else if ((NInputArgument==4) &&
469 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
470 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
471 sci_strings_scalar(pvApiCtx,3) && sci_matrix_scalar_real(pvApiCtx,4))
472 *flow = 3;
473 else if ((NInputArgument==5) &&
474 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
475 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
476 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
477 vector_length_check(pvApiCtx,3,4) && sci_matrix_scalar_real(pvApiCtx,5))
478 *flow = 4;
479 else if ((NInputArgument==5) &&
480 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
481 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
482 sci_strings_scalar(pvApiCtx,3) && sci_strings_scalar(pvApiCtx,4) &&
483 sci_strings_scalar(pvApiCtx,5))
484 *flow = 5;
485 else if ((NInputArgument==6) &&
486 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
487 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
488 sci_strings_scalar(pvApiCtx,3) && sci_matrix_scalar_real(pvApiCtx,4) &&
489 sci_strings_scalar(pvApiCtx,5) && sci_strings_scalar(pvApiCtx,6))
490 *flow = 6;
491 else if ((NInputArgument==6) &&
492 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
493 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
494 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
495 vector_length_check(pvApiCtx,3,4) && sci_strings_scalar(pvApiCtx,5) &&
496 sci_strings_scalar(pvApiCtx,6))
497 *flow = 7;
498 else if ((NInputArgument==7) &&
499 ((sci_matrix_vector_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2)) ||
500 (sci_matrix_void(pvApiCtx,1) && sci_matrix_vector_real(pvApiCtx,2))) &&
501 sci_matrix_vector_real(pvApiCtx,3) && sci_matrix_vector_real(pvApiCtx,4) &&
502 vector_length_check(pvApiCtx,3,4) && sci_matrix_scalar_real(pvApiCtx,5) &&
503 sci_strings_scalar(pvApiCtx,6) && sci_strings_scalar(pvApiCtx,7))
504 *flow = 8;
505 else
506 *errCode = UNKNOWN_INPUT_ERR;
507 return;
508 }
509
510 void
idwt_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3,int * l4,int * l5,char * l4_string,char * l5_string,char * l6,char * l7)511 idwt_content_validate (void * pvApiCtx, int *errCode, int flow,
512 char * l3, int* l4, int* l5, char* l4_string, char* l5_string, char* l6, char* l7)
513 {
514 int type;
515
516 *errCode = SUCCESS;
517 switch (flow) {
518 case 1:
519 {
520 wfilters_content_validate(pvApiCtx,errCode, (l3));
521 break;
522 }
523 case 2:
524 {
525 break;
526 }
527 case 3:
528 {
529 wfilters_content_validate(pvApiCtx,errCode, (l3));
530 if ((l4)[0] <= 0)
531 *errCode = POSITIVE_INTEGER_ONLY;
532 break;
533 }
534 case 4:
535 {
536 if ((l5)[0] <= 0)
537 *errCode = POSITIVE_INTEGER_ONLY;
538 break;
539 }
540 case 5:
541 {
542 wfilters_content_validate(pvApiCtx,errCode, (l3));
543 if (strcmp(l4_string,"mode"))
544 *errCode = UNKNOWN_INPUT_ERR;
545 extension_check(l5_string,&type);
546 if (!type)
547 *errCode = EXTENSION_OPT_NOT_VALID;
548 break;
549 }
550 case 6:
551 {
552 wfilters_content_validate(pvApiCtx,errCode, (l3));
553 if (strcmp(l5_string,"mode"))
554 *errCode = UNKNOWN_INPUT_ERR;
555 extension_check((l6),&type);
556 if (!type)
557 *errCode = EXTENSION_OPT_NOT_VALID;
558 if ((l4)[0] <= 0)
559 *errCode = POSITIVE_INTEGER_ONLY;
560 break;
561 }
562 case 7:
563 {
564 if (strcmp(l5_string,"mode"))
565 *errCode = UNKNOWN_INPUT_ERR;
566 extension_check((l6),&type);
567 if (!type)
568 *errCode = EXTENSION_OPT_NOT_VALID;
569 break;
570 }
571 case 8:
572 {
573 if (strcmp((l6),"mode"))
574 *errCode = UNKNOWN_INPUT_ERR;
575 extension_check((l7),&type);
576 if (!type)
577 *errCode = EXTENSION_OPT_NOT_VALID;
578 if ((l5)[0] <= 0)
579 *errCode = POSITIVE_INTEGER_ONLY;
580 break;
581 }
582 default:
583 break;
584 }
585 return;
586 }
587
588 /*-------------------------------------------
589 * wavedec validation
590 *-----------------------------------------*/
591
592 void
wavedec_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)593 wavedec_form_validate(void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
594 {
595 *errCode = SUCCESS;
596 if ((NInputArgument==3) && (sci_matrix_vector_real(pvApiCtx,1))&&
597 sci_matrix_scalar_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3))
598 *flow = 1;
599 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
600 sci_matrix_scalar_real(pvApiCtx,2) &&
601 sci_matrix_vector_real(pvApiCtx,3) &&
602 sci_matrix_vector_real(pvApiCtx,4) &&
603 vector_length_check(pvApiCtx,3,4))
604 *flow = 2;
605 else
606 *errCode = UNKNOWN_INPUT_ERR;
607 return;
608 }
609
610 void
wavedec_content_validate(void * pvApiCtx,int * errCode,int flow,int * int1,char * string1)611 wavedec_content_validate(void * pvApiCtx, int *errCode, int flow, int* int1, char* string1)
612 {
613 *errCode = SUCCESS;
614 switch (flow) {
615 case 1:
616 {
617 wfilters_content_validate(pvApiCtx,errCode,string1);
618 if (int1[0]<=0)
619 *errCode = POSITIVE_INTEGER_ONLY;
620 break;
621 }
622 case 2:
623 {
624 if (int1[0]<=0)
625 *errCode = POSITIVE_INTEGER_ONLY;
626 break;
627 }
628 default:
629 break;
630 }
631 return;
632 }
633
634 /*-------------------------------------------
635 * waverec validation
636 *-----------------------------------------*/
637
638 void
waverec_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)639 waverec_form_validate(void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
640 {
641 *errCode = SUCCESS;
642 if ((NInputArgument==3) && (sci_matrix_vector_real(pvApiCtx,1))&&
643 sci_matrix_vector_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3))
644 *flow = 1;
645 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
646 sci_matrix_vector_real(pvApiCtx,2) &&
647 sci_matrix_vector_real(pvApiCtx,3) &&
648 sci_matrix_vector_real(pvApiCtx,4) &&
649 vector_length_check(pvApiCtx,3,4))
650 *flow = 2;
651 else
652 *errCode = UNKNOWN_INPUT_ERR;
653 return;
654 }
655
656 void
waverec_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3)657 waverec_content_validate(void * pvApiCtx, int *errCode, int flow, char* l3)
658 {
659 *errCode = SUCCESS;
660 switch (flow) {
661 case 1:
662 {
663 wfilters_content_validate(pvApiCtx,errCode,(l3));
664 break;
665 }
666 case 2:
667 {
668 break;
669 }
670 default:
671 break;
672 }
673 return;
674 }
675
676 /*-------------------------------------------
677 * wrcoef validation
678 *-----------------------------------------*/
679
680 void
wrcoef_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)681 wrcoef_form_validate(void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
682 {
683 *errCode = SUCCESS;
684
685 if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
686 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
687 sci_strings_scalar(pvApiCtx,4))
688 *flow = 1;
689 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
690 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
691 sci_strings_scalar(pvApiCtx,4) && sci_matrix_scalar_real(pvApiCtx,5))
692 *flow = 2;
693 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
694 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
695 sci_matrix_vector_real(pvApiCtx,4) && sci_matrix_vector_real(pvApiCtx,5) &&
696 vector_length_check(pvApiCtx,4,5))
697 *flow = 3;
698 else if ((NInputArgument==6) && sci_strings_scalar(pvApiCtx,1) &&
699 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
700 sci_matrix_vector_real(pvApiCtx,4) && sci_matrix_vector_real(pvApiCtx,5) &&
701 sci_matrix_scalar_real(pvApiCtx,6) && vector_length_check(pvApiCtx,4,5))
702 *flow = 4;
703 else
704 *errCode = UNKNOWN_INPUT_ERR;
705 return;
706 }
707
708 void
wrcoef_content_validate(void * pvApiCtx,int * errCode,int flow,char * l1,char * l4,int * l5,int * l6)709 wrcoef_content_validate (void * pvApiCtx, int *errCode, int flow, char *l1, char* l4, int *l5, int* l6)
710 {
711 *errCode = SUCCESS;
712 switch (flow){
713 case 1:
714 {
715 wfilters_content_validate(pvApiCtx,errCode,(l4));
716 if (scalar_string_check((l1),'a') ||
717 scalar_string_check((l1),'d'))
718 *errCode = SUCCESS;
719 else
720 *errCode = UNKNOWN_INPUT_ERR;
721 break;
722 }
723 case 2:
724 {
725 wfilters_content_validate(pvApiCtx,errCode,(l4));
726 if (scalar_string_check((l1),'a') ||
727 scalar_string_check((l1),'d'))
728 *errCode = SUCCESS;
729 else
730 *errCode = UNKNOWN_INPUT_ERR;
731 if ((scalar_string_check((l1),'a') && ((l5)[0] >= 0)) ||
732 (scalar_string_check((l1),'d') && ((l5)[0] > 0) ))
733 *errCode = SUCCESS;
734 else
735 *errCode = UNKNOWN_INPUT_ERR;
736 break;
737 }
738 case 3:
739 {
740 if (scalar_string_check((l1),'a') ||
741 scalar_string_check((l1),'d'))
742 *errCode = SUCCESS;
743 else
744 *errCode = OPT_CHAR_NOT_VALID;
745 break;
746 }
747 case 4:
748 {
749 if (scalar_string_check((l1),'a') ||
750 scalar_string_check((l1),'d'))
751 *errCode = SUCCESS;
752 else
753 *errCode = UNKNOWN_INPUT_ERR;
754 if ((scalar_string_check((l1),'a') && ((l6)[0] >= 0)) ||
755 (scalar_string_check((l1),'d') && ((l6)[0] > 0) ))
756 *errCode = SUCCESS;
757 else
758 *errCode = UNKNOWN_INPUT_ERR;
759 break;
760 }
761 default:
762 break;
763 }
764 return;
765 }
766
767 /*-------------------------------------------
768 * appcoef validation
769 *-----------------------------------------*/
770
771 void
appcoef_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)772 appcoef_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
773 {
774 *errCode = SUCCESS;
775 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
776 sci_matrix_vector_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3))
777 *flow = 1;
778 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
779 sci_matrix_vector_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
780 sci_matrix_scalar_real(pvApiCtx,4) )
781 *flow = 2;
782 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
783 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
784 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4))
785 *flow = 3;
786 else if ((NInputArgument==5) && sci_matrix_vector_real(pvApiCtx,1) &&
787 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
788 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
789 sci_matrix_scalar_real(pvApiCtx,5))
790 *flow = 4;
791 else
792 *errCode = UNKNOWN_INPUT_ERR;
793 return;
794 }
795
796 void
appcoef_content_validate(void * pvApiCtx,int * errCode,int flow,char * input3)797 appcoef_content_validate (void * pvApiCtx, int *errCode, int flow, char* input3)
798 {
799 *errCode = SUCCESS;
800 switch (flow) {
801 case 1:
802 {
803 wfilters_content_validate(pvApiCtx,errCode,(input3));
804 break;
805 }
806 case 2:
807 {
808 wfilters_content_validate(pvApiCtx,errCode,(input3));
809 break;
810 }
811 case 3:
812 {
813 break;
814 }
815 case 4:
816 {
817 break;
818 }
819 default:
820 break;
821 }
822 return;
823 }
824
825 /*-------------------------------------------
826 * detcoef validation
827 *-----------------------------------------*/
828
829 void
detcoef_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)830 detcoef_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
831 {
832 *errCode = SUCCESS;
833 if ((NInputArgument==2) && sci_matrix_vector_real(pvApiCtx,1) &&
834 sci_matrix_vector_real(pvApiCtx,2))
835 *flow = 1;
836 else if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
837 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_scalar_real(pvApiCtx,3))
838 *flow = 2;
839 else
840 *errCode = UNKNOWN_INPUT_ERR;
841 return;
842 }
843
844 /*-------------------------------------------
845 * wenergy validation
846 *-----------------------------------------*/
847
848 void
wenergy_form_validate(void * pvApiCtx,int * errCode,int NInputArgument)849 wenergy_form_validate (void * pvApiCtx, int *errCode, int NInputArgument)
850 {
851 *errCode = UNKNOWN_INPUT_ERR;
852 if ((NInputArgument==2) && sci_matrix_vector_real(pvApiCtx,1) &&
853 sci_matrix_vector_real(pvApiCtx,2))
854 *errCode = SUCCESS;
855 return;
856 }
857
858 /*-------------------------------------------
859 * upcoef validation
860 *-----------------------------------------*/
861
862 void
upcoef_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)863 upcoef_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
864 {
865 *errCode = SUCCESS;
866 if ((NInputArgument==3) && sci_strings_scalar(pvApiCtx,1) &&
867 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3))
868 *flow = 5;
869 else if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
870 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3) &&
871 sci_matrix_scalar_real(pvApiCtx,4))
872 *flow = 1;
873 else if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
874 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
875 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4))
876 *flow = 6;
877 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
878 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3) &&
879 sci_matrix_scalar_real(pvApiCtx,4) && sci_matrix_scalar_real(pvApiCtx,5))
880 *flow = 2;
881 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
882 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
883 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
884 sci_matrix_scalar_real(pvApiCtx,5))
885 *flow = 3;
886 else if ((NInputArgument==6) && sci_strings_scalar(pvApiCtx,1) &&
887 (sci_matrix_vector_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
888 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
889 sci_matrix_scalar_real(pvApiCtx,5) && sci_matrix_scalar_real(pvApiCtx,6))
890 *flow = 4;
891 else
892 *errCode = UNKNOWN_INPUT_ERR;
893 return;
894 }
895
896 void
upcoef_content_validate(void * pvApiCtx,int * errCode,int flow,char * l1,char * input3,int * l4,int * l5,int * l6)897 upcoef_content_validate (void * pvApiCtx, int *errCode, int flow, char* l1,
898 char* input3, int* l4, int* l5, int* l6)
899 {
900 *errCode = SUCCESS;
901 switch (flow) {
902 case 1:
903 {
904 if (scalar_string_check((l1),'a') ||
905 scalar_string_check((l1),'d'))
906 *errCode = SUCCESS;
907 else
908 *errCode = OPT_CHAR_NOT_VALID;
909 wfilters_content_validate(pvApiCtx,errCode,(input3));
910 if ((l4)[0]<=0)
911 *errCode = POSITIVE_INTEGER_ONLY;
912 break;
913 }
914 case 2:
915 {
916 if (scalar_string_check((l1),'a') ||
917 scalar_string_check((l1),'d'))
918 *errCode = SUCCESS;
919 else
920 *errCode = OPT_CHAR_NOT_VALID;
921 wfilters_content_validate(pvApiCtx,errCode,(input3));
922 if ((l4)[0]<=0)
923 *errCode = POSITIVE_INTEGER_ONLY;
924 if ((l5)[0]<=0)
925 *errCode = POSITIVE_INTEGER_ONLY;
926 break;
927 }
928 case 3:
929 {
930 if (scalar_string_check((l1),'a') ||
931 scalar_string_check((l1),'d'))
932 *errCode = SUCCESS;
933 else
934 *errCode = OPT_CHAR_NOT_VALID;
935 if ((l5)[0]<=0)
936 *errCode = POSITIVE_INTEGER_ONLY;
937 break;
938 }
939 case 4:
940 {
941 if (scalar_string_check((l1),'a') ||
942 scalar_string_check((l1),'d'))
943 *errCode = SUCCESS;
944 else
945 *errCode = OPT_CHAR_NOT_VALID;
946 if ((l5)[0]<=0)
947 *errCode = POSITIVE_INTEGER_ONLY;
948 if ((l6)[0]<=0)
949 *errCode = POSITIVE_INTEGER_ONLY;
950 break;
951 }
952 case 5:
953 {
954 if (scalar_string_check((l1),'a') ||
955 scalar_string_check((l1),'d'))
956 *errCode = SUCCESS;
957 else
958 *errCode = OPT_CHAR_NOT_VALID;
959 wfilters_content_validate(pvApiCtx,errCode,(input3));
960 break;
961 }
962 case 6:
963 {
964 if (scalar_string_check((l1),'a') ||
965 scalar_string_check((l1),'d'))
966 *errCode = SUCCESS;
967 else
968 *errCode = OPT_CHAR_NOT_VALID;
969 break;
970 }
971 default:
972 break;
973 }
974 return;
975 }
976
977 /*-------------------------------------------
978 * upwlev validation
979 *-----------------------------------------*/
980
981 void
upwlev_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)982 upwlev_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
983 {
984 *errCode = SUCCESS;
985 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
986 sci_matrix_vector_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3))
987 *flow = 1;
988 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
989 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
990 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4))
991 *flow = 2;
992 else
993 *errCode = UNKNOWN_INPUT_ERR;
994 return;
995 }
996
997 void
upwlev_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3)998 upwlev_content_validate (void * pvApiCtx, int *errCode, int flow,char* l3)
999 {
1000 *errCode = SUCCESS;
1001 switch (flow){
1002 case 1:
1003 {
1004 wfilters_content_validate(pvApiCtx,errCode,(l3));
1005 break;
1006 }
1007 case 2:
1008 {
1009 break;
1010 }
1011 default:
1012 break;
1013 }
1014 return;
1015 }
1016
1017 /*-------------------------------------------
1018 * dwt2 validation
1019 *-----------------------------------------*/
1020
1021 void
dwt2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1022 dwt2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1023 {
1024 *errCode = SUCCESS;
1025 if ((NInputArgument==2) && sci_matrix_matrix_real(pvApiCtx,1) &&
1026 sci_strings_scalar(pvApiCtx,2))
1027 *flow = 1;
1028 else if ((NInputArgument==3) && sci_matrix_matrix_real(pvApiCtx,1) &&
1029 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1030 vector_length_check(pvApiCtx,2,3))
1031 *flow = 2;
1032 else if ((NInputArgument==4) && sci_matrix_matrix_real(pvApiCtx,1) &&
1033 sci_strings_scalar(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
1034 sci_strings_scalar(pvApiCtx,4))
1035 *flow = 3;
1036 else if ((NInputArgument==5) && sci_matrix_matrix_real(pvApiCtx,1) &&
1037 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1038 vector_length_check(pvApiCtx,2,3) && sci_strings_scalar(pvApiCtx,4) &&
1039 sci_strings_scalar(pvApiCtx,5))
1040 *flow = 4;
1041 else
1042 *errCode = UNKNOWN_INPUT_ERR;
1043 return;
1044 }
1045
1046 void
dwt2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l2,char * l3,char * l4,char * l5)1047 dwt2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l2,
1048 char* l3, char* l4, char* l5)
1049 {
1050 int type;
1051 *errCode = SUCCESS;
1052 switch (flow){
1053 case 1:
1054 {
1055 wfilters_content_validate(pvApiCtx,errCode,(l2));
1056 break;
1057 }
1058 case 2:
1059 {
1060 break;
1061 }
1062 case 3:
1063 {
1064 wfilters_content_validate(pvApiCtx,errCode,(l2));
1065 if (strcmp((l3),"mode"))
1066 *errCode = UNKNOWN_INPUT_ERR;
1067 extension_check((l4),&type);
1068 if (!type)
1069 *errCode = EXTENSION_OPT_NOT_VALID;
1070 break;
1071 }
1072 case 4:
1073 {
1074 if (strcmp((l4),"mode"))
1075 *errCode = UNKNOWN_INPUT_ERR;
1076 extension_check((l5),&type);
1077 if (!type)
1078 *errCode = EXTENSION_OPT_NOT_VALID;
1079 break;
1080 }
1081 default:
1082 break;
1083 }
1084 return;
1085 }
1086
1087 /*-------------------------------------------
1088 * idwt2 validation
1089 *-----------------------------------------*/
1090
1091 void
idwt2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1092 idwt2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1093 {
1094 if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1095 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1096 matrix_length_check(pvApiCtx,1,2) && matrix_length_check(pvApiCtx,1,3) &&
1097 matrix_length_check(pvApiCtx,1,4))
1098 *errCode = SUCCESS;
1099 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1100 sci_matrix_void(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4))
1101 *errCode = SUCCESS;
1102 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1103 sci_matrix_void(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4))
1104 *errCode = SUCCESS;
1105 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1106 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4))
1107 *errCode = SUCCESS;
1108 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1109 sci_matrix_void(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4))
1110 *errCode = SUCCESS;
1111 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1112 sci_matrix_void(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4) &&
1113 matrix_length_check(pvApiCtx,1,2))
1114 *errCode = SUCCESS;
1115 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1116 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4) &&
1117 matrix_length_check(pvApiCtx,1,3))
1118 *errCode = SUCCESS;
1119 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1120 sci_matrix_void(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1121 matrix_length_check(pvApiCtx,1,4))
1122 *errCode = SUCCESS;
1123 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1124 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4) &&
1125 matrix_length_check(pvApiCtx,2,3))
1126 *errCode = SUCCESS;
1127 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1128 sci_matrix_void(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1129 matrix_length_check(pvApiCtx,2,4))
1130 *errCode = SUCCESS;
1131 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1132 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1133 matrix_length_check(pvApiCtx,3,4))
1134 *errCode = SUCCESS;
1135 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1136 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_void(pvApiCtx,4) &&
1137 matrix_length_check(pvApiCtx,1,2) && matrix_length_check(pvApiCtx,1,3))
1138 *errCode = SUCCESS;
1139 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1140 sci_matrix_void(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1141 matrix_length_check(pvApiCtx,1,2) && matrix_length_check(pvApiCtx,1,4))
1142 *errCode = SUCCESS;
1143 else if (sci_matrix_matrix_real(pvApiCtx,1) && sci_matrix_void(pvApiCtx,2) &&
1144 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1145 matrix_length_check(pvApiCtx,1,3) && matrix_length_check(pvApiCtx,1,4))
1146 *errCode = SUCCESS;
1147 else if (sci_matrix_void(pvApiCtx,1) && sci_matrix_matrix_real(pvApiCtx,2) &&
1148 sci_matrix_matrix_real(pvApiCtx,3) && sci_matrix_matrix_real(pvApiCtx,4) &&
1149 matrix_length_check(pvApiCtx,2,3) && matrix_length_check(pvApiCtx,2,4))
1150 *errCode = SUCCESS;
1151 else
1152 {
1153 *errCode = UNKNOWN_INPUT_ERR;
1154 return;
1155 }
1156
1157 if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,5))
1158 *flow = 1;
1159 else if ((NInputArgument==6) && sci_matrix_vector_real(pvApiCtx,5) &&
1160 sci_matrix_vector_real(pvApiCtx,6) && vector_length_check(pvApiCtx,5,6))
1161 *flow = 2;
1162 else if ((NInputArgument==6) && sci_strings_scalar(pvApiCtx,5) &&
1163 sci_matrix_vector_real(pvApiCtx,6) && length_check(pvApiCtx,6,2))
1164 *flow = 3;
1165 else if ((NInputArgument==7) && sci_matrix_vector_real(pvApiCtx,5) &&
1166 sci_matrix_vector_real(pvApiCtx,6) && vector_length_check(pvApiCtx,5,6) &&
1167 sci_matrix_vector_real(pvApiCtx,7) && length_check(pvApiCtx,7,2))
1168 *flow = 4;
1169 else if ((NInputArgument==7) && sci_strings_scalar(pvApiCtx,5) &&
1170 sci_strings_scalar(pvApiCtx,6) && sci_strings_scalar(pvApiCtx,7))
1171 *flow = 5;
1172 else if ((NInputArgument==8) && sci_matrix_vector_real(pvApiCtx,5) &&
1173 sci_matrix_vector_real(pvApiCtx,6) && vector_length_check(pvApiCtx,5,6) &&
1174 sci_strings_scalar(pvApiCtx,7) && sci_strings_scalar(pvApiCtx,8))
1175 *flow = 6;
1176 else if ((NInputArgument==8) && sci_strings_scalar(pvApiCtx,5) &&
1177 sci_matrix_vector_real(pvApiCtx,6) && length_check(pvApiCtx,6,2) &&
1178 sci_strings_scalar(pvApiCtx,7) && sci_strings_scalar(pvApiCtx,8))
1179 *flow = 7;
1180 else if ((NInputArgument==9) && sci_matrix_vector_real(pvApiCtx,5) &&
1181 sci_matrix_vector_real(pvApiCtx,6) && vector_length_check(pvApiCtx,5,6) &&
1182 sci_matrix_vector_real(pvApiCtx,7) && length_check(pvApiCtx,7,2) &&
1183 sci_strings_scalar(pvApiCtx,8) && sci_strings_scalar(pvApiCtx,9))
1184 *flow = 8;
1185 else
1186 *errCode = UNKNOWN_INPUT_ERR;
1187
1188 return;
1189 }
1190
1191 /*-------------------------------------------
1192 * idwt2 validation
1193 *-----------------------------------------*/
1194
1195 void
idwt2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l5,int * l6,char * l6_char,int * l7,char * l7_char,char * l8,char * l9)1196 idwt2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l5, int* l6,char* l6_char, int* l7,char* l7_char,char* l8,char* l9)
1197 {
1198 int type;
1199 *errCode = SUCCESS;
1200 switch (flow) {
1201 case 1:
1202 {
1203 wfilters_content_validate(pvApiCtx,errCode,(l5));
1204 break;
1205 }
1206 case 2:
1207 {
1208 break;
1209 }
1210 case 3:
1211 {
1212 wfilters_content_validate(pvApiCtx,errCode,(l5));
1213 if (((l6)[0]<=0) || ((l6)[1]<=0))
1214 *errCode = POSITIVE_INTEGER_ONLY;
1215 break;
1216 }
1217 case 4:
1218 {
1219 if (((l7)[0]<=0) || ((l7)[1]<=0))
1220 *errCode = POSITIVE_INTEGER_ONLY;
1221 break;
1222 }
1223 case 5:
1224 {
1225 wfilters_content_validate(pvApiCtx,errCode,(l5));
1226 if (strcmp(l6_char,"mode"))
1227 *errCode = UNKNOWN_INPUT_ERR;
1228 extension_check(l7_char,&type);
1229 if (!type)
1230 *errCode = EXTENSION_OPT_NOT_VALID;
1231 break;
1232 }
1233 case 6:
1234 {
1235 if (strcmp(l7_char,"mode"))
1236 *errCode = UNKNOWN_INPUT_ERR;
1237 extension_check((l8),&type);
1238 if (!type)
1239 *errCode = EXTENSION_OPT_NOT_VALID;
1240 break;
1241 }
1242 case 7:
1243 {
1244 wfilters_content_validate(pvApiCtx,errCode,(l5));
1245 if (strcmp(l7_char,"mode"))
1246 *errCode = UNKNOWN_INPUT_ERR;
1247 extension_check((l8),&type);
1248 if (!type)
1249 *errCode = EXTENSION_OPT_NOT_VALID;
1250 if (((l6)[0]<=0) || ((l6)[1]<=0))
1251 *errCode = POSITIVE_INTEGER_ONLY;
1252 break;
1253 }
1254 case 8:
1255 {
1256 if (strcmp(l8,"mode"))
1257 *errCode = UNKNOWN_INPUT_ERR;
1258 extension_check((l9),&type);
1259 if (!type)
1260 *errCode = EXTENSION_OPT_NOT_VALID;
1261 if (((l7)[0]<=0) || ((l7)[1]<=0))
1262 *errCode = POSITIVE_INTEGER_ONLY;
1263 break;
1264 }
1265 default:
1266 break;
1267 }
1268 return;
1269 }
1270
1271 /*-------------------------------------------
1272 * wavedec2 validation
1273 *-----------------------------------------*/
1274
1275 void
wavedec2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1276 wavedec2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1277 {
1278 *errCode = SUCCESS;
1279 if ((NInputArgument==3) && sci_matrix_matrix_real(pvApiCtx,1) &&
1280 sci_matrix_scalar_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3))
1281 *flow = 1;
1282 else if ((NInputArgument==4) && sci_matrix_matrix_real(pvApiCtx,1) &&
1283 sci_matrix_scalar_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1284 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4))
1285 *flow = 2;
1286 else
1287 *errCode = UNKNOWN_INPUT_ERR;
1288 return;
1289 }
1290
1291 void
wavedec2_content_validate(void * pvApiCtx,int * errCode,int flow,int * l2,char * l3)1292 wavedec2_content_validate (void * pvApiCtx, int *errCode, int flow, int* l2, char* l3)
1293 {
1294 *errCode = SUCCESS;
1295 switch (flow){
1296 case 1:
1297 {
1298 if ((l2)[0]<=0)
1299 *errCode = POSITIVE_INTEGER_ONLY;
1300 wfilters_content_validate(pvApiCtx,errCode,(l3));
1301 break;
1302 }
1303 case 2:
1304 {
1305 if ((l2)[0]<=0)
1306 *errCode = POSITIVE_INTEGER_ONLY;
1307 break;
1308 }
1309 default:
1310 break;
1311 }
1312 return;
1313 }
1314
1315 /*-------------------------------------------
1316 * waverec2 validation
1317 *-----------------------------------------*/
1318
1319 void
waverec2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1320 waverec2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1321 {
1322 *errCode = SUCCESS;
1323 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
1324 sci_matrix_matrix_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
1325 matrix_col_length_check(pvApiCtx,2,2))
1326 *flow = 1;
1327 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
1328 sci_matrix_matrix_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1329 sci_matrix_vector_real(pvApiCtx,4) && matrix_length_check(pvApiCtx,3,4) &&
1330 matrix_col_length_check(pvApiCtx,2,2))
1331 *flow = 2;
1332 else
1333 *errCode = UNKNOWN_INPUT_ERR;
1334 return;
1335 }
1336
1337 void
waverec2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3)1338 waverec2_content_validate (void * pvApiCtx, int *errCode, int flow, char *l3)
1339 {
1340 *errCode = SUCCESS;
1341 switch (flow) {
1342 case 1:
1343 {
1344 wfilters_content_validate(pvApiCtx,errCode,(l3));
1345 break;
1346 }
1347 case 2:
1348 {
1349 break;
1350 }
1351 default:
1352 break;
1353 }
1354 return;
1355 }
1356
1357 /*-------------------------------------------
1358 * wenergy2 validation
1359 *-----------------------------------------*/
1360
1361 void
wenergy2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument,int NOutputArgument)1362 wenergy2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument, int NOutputArgument)
1363 {
1364 *errCode = SUCCESS;
1365 if ((NInputArgument==2) && (NOutputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
1366 sci_matrix_matrix_real(pvApiCtx,2) && matrix_col_length_check(pvApiCtx,2,2))
1367 *flow = 1;
1368 else if ((NInputArgument==2) && (NOutputArgument==2) && sci_matrix_vector_real(pvApiCtx,1) &&
1369 sci_matrix_matrix_real(pvApiCtx,2) && matrix_col_length_check(pvApiCtx,2,2))
1370 *flow = 2;
1371 else
1372 *errCode = UNKNOWN_INPUT_ERR;
1373 return;
1374 }
1375
1376 /*-------------------------------------------
1377 * detcoef2 validation
1378 *-----------------------------------------*/
1379
1380 void
detcoef2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1381 detcoef2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1382 {
1383 if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
1384 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_matrix_real(pvApiCtx,3) &&
1385 sci_matrix_scalar_real(pvApiCtx,4) && matrix_col_length_check(pvApiCtx,3,2))
1386 *errCode = SUCCESS;
1387 else
1388 *errCode = UNKNOWN_INPUT_ERR;
1389 return;
1390 }
1391
1392
1393 void
detcoef2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l1)1394 detcoef2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l1)
1395 {
1396 if ((!strcmp((l1),"a")) || (!strcmp((l1),"h")) ||
1397 (!strcmp((l1),"v")) || (!strcmp((l1),"d")) ||
1398 (!strcmp((l1),"c")) || (!strcmp((l1),"all")) ||
1399 (!strcmp((l1),"compact")))
1400 *errCode = SUCCESS;
1401 else
1402 *errCode = OPT_CHAR_NOT_VALID;
1403 return;
1404 }
1405
1406
1407 /*-------------------------------------------
1408 * appcoef2 validation
1409 *-----------------------------------------*/
1410
1411 void
appcoef2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1412 appcoef2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1413 {
1414 *errCode = SUCCESS;
1415 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
1416 sci_matrix_matrix_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
1417 matrix_col_length_check(pvApiCtx,2,2))
1418 *flow = 2;
1419 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
1420 sci_matrix_matrix_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
1421 sci_matrix_scalar_real(pvApiCtx,4) && matrix_col_length_check(pvApiCtx,2,2))
1422 *flow = 1;
1423 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
1424 sci_matrix_matrix_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1425 sci_matrix_vector_real(pvApiCtx,4) &&
1426 matrix_col_length_check(pvApiCtx,2,2) && vector_length_check(pvApiCtx,3,4))
1427 *flow = 3;
1428 else if ((NInputArgument==5) && sci_matrix_vector_real(pvApiCtx,1) &&
1429 sci_matrix_matrix_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1430 sci_matrix_vector_real(pvApiCtx,4) && sci_matrix_scalar_real(pvApiCtx,5) &&
1431 vector_length_check(pvApiCtx,3,4) && matrix_col_length_check(pvApiCtx,2,2))
1432 *flow = 4;
1433 else
1434 *errCode = UNKNOWN_INPUT_ERR;
1435 return;
1436 }
1437
1438
1439 void
appcoef2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3,int * l4,int * l5)1440 appcoef2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l3, int* l4, int* l5)
1441 {
1442 *errCode = SUCCESS;
1443 switch (flow) {
1444 case 1:
1445 {
1446 wfilters_content_validate(pvApiCtx,errCode,(l3));
1447 if ((l4)[0]<0)
1448 *errCode = POSITIVE_INTEGER_ONLY;
1449 break;
1450 }
1451 case 2:
1452 {
1453 wfilters_content_validate(pvApiCtx,errCode,(l3));
1454 break;
1455 }
1456 case 3:
1457 {
1458 break;
1459 }
1460 case 4:
1461 {
1462 if ((l5)[0]<0)
1463 *errCode = POSITIVE_INTEGER_ONLY;
1464 break;
1465 }
1466 default:
1467 break;
1468 }
1469 return;
1470 }
1471
1472
1473 /*-------------------------------------------
1474 * wrcoef2 validation
1475 *-----------------------------------------*/
1476
1477 void
wrcoef2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1478 wrcoef2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1479 {
1480 *errCode = SUCCESS;
1481 if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
1482 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_matrix_real(pvApiCtx,3) &&
1483 sci_strings_scalar(pvApiCtx,4) && matrix_col_length_check(pvApiCtx,3,2))
1484 *flow = 3;
1485 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
1486 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_matrix_real(pvApiCtx,3) &&
1487 sci_strings_scalar(pvApiCtx,4) && sci_matrix_scalar_real(pvApiCtx,5) &&
1488 matrix_col_length_check(pvApiCtx,3,2))
1489 *flow = 1;
1490 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
1491 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_matrix_real(pvApiCtx,3) &&
1492 sci_matrix_vector_real(pvApiCtx,4) && sci_matrix_vector_real(pvApiCtx,5) &&
1493 vector_length_check(pvApiCtx,4,5) && matrix_col_length_check(pvApiCtx,3,2))
1494 *flow = 4;
1495 else if ((NInputArgument==6) && sci_strings_scalar(pvApiCtx,1) &&
1496 sci_matrix_vector_real(pvApiCtx,2) && sci_matrix_matrix_real(pvApiCtx,3) &&
1497 sci_matrix_vector_real(pvApiCtx,4) && sci_matrix_vector_real(pvApiCtx,5) &&
1498 vector_length_check(pvApiCtx,4,5) &&
1499 matrix_col_length_check(pvApiCtx,3,2) && sci_matrix_scalar_real(pvApiCtx,6))
1500 *flow = 2;
1501 return;
1502 }
1503
1504 void
wrcoef2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l1,char * l4,int * l5,int * l6)1505 wrcoef2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l1, char* l4, int* l5, int* l6)
1506 {
1507 if (scalar_string_check((l1),'a') ||
1508 scalar_string_check((l1),'h') ||
1509 scalar_string_check((l1),'v') ||
1510 scalar_string_check((l1),'d'))
1511 *errCode = SUCCESS;
1512 else
1513 {
1514 *errCode = OPT_CHAR_NOT_VALID;
1515 return;
1516 }
1517 switch (flow) {
1518 case 1:
1519 {
1520 wfilters_content_validate(pvApiCtx,errCode,(l4));
1521 if ((l5)[0]<=0)
1522 *errCode = POSITIVE_INTEGER_ONLY;
1523 if (scalar_string_check((l1),'a') ||
1524 scalar_string_check((l1),'h') ||
1525 scalar_string_check((l1),'v') ||
1526 scalar_string_check((l1),'d'))
1527 *errCode = SUCCESS;
1528 else
1529 *errCode = OPT_CHAR_NOT_VALID;
1530 break;
1531 }
1532 case 2:
1533 {
1534 if ((l6)[0]<=0)
1535 *errCode = POSITIVE_INTEGER_ONLY;
1536 break;
1537 }
1538 case 3:
1539 {
1540 wfilters_content_validate(pvApiCtx,errCode,(l4));
1541 break;
1542 }
1543 case 4:
1544 {
1545 break;
1546 }
1547 default:
1548 break;
1549 }
1550 return;
1551 }
1552
1553 /*-------------------------------------------
1554 * upwlev2 validation
1555 *-----------------------------------------*/
1556
1557 void
upwlev2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1558 upwlev2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1559 {
1560 *errCode = SUCCESS;
1561 if ((NInputArgument==3) && sci_matrix_vector_real(pvApiCtx,1) &&
1562 sci_matrix_matrix_real(pvApiCtx,2) && sci_strings_scalar(pvApiCtx,3) &&
1563 matrix_col_length_check(pvApiCtx,2,2))
1564 *flow = 1;
1565 else if ((NInputArgument==4) && sci_matrix_vector_real(pvApiCtx,1) &&
1566 sci_matrix_matrix_real(pvApiCtx,2) && sci_matrix_vector_real(pvApiCtx,3) &&
1567 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
1568 matrix_col_length_check(pvApiCtx,2,2))
1569 *flow = 2;
1570 else
1571 *errCode = UNKNOWN_INPUT_ERR;
1572 return;
1573 }
1574
1575 void
upwlev2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l3)1576 upwlev2_content_validate (void * pvApiCtx, int *errCode, int flow, char *l3)
1577 {
1578 *errCode = SUCCESS;
1579 switch (flow) {
1580 case 1:
1581 {
1582 wfilters_content_validate(pvApiCtx,errCode,(l3));
1583 break;
1584 }
1585 case 2:
1586 {
1587 break;
1588 }
1589 default:
1590 break;
1591 }
1592 return;
1593 }
1594
1595 /*-------------------------------------------
1596 * upcoef2 validation
1597 *-----------------------------------------*/
1598
1599 void
upcoef2_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1600 upcoef2_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1601 {
1602 *errCode = SUCCESS;
1603 if ((NInputArgument==3) && sci_strings_scalar(pvApiCtx,1) &&
1604 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2) || sci_matrix_vector_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3))
1605 *flow = 5;
1606 else if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
1607 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3) &&
1608 sci_matrix_scalar_real(pvApiCtx,4))
1609 *flow = 3;
1610 else if ((NInputArgument==4) && sci_strings_scalar(pvApiCtx,1) &&
1611 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
1612 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4))
1613 *flow = 6;
1614 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
1615 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_strings_scalar(pvApiCtx,3) &&
1616 sci_matrix_scalar_real(pvApiCtx,4) && sci_matrix_vector_real(pvApiCtx,5) &&
1617 length_check(pvApiCtx,5,2))
1618 *flow = 1;
1619 else if ((NInputArgument==5) && sci_strings_scalar(pvApiCtx,1) &&
1620 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
1621 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
1622 sci_matrix_scalar_real(pvApiCtx,5))
1623 *flow = 4;
1624 else if ((NInputArgument==6) && sci_strings_scalar(pvApiCtx,1) &&
1625 (sci_matrix_matrix_real(pvApiCtx,2) || sci_matrix_scalar_real(pvApiCtx,2)) && sci_matrix_vector_real(pvApiCtx,3) &&
1626 sci_matrix_vector_real(pvApiCtx,4) && vector_length_check(pvApiCtx,3,4) &&
1627 sci_matrix_scalar_real(pvApiCtx,5) && sci_matrix_vector_real(pvApiCtx,6) &&
1628 length_check(pvApiCtx,6,2))
1629 *flow = 2;
1630 else
1631 *errCode = UNKNOWN_INPUT_ERR;
1632 return;
1633 }
1634
1635 void
upcoef2_content_validate(void * pvApiCtx,int * errCode,int flow,char * l1,char * l3,int * l4,int * l5,int * l6)1636 upcoef2_content_validate (void * pvApiCtx, int *errCode, int flow, char* l1, char* l3, int* l4, int* l5, int* l6)
1637 {
1638 if ((!strcmp((l1),"a")) || (!strcmp((l1),"h")) ||
1639 (!strcmp((l1),"v")) || (!strcmp((l1),"d")))
1640 *errCode = SUCCESS;
1641 else
1642 {
1643 *errCode = OPT_CHAR_NOT_VALID;
1644 return;
1645 }
1646 switch (flow) {
1647 case 1:
1648 {
1649 wfilters_content_validate(pvApiCtx,errCode,(l3));
1650 if (((l4)[0]<=0) || ((l5)[0]<=0) ||
1651 ((l5)[1]<=0))
1652 *errCode = POSITIVE_INTEGER_ONLY;
1653 break;
1654 }
1655 case 2:
1656 {
1657 if (((l5)[0]<=0) || ((l6)[0]<=0) ||
1658 ((l6)[1]<=0))
1659 *errCode = POSITIVE_INTEGER_ONLY;
1660 break;
1661 }
1662 case 3:
1663 {
1664 wfilters_content_validate(pvApiCtx,errCode,(l3));
1665 if ((l4)[0]<=0)
1666 *errCode = POSITIVE_INTEGER_ONLY;
1667 break;
1668 }
1669 case 4:
1670 {
1671 if ((l5)[0]<=0)
1672 *errCode = POSITIVE_INTEGER_ONLY;
1673 break;
1674 }
1675 case 5:
1676 {
1677 wfilters_content_validate(pvApiCtx,errCode,(l3));
1678 break;
1679 }
1680 case 6:
1681 {
1682 break;
1683 }
1684 default:
1685 break;
1686 }
1687 return;
1688 }
1689
1690 /*-------------------------------------------
1691 * dwt3 validation
1692 *-----------------------------------------*/
1693 void
dwt3_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1694 dwt3_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1695 {
1696 *errCode = SUCCESS;
1697 if ((NInputArgument==2) && sci_mlist_check(pvApiCtx,1) &&
1698 sci_strings_scalar(pvApiCtx,2))
1699 *flow = 1;
1700 else if ((NInputArgument==3) && sci_mlist_check(pvApiCtx,1) &&
1701 sci_matrix_vector_real(pvApiCtx,2) &&
1702 sci_matrix_vector_real(pvApiCtx,3) &&
1703 vector_length_check(pvApiCtx,2,3))
1704 *flow = 2;
1705 else if ((NInputArgument==4) && sci_mlist_check(pvApiCtx,1) &&
1706 sci_strings_scalar(pvApiCtx,2) &&
1707 sci_strings_scalar(pvApiCtx,3) &&
1708 sci_strings_scalar(pvApiCtx,4))
1709 *flow = 3;
1710 else if ((NInputArgument==5) && sci_mlist_check(pvApiCtx,1) &&
1711 sci_matrix_vector_real(pvApiCtx,2) &&
1712 sci_matrix_vector_real(pvApiCtx,3) &&
1713 vector_length_check(pvApiCtx,2,3) &&
1714 sci_strings_scalar(pvApiCtx,4) &&
1715 sci_strings_scalar(pvApiCtx,5))
1716 *flow = 4;
1717 else if ((NInputArgument==4) && sci_mlist_check(pvApiCtx,1) &&
1718 sci_strings_scalar(pvApiCtx,2) &&
1719 sci_strings_scalar(pvApiCtx,3) &&
1720 sci_strings_scalar(pvApiCtx,4))
1721 *flow = 5;
1722 else if ((NInputArgument==7) && sci_mlist_check(pvApiCtx,1) &&
1723 sci_matrix_vector_real(pvApiCtx,2) &&
1724 sci_matrix_vector_real(pvApiCtx,3) &&
1725 sci_matrix_vector_real(pvApiCtx,4) &&
1726 sci_matrix_vector_real(pvApiCtx,5) &&
1727 sci_matrix_vector_real(pvApiCtx,6) &&
1728 sci_matrix_vector_real(pvApiCtx,7) &&
1729 vector_length_check(pvApiCtx,2,3) &&
1730 vector_length_check(pvApiCtx,4,5) &&
1731 vector_length_check(pvApiCtx,6,7))
1732 *flow = 6;
1733 else if ((NInputArgument==6) && sci_mlist_check(pvApiCtx,1) &&
1734 sci_strings_scalar(pvApiCtx,2) &&
1735 sci_strings_scalar(pvApiCtx,3) &&
1736 sci_strings_scalar(pvApiCtx,4) &&
1737 sci_strings_scalar(pvApiCtx,5) &&
1738 sci_strings_scalar(pvApiCtx,6) )
1739 *flow = 7;
1740 else if ((NInputArgument==9) && sci_mlist_check(pvApiCtx,1) &&
1741 sci_matrix_vector_real(pvApiCtx,2) &&
1742 sci_matrix_vector_real(pvApiCtx,3) &&
1743 sci_matrix_vector_real(pvApiCtx,4) &&
1744 sci_matrix_vector_real(pvApiCtx,5) &&
1745 sci_matrix_vector_real(pvApiCtx,6) &&
1746 sci_matrix_vector_real(pvApiCtx,7) &&
1747 vector_length_check(pvApiCtx,2,3) &&
1748 vector_length_check(pvApiCtx,4,5) &&
1749 vector_length_check(pvApiCtx,6,7) &&
1750 sci_strings_scalar(pvApiCtx,8) &&
1751 sci_strings_scalar(pvApiCtx,9) )
1752 *flow = 8;
1753 else
1754 *errCode = UNKNOWN_INPUT_ERR;
1755 return;
1756 }
1757
1758 void
dwt3_content_validate(void * pvApiCtx,int * errCode,int flow,char * l2,char * l3,char * l4,char * l5,char * l6,char * l8,char * l9)1759 dwt3_content_validate (void * pvApiCtx, int *errCode, int flow, char* l2, char* l3, char* l4, char* l5, char* l6, char* l8, char* l9)
1760 {
1761 int type, err1, err2, err3;
1762 *errCode = SUCCESS;
1763 switch (flow){
1764 case 1:
1765 {
1766 wfilters_content_validate(pvApiCtx,errCode,(l2));
1767 break;
1768 }
1769 case 2:
1770 {
1771 break;
1772 }
1773 case 3:
1774 {
1775 wfilters_content_validate(pvApiCtx,errCode,(l2));
1776 if (strcmp((l3),"mode"))
1777 *errCode = UNKNOWN_INPUT_ERR;
1778 extension_check((l4),&type);
1779 if (!type)
1780 *errCode = EXTENSION_OPT_NOT_VALID;
1781 break;
1782 }
1783 case 4:
1784 {
1785 if (strcmp((l4),"mode"))
1786 *errCode = UNKNOWN_INPUT_ERR;
1787 extension_check((l5),&type);
1788 if (!type)
1789 *errCode = EXTENSION_OPT_NOT_VALID;
1790 break;
1791 }
1792 case 5:
1793 {
1794 wfilters_content_validate(pvApiCtx,&err1,(l2));
1795 wfilters_content_validate(pvApiCtx,&err2,(l3));
1796 wfilters_content_validate(pvApiCtx,&err3,(l4));
1797 if ((err1 != SUCCESS) || (err1 != SUCCESS) ||
1798 (err1 != SUCCESS))
1799 *errCode = WAVELET_NAME_NOT_VALID;
1800 break;
1801 }
1802 case 6:
1803 {
1804
1805 break;
1806 }
1807 case 7:
1808 {
1809 wfilters_content_validate(pvApiCtx,&err1,(l2));
1810 wfilters_content_validate(pvApiCtx,&err2,(l3));
1811 wfilters_content_validate(pvApiCtx,&err3,(l4));
1812 if ((err1 != SUCCESS) || (err1 != SUCCESS) ||
1813 (err1 != SUCCESS))
1814 *errCode = WAVELET_NAME_NOT_VALID;
1815 if (strcmp((l5),"mode"))
1816 *errCode = UNKNOWN_INPUT_ERR;
1817 extension_check((l6),&type);
1818 if (!type)
1819 *errCode = EXTENSION_OPT_NOT_VALID;
1820 break;
1821 }
1822 case 8:
1823 {
1824 if (strcmp((l8),"mode"))
1825 *errCode = UNKNOWN_INPUT_ERR;
1826 extension_check((l9),&type);
1827 if (!type)
1828 *errCode = EXTENSION_OPT_NOT_VALID;
1829 break;
1830 }
1831 default:
1832 break;
1833 }
1834 return;
1835 }
1836
1837
1838 /*-------------------------------------------
1839 * idwt3 validation
1840 *-----------------------------------------*/
1841 void
idwt3_form_validate(void * pvApiCtx,int * errCode,int * flow,int NInputArgument)1842 idwt3_form_validate (void * pvApiCtx, int *errCode, int *flow, int NInputArgument)
1843 {
1844 *errCode = SUCCESS;
1845 if ((NInputArgument==2) && sci_mlist_check(pvApiCtx,1) &&
1846 sci_strings_scalar(pvApiCtx,2))
1847 *flow = 1;
1848 else if ((NInputArgument==3) && sci_mlist_check(pvApiCtx,1) &&
1849 sci_strings_scalar(pvApiCtx,2) &&
1850 sci_matrix_vector_real(pvApiCtx,3) &&
1851 length_check(pvApiCtx,3,3))
1852 *flow = 2;
1853 else if ((NInputArgument==3) && sci_mlist_check(pvApiCtx,1) &&
1854 sci_matrix_vector_real(pvApiCtx,2) &&
1855 sci_matrix_vector_real(pvApiCtx,3) &&
1856 vector_length_check(pvApiCtx,2,3))
1857 *flow = 3;
1858 else if ((NInputArgument==4) && sci_mlist_check(pvApiCtx,1) &&
1859 sci_matrix_vector_real(pvApiCtx,2) &&
1860 sci_matrix_vector_real(pvApiCtx,3) &&
1861 vector_length_check(pvApiCtx,2,3) &&
1862 sci_matrix_vector_real(pvApiCtx,4) &&
1863 length_check(pvApiCtx,4,3))
1864 *flow = 4;
1865 else if ((NInputArgument==4) && sci_mlist_check(pvApiCtx,1) &&
1866 sci_strings_scalar(pvApiCtx,2) &&
1867 sci_strings_scalar(pvApiCtx,3) &&
1868 sci_strings_scalar(pvApiCtx,4))
1869 *flow = 5;
1870 else if ((NInputArgument==5) && sci_mlist_check(pvApiCtx,1) &&
1871 sci_strings_scalar(pvApiCtx,2) &&
1872 sci_strings_scalar(pvApiCtx,3) &&
1873 sci_strings_scalar(pvApiCtx,4) &&
1874 sci_matrix_vector_real(pvApiCtx,5) &&
1875 length_check(pvApiCtx,5,3))
1876 *flow = 6;
1877 else if ((NInputArgument==7) && sci_mlist_check(pvApiCtx,1) &&
1878 sci_matrix_vector_real(pvApiCtx,2) &&
1879 sci_matrix_vector_real(pvApiCtx,3) &&
1880 sci_matrix_vector_real(pvApiCtx,4) &&
1881 sci_matrix_vector_real(pvApiCtx,5) &&
1882 sci_matrix_vector_real(pvApiCtx,6) &&
1883 sci_matrix_vector_real(pvApiCtx,7) &&
1884 vector_length_check(pvApiCtx,2,3) &&
1885 vector_length_check(pvApiCtx,4,5) &&
1886 vector_length_check(pvApiCtx,6,7))
1887 *flow = 7;
1888 else if ((NInputArgument==8) && sci_mlist_check(pvApiCtx,1) &&
1889 sci_matrix_vector_real(pvApiCtx,2) &&
1890 sci_matrix_vector_real(pvApiCtx,3) &&
1891 sci_matrix_vector_real(pvApiCtx,4) &&
1892 sci_matrix_vector_real(pvApiCtx,5) &&
1893 sci_matrix_vector_real(pvApiCtx,6) &&
1894 sci_matrix_vector_real(pvApiCtx,7) &&
1895 vector_length_check(pvApiCtx,2,3) &&
1896 vector_length_check(pvApiCtx,4,5) &&
1897 vector_length_check(pvApiCtx,6,7) &&
1898 sci_matrix_vector_real(pvApiCtx,8) &&
1899 length_check(pvApiCtx,8,3))
1900 *flow = 8;
1901 else
1902 *errCode = UNKNOWN_INPUT_ERR;
1903 return;
1904 }
1905
1906 void
idwt3_content_validate(void * pvApiCtx,int * errCode,int flow,char * l2,char * char_l3,int * l3,char * char_l4,int * l4,int * l5,int * l8)1907 idwt3_content_validate (void * pvApiCtx, int *errCode, int flow,
1908 char* l2, char* char_l3,int* l3, char* char_l4,int* l4, int* l5,
1909 int* l8)
1910 {
1911 int type, err1, err2, err3;
1912 *errCode = SUCCESS;
1913 switch (flow){
1914 case 1:
1915 {
1916 wfilters_content_validate(pvApiCtx,errCode,(l2));
1917 break;
1918 }
1919 case 2:
1920 {
1921 wfilters_content_validate(pvApiCtx,errCode,(l2));
1922 if (((l3)[0]<=0) || ((l3)[1]<=0) || ((l3)[2]<=0))
1923 {
1924 *errCode = UNKNOWN_INPUT_ERR;
1925 }
1926 break;
1927 }
1928 case 3:
1929 {
1930 break;
1931 }
1932 case 4:
1933 {
1934 if (((l4)[0]<=0) || ((l4)[1]<=0) || ((l4)[2]<=0))
1935 {
1936 *errCode = UNKNOWN_INPUT_ERR;
1937 }
1938 break;
1939 }
1940 case 5:
1941 {
1942 wfilters_content_validate(pvApiCtx,&err1,(l2));
1943 wfilters_content_validate(pvApiCtx,&err2,char_l3);
1944 wfilters_content_validate(pvApiCtx,&err3,char_l4);
1945 if ((err1 != SUCCESS) || (err1 != SUCCESS) ||
1946 (err1 != SUCCESS))
1947 *errCode = WAVELET_NAME_NOT_VALID;
1948 break;
1949 }
1950 case 6:
1951 {
1952 wfilters_content_validate(pvApiCtx,&err1,(l2));
1953 wfilters_content_validate(pvApiCtx,&err2,char_l3);
1954 wfilters_content_validate(pvApiCtx,&err3,char_l4);
1955 if ((err1 != SUCCESS) || (err1 != SUCCESS) ||
1956 (err1 != SUCCESS))
1957 *errCode = WAVELET_NAME_NOT_VALID;
1958 if (((l5)[0]<=0) || ((l5)[1]<=0) || ((l5)[2]<=0))
1959 {
1960 *errCode = UNKNOWN_INPUT_ERR;
1961 }
1962 break;
1963 }
1964 case 7:
1965 {
1966 break;
1967 }
1968 case 8:
1969 {
1970 if (((l8)[0]<=0) || ((l8)[1]<=0) || ((l8)[2]<=0))
1971 {
1972 *errCode = UNKNOWN_INPUT_ERR;
1973 }
1974 break;
1975 }
1976 default:
1977 break;
1978 }
1979 return;
1980 }
1981