1 /*
2 * -------------------------------------------------------------------------
3 * utility_int.c -- utility function interface
4 * SWT - Scilab wavelet toolbox
5 * Copyright (C) 2005-2007 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
24 #include "swt_common.h"
25
26
27 // #include <stack-c.h>
28
29 /*-------------------------------------------
30 * convolution
31 *-----------------------------------------*/
32
33 int
int_conv(char * fname,void * pvApiCtx)34 int_conv
35 #ifdef _SCILAB6_
36 (char *fname, void* pvApiCtx)
37 #else
38 (char *fname)
39 #endif
40 {
41 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
42 static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
43 int errCode;
44 int readFlag;
45 double *input1;
46 double *input2;
47 double *output1;
48 /* Input Validation */
49 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
50 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
51 /* Get Input */
52 //GetRhsVar (1, "d", &m1, &n1, &l1);
53 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
54 if(readFlag==SWT_GWSUPPORT_ERROR)
55 {
56 return 0;
57 }
58 //GetRhsVar (2, "d", &m2, &n2, &l2);
59 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
60 if(readFlag==SWT_GWSUPPORT_ERROR)
61 {
62 return 0;
63 }
64 conv_validate (pvApiCtx, &errCode);
65 if (errCode != SUCCESS)
66 {
67 validate_print (errCode); /* Indicate error */
68 return 0; /* Stop when validation fails */
69 }
70 /* Memory Management */
71 m3 = 1;
72 n3 = m1 * n1 + m2 * n2 - 1;
73 // CreateVar (3, "d", &m3, &n3, &l3);
74 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
75 if(readFlag==SWT_GWSUPPORT_ERROR)
76 {
77 return 0;
78 }
79
80 /* Actual Processing */
81 conv (input1, n1 * m1, output1, n3, input2, n2 * m2);
82 /* Return Value */
83 //LhsVar (1) = 3;
84 return 0;
85 }
86
87 /*-------------------------------------------
88 * circular or periodic convolution
89 *-----------------------------------------*/
90
91 int
int_iconv(char * fname,void * pvApiCtx)92 int_iconv
93 #ifdef _SCILAB6_
94 (char *fname, void* pvApiCtx)
95 #else
96 (char *fname)
97 #endif
98 {
99 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
100 static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
101 int errCode;
102 int readFlag;
103 double *input1;
104 double *input2;
105 double *output1;
106 /* Input Validation */
107 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
108 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
109 /* Get Input */
110 //GetRhsVar (1, "d", &m1, &n1, &l1);
111 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
112 if(readFlag==SWT_GWSUPPORT_ERROR)
113 {
114 return 0;
115 }
116 //GetRhsVar (2, "d", &m2, &n2, &l2);
117 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
118 if(readFlag==SWT_GWSUPPORT_ERROR)
119 {
120 return 0;
121 }
122 conv_validate (pvApiCtx, &errCode);
123
124 if (errCode != SUCCESS)
125 {
126 validate_print (errCode);
127 return 0;
128 }
129 /* Memory Management */
130 m3 = 1;
131 if (m1*n1>m2*n2)
132 n3 = m1 * n1;
133 else
134 n3 = m2 * n2;
135 //CreateVar (3, "d", &m3, &n3, &l3);
136 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
137 if(readFlag==SWT_GWSUPPORT_ERROR)
138 {
139 return 0;
140 }
141 /* Actual Processing */
142 if (m1*n1>m2*n2)
143 i_conv (input1, n1 * m1, output1, n3, input2, n2 * m2);
144 else
145 i_conv (input2, n2 * m2, output1, n3, input1, n1 * m1);
146 /* Return Value */
147 //LhsVar (1) = 3;
148 return 0;
149 }
150
151
152 /*-------------------------------------------
153 * wrev
154 *-----------------------------------------*/
155
156 int
int_wrev(char * fname,void * pvApiCtx)157 int_wrev
158 #ifdef _SCILAB6_
159 (char *fname, void* pvApiCtx)
160 #else
161 (char *fname)
162 #endif
163 {
164 static int l1, m1, n1, l2, m2, n2;
165 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
166 int errCode;
167 int readFlag;
168 double *input1;
169 double *output1;
170
171 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
172 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
173
174 wrev_validate (pvApiCtx, &errCode);
175 if (errCode != SUCCESS)
176 {
177 validate_print (errCode);
178 return 0;
179 }
180 //GetRhsVar (1, "d", &m1, &n1, &l1);
181 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
182 if(readFlag==SWT_GWSUPPORT_ERROR)
183 {
184 return 0;
185 }
186
187 m2 = m1;
188 n2 = n1;
189 //CreateVar (2, "d", &m2, &n2, &l2);
190 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
191 if(readFlag==SWT_GWSUPPORT_ERROR)
192 {
193 return 0;
194 }
195
196 wrev (input1, n1 * m1, output1, n1 * m1);
197
198 //LhsVar (1) = 2;
199 return 0;
200 }
201
202 /*-------------------------------------------
203 * qmf
204 *-----------------------------------------*/
205
206 int
int_qmf(char * fname,void * pvApiCtx)207 int_qmf
208 #ifdef _SCILAB6_
209 (char *fname, void* pvApiCtx)
210 #else
211 (char *fname)
212 #endif
213 {
214 static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
215 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 2;
216 int errCode, flow;
217 int readFlag;
218 double *input1;
219 int *int_input2;
220 double *output1;
221 /* Input Validation */
222 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
223 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
224
225 qmf_validate (pvApiCtx, &flow, &errCode, Rhs);
226 if (errCode != SUCCESS)
227 {
228 validate_print (errCode);
229 return 0;
230 }
231
232 //GetRhsVar (1, "d", &m1, &n1, &l1);
233 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
234 if(readFlag==SWT_GWSUPPORT_ERROR)
235 {
236 return 0;
237 }
238
239 switch (flow){
240 case 1:
241 {
242 m2 = m1;
243 n2 = n1;
244 //CreateVar (2, "d", &m2, &n2, &l2);
245 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
246 if(readFlag==SWT_GWSUPPORT_ERROR)
247 {
248 return 0;
249 }
250 qmf_even (input1, n1 * m1, output1, n1 * m1);
251 //LhsVar (1) = 2;
252 break;
253 }
254 case 2:
255 {
256 //GetRhsVar (2, "i", &m2, &n2, &l2);
257 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
258 if(readFlag==SWT_GWSUPPORT_ERROR)
259 {
260 return 0;
261 }
262 m3 = m1;
263 n3 = n1;
264 //CreateVar (3, "d", &m3, &n3, &l3);
265 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
266 if(readFlag==SWT_GWSUPPORT_ERROR)
267 {
268 return 0;
269 }
270 if ((int_input2[0] % 2) == 0) /* even */
271 qmf_even (input1, n1 * m1, output1, n1 * m1);
272 else
273 qmf_odd (input1, n1 * m1, output1, n1 * m1);
274 //LhsVar (1) = 3;
275 break;
276 }
277 default:
278 break;
279 }
280 return 0;
281 }
282
283
284 /*-------------------------------------------
285 * dyaddown
286 *-----------------------------------------*/
287
288 int
int_dyaddown(char * fname,void * pvApiCtx)289 int_dyaddown
290 #ifdef _SCILAB6_
291 (char *fname, void* pvApiCtx)
292 #else
293 (char *fname)
294 #endif
295 {
296 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, l4, m4, n4;
297 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 3;
298 int flow, errCode;
299 int readFlag;
300 double *input1;
301 int *int_input2;
302 int *int_input3;
303 char * input_string1 = NULL;
304 double *output1;
305 /* Input Validation */
306 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
307 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
308
309 flow = 0;
310 dyaddown_form_validate (pvApiCtx, &flow, &errCode, Rhs);
311 if (errCode != SUCCESS)
312 {
313 validate_print (errCode);
314 return 0;
315 }
316
317 switch (flow){
318 case 1:
319 {
320 //GetRhsVar (1, "d", &m1, &n1, &l1);
321 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
322 if(readFlag==SWT_GWSUPPORT_ERROR)
323 {
324 return 0;
325 }
326 if (m1 > 1)
327 {
328 m2 = m1 / 2;// + (m1%2==0)?0:1;
329 n2 = 1;
330 }
331 else
332 {
333 m2 = 1;
334 n2 = n1 / 2;// + (n1%2==0)?0:1;
335 }
336 //CreateVar (2, "d", &m2, &n2, &l2);
337 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
338 if(readFlag==SWT_GWSUPPORT_ERROR)
339 {
340 return 0;
341 }
342 dyaddown_1D_keep_even (input1, n1 * m1, output1, n2 * m2);
343 //LhsVar (1) = 2;
344 break;
345 }
346 case 2:
347 {
348 //GetRhsVar (1, "d", &m1, &n1, &l1);
349 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
350 if(readFlag==SWT_GWSUPPORT_ERROR)
351 {
352 return 0;
353 }
354 //GetRhsVar (2, "i", &m2, &n2, &l2);
355 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
356 if(readFlag==SWT_GWSUPPORT_ERROR)
357 {
358 return 0;
359 }
360 // if (m1 > 1)
361 //{
362 // m3 = m1 / 2;
363 // n3 = 1;
364 //}
365 // else
366 //{
367 // m3 = 1;
368 // n3 = n1 / 2;
369 //}
370 // CreateVar (3, "d", &m3, &n3, &l3);
371
372 if (int_input2[0] % 2 == 0)
373 {
374 if (m1 > 1)
375 {
376 m3 = m1 / 2;
377 n3 = 1;
378 }
379 else
380 {
381 m3 = 1;
382 n3 = n1 / 2;
383 }
384 //CreateVar (3, "d", &m3, &n3, &l3);
385 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
386 if(readFlag==SWT_GWSUPPORT_ERROR)
387 {
388 return 0;
389 }
390 dyaddown_1D_keep_even (input1, n1 * m1, output1, n3 * m3);
391 }
392 else
393 {
394 if (m1 > 1)
395 {
396 m3 = m1 / 2;// + ((m1%2)==0)?0:1;
397 n3 = 1;
398 if (m1 % 2 != 0)
399 m3 += 1;
400 }
401 else
402 {
403 m3 = 1;
404 n3 = n1 / 2;// + ((n1%2)==0)?0:1;
405 if (n1 % 2 != 0)
406 n3 += 1;
407 }
408 //sprintf("%d\n",m3);
409 //sprintf("%d\n",n3);
410 //CreateVar (3, "d", &m3, &n3, &l3);
411 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
412 if(readFlag==SWT_GWSUPPORT_ERROR)
413 {
414 return 0;
415 }
416 dyaddown_1D_keep_odd (input1, n1 * m1, output1, n3 * m3);
417 }
418 //LhsVar (1) = 3;
419 break;
420 }
421 case 3:
422 {
423 //GetRhsVar (1, "d", &m1, &n1, &l1);
424 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
425 if(readFlag==SWT_GWSUPPORT_ERROR)
426 {
427 return 0;
428 }
429 //m2 = m1 / 2;
430 m2 = m1;
431 n2 = n1 / 2;
432 //CreateVar (2, "d", &m2, &n2, &l2);
433 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
434 if(readFlag==SWT_GWSUPPORT_ERROR)
435 {
436 return 0;
437 }
438 //dyaddown_2D_keep_even (input1, m1, n1, stk(l2), m2, n2);
439 dyaddown_2D_keep_even_col(input1, m1, n1, output1, m2, n2);
440 //LhsVar (1) = 2;
441 break;
442 }
443 case 4:
444 {
445 //GetRhsVar (1, "d", &m1, &n1, &l1);
446 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
447 if(readFlag==SWT_GWSUPPORT_ERROR)
448 {
449 return 0;
450 }
451 //GetRhsVar (2, "c", &m2, &n2, &l2);
452 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string1 );
453 m2=1;n2=1;
454 if(readFlag==SWT_GWSUPPORT_ERROR)
455 {
456 return 0;
457 }
458 //printf("%c\n",cstk(l2)[0]);
459 dyaddown_content_validate (pvApiCtx, input_string1, &errCode);
460 if (errCode != SUCCESS)
461 {
462 validate_print (errCode);
463 return 0;
464 }
465 if (strcmp(input_string1,"r")==0)
466 {
467 m3 = m1 / 2;
468 n3 = n1;
469 //CreateVar (3, "d", &m3, &n3, &l3);
470 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
471 if(readFlag==SWT_GWSUPPORT_ERROR)
472 {
473 return 0;
474 }
475 dyaddown_2D_keep_even_row(input1, m1, n1,
476 output1, m3, n3);
477 }
478 if (strcmp(input_string1,"c")==0)
479 {
480 m3 = m1;
481 n3 = n1 / 2;
482 //CreateVar (3, "d", &m3, &n3, &l3);
483 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
484 if(readFlag==SWT_GWSUPPORT_ERROR)
485 {
486 return 0;
487 }
488 dyaddown_2D_keep_even_col(input1, m1, n1,
489 output1, m3, n3);
490 }
491 if (strcmp(input_string1,"m")==0)
492 {
493 m3 = m1 / 2;
494 n3 = n1 / 2;
495 //CreateVar (3, "d", &m3, &n3, &l3);
496 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
497 if(readFlag==SWT_GWSUPPORT_ERROR)
498 {
499 return 0;
500 }
501 dyaddown_2D_keep_even(input1, m1, n1, output1, m3, n3);
502 }
503 //LhsVar (1) = 3;
504 break;
505 }
506 case 5:
507 {
508 //GetRhsVar (1, "d", &m1, &n1, &l1);
509 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
510 if(readFlag==SWT_GWSUPPORT_ERROR)
511 {
512 return 0;
513 }
514 //GetRhsVar (2, "i", &m2, &n2, &l2);
515 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
516 if(readFlag==SWT_GWSUPPORT_ERROR)
517 {
518 return 0;
519 }
520 //m3 = m1 / 2;
521
522 if (int_input2[0]%2==0)
523 {
524 m3 = m1;
525 n3 = n1 / 2;
526 //CreateVar (3, "d", &m3, &n3, &l3);
527 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
528 if(readFlag==SWT_GWSUPPORT_ERROR)
529 {
530 return 0;
531 }
532 dyaddown_2D_keep_even_col(input1, m1, n1, output1, m3, n3);
533 }
534 else
535 {
536 m3 = m1;
537 n3 = n1 /2;
538 if (n1 % 2 != 0)
539 n3 += 1;
540 //CreateVar (3, "d", &m3, &n3, &l3);
541 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
542 if(readFlag==SWT_GWSUPPORT_ERROR)
543 {
544 return 0;
545 }
546 dyaddown_2D_keep_odd_col(input1, m1, n1, output1, m3, n3);
547 }
548 //LhsVar (1) = 3;
549 break;
550 }
551 case 6:
552 {
553 //GetRhsVar (1, "d", &m1, &n1, &l1);
554 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
555 if(readFlag==SWT_GWSUPPORT_ERROR)
556 {
557 return 0;
558 }
559 //GetRhsVar (2, "i", &m2, &n2, &l2);
560 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
561 if(readFlag==SWT_GWSUPPORT_ERROR)
562 {
563 return 0;
564 }
565 //GetRhsVar (3, "c", &m3, &n3, &l3);
566 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
567 m3=1;n3=1;
568 if(readFlag==SWT_GWSUPPORT_ERROR)
569 {
570 return 0;
571 }
572 dyaddown_content_validate (pvApiCtx, input_string1, &errCode);
573 if (errCode != SUCCESS)
574 {
575 validate_print (errCode);
576 return 0;
577 }
578 if ((int_input2[0])%2==0)
579 {
580 if (strcmp(input_string1,"r")==0)
581 {
582 m4 = m1 / 2;
583 n4 = n1;
584 //CreateVar (4, "d", &m4, &n4, &l4);
585 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
586 if(readFlag==SWT_GWSUPPORT_ERROR)
587 {
588 return 0;
589 }
590 dyaddown_2D_keep_even_row(input1, m1, n1,
591 output1, m4, n4);
592 }
593 if (strcmp(input_string1,"c")==0)
594 {
595 m4 = m1;
596 n4 = n1 / 2;
597 //CreateVar (4, "d", &m4, &n4, &l4);
598 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
599 if(readFlag==SWT_GWSUPPORT_ERROR)
600 {
601 return 0;
602 }
603 dyaddown_2D_keep_even_col(input1, m1, n1,
604 output1, m4, n4);
605 }
606 if (strcmp(input_string1,"m")==0)
607 {
608 m4 = m1 / 2;
609 n4 = n1 / 2;
610 //CreateVar (4, "d", &m4, &n4, &l4);
611 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
612 if(readFlag==SWT_GWSUPPORT_ERROR)
613 {
614 return 0;
615 }
616 dyaddown_2D_keep_even(input1, m1, n1,
617 output1, m4, n4);
618 }
619 }
620 else
621 {
622 if (strcmp(input_string1,"r")==0)
623 {
624 m4 = m1 / 2;
625 n4 = n1;
626 if (m1 % 2 != 0)
627 m4 += 1;
628 //CreateVar (4, "d", &m4, &n4, &l4);
629 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
630 if(readFlag==SWT_GWSUPPORT_ERROR)
631 {
632 return 0;
633 }
634 dyaddown_2D_keep_odd_row(input1, m1, n1,
635 output1, m4, n4);
636 }
637 if (strcmp(input_string1,"c")==0)
638 {
639 m4 = m1;
640 n4 = n1 / 2;
641 if (n1 % 2 != 0)
642 n4 += 1;
643 //CreateVar (4, "d", &m4, &n4, &l4);
644 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
645 if(readFlag==SWT_GWSUPPORT_ERROR)
646 {
647 return 0;
648 }
649 dyaddown_2D_keep_odd_col(input1, m1, n1,
650 output1, m4, n4);
651 }
652 if (strcmp(input_string1,"m")==0)
653 {
654 m4 = m1 / 2;
655 n4 = n1 / 2;
656 if (m1 % 2 != 0)
657 m4 += 1;
658 if (n1 % 2 != 0)
659 n4 += 1;
660 //CreateVar (4, "d", &m4, &n4, &l4);
661 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
662 if(readFlag==SWT_GWSUPPORT_ERROR)
663 {
664 return 0;
665 }
666 dyaddown_2D_keep_odd(input1, m1, n1,
667 output1, m4, n4);
668 }
669 }
670 //LhsVar (1) = 4;
671 break;
672 }
673 case 7:
674 {
675 //GetRhsVar (1, "d", &m1, &n1, &l1);
676 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
677 if(readFlag==SWT_GWSUPPORT_ERROR)
678 {
679 return 0;
680 }
681 //GetRhsVar (2, "c", &m2, &n2, &l2);
682 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string1 );
683 if(readFlag==SWT_GWSUPPORT_ERROR)
684 {
685 return 0;
686 }
687 //GetRhsVar (3, "i", &m3, &n3, &l3);
688 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 3, &m3, &n3, &int_input3);
689 if(readFlag==SWT_GWSUPPORT_ERROR)
690 {
691 return 0;
692 }
693 dyaddown_content_validate (pvApiCtx, input_string1, &errCode);
694 if (errCode != SUCCESS)
695 {
696 validate_print (errCode);
697 return 0;
698 }
699 if ((int_input3[0])%2==0)
700 {
701 if (strcmp(input_string1,"r")==0)
702 {
703 m4 = m1 / 2;
704 n4 = n1;
705 //CreateVar (4, "d", &m4, &n4, &l4);
706 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
707 if(readFlag==SWT_GWSUPPORT_ERROR)
708 {
709 return 0;
710 }
711 dyaddown_2D_keep_even_row(input1, m1, n1,
712 output1, m4, n4);
713 }
714 if (strcmp(input_string1,"c")==0)
715 {
716 m4 = m1;
717 n4 = n1 / 2;
718 //CreateVar (4, "d", &m4, &n4, &l4);
719 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
720 if(readFlag==SWT_GWSUPPORT_ERROR)
721 {
722 return 0;
723 }
724 dyaddown_2D_keep_even_col(input1, m1, n1,
725 output1, m4, n4);
726 }
727 if (strcmp(input_string1,"m")==0)
728 {
729 m4 = m1 / 2;
730 n4 = n1 / 2;
731 //CreateVar (4, "d", &m4, &n4, &l4);
732 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
733 if(readFlag==SWT_GWSUPPORT_ERROR)
734 {
735 return 0;
736 }
737 dyaddown_2D_keep_even(input1, m1, n1,
738 output1, m4, n4);
739 }
740 }
741 else
742 {
743 if (strcmp(input_string1,"r")==0)
744 {
745 m4 = m1 / 2;
746 n4 = n1;
747 if (m1 % 2 != 0)
748 m4 += 1;
749 //CreateVar (4, "d", &m4, &n4, &l4);
750 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
751 if(readFlag==SWT_GWSUPPORT_ERROR)
752 {
753 return 0;
754 }
755 dyaddown_2D_keep_odd_row(input1, m1, n1,
756 output1, m4, n4);
757 }
758 if (strcmp(input_string1,"c")==0)
759 {
760 m4 = m1;
761 n4 = n1 / 2;
762 if (n1 % 2 != 0)
763 n4 += 1;
764 //CreateVar (4, "d", &m4, &n4, &l4);
765 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
766 if(readFlag==SWT_GWSUPPORT_ERROR)
767 {
768 return 0;
769 }
770 dyaddown_2D_keep_odd_col(input1, m1, n1,
771 output1, m4, n4);
772 }
773 if (strcmp(input_string1,"m")==0)
774 {
775 m4 = m1 / 2;
776 n4 = n1 / 2;
777 if (m1 % 2 != 0)
778 m4 += 1;
779 if (n1 % 2 != 0)
780 n4 += 1;
781 //CreateVar (4, "d", &m4, &n4, &l4);
782 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
783 if(readFlag==SWT_GWSUPPORT_ERROR)
784 {
785 return 0;
786 }
787 dyaddown_2D_keep_odd(input1, m1, n1,
788 output1, m4, n4);
789 }
790 }
791 //LhsVar (1) = 4;
792 break;
793 }
794 default:
795 break;
796 }
797 return 0;
798 }
799
800 /*-------------------------------------------
801 * dyadup
802 *-----------------------------------------*/
803
804 int
int_dyadup(char * fname,void * pvApiCtx)805 int_dyadup
806 #ifdef _SCILAB6_
807 (char *fname, void* pvApiCtx)
808 #else
809 (char *fname)
810 #endif
811 {
812 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, l4, m4, n4;
813 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 3;
814 int flow, errCode;
815 int readFlag;
816 double *input1;
817 int *int_input2;
818 int *int_input3;
819 char * input_string1 = NULL;
820 double *output1;
821 /* Input Validation */
822 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
823 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
824
825 flow = 0;
826 dyadup_form_validate (pvApiCtx, &flow, &errCode, Rhs);
827 if (errCode != SUCCESS)
828 {
829 validate_print (errCode);
830 return 0;
831 }
832
833 switch (flow){
834 case 1:
835 {
836 //GetRhsVar (1, "d", &m1, &n1, &l1);
837 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
838 if(readFlag==SWT_GWSUPPORT_ERROR)
839 {
840 return 0;
841 }
842 if (m1 > 1)
843 {
844 m2 = m1 * 2 + 1;
845 n2 = 1;
846 }
847 else
848 {
849 m2 = 1;
850 n2 = n1 * 2 + 1;
851 }
852 //CreateVar (2, "d", &m2, &n2, &l2);
853 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
854 if(readFlag==SWT_GWSUPPORT_ERROR)
855 {
856 return 0;
857 }
858 dyadup_1D_feed_even (input1, n1 * m1, output1, n2 * m2);
859 LhsVar (1) = 2;
860 break;
861 }
862 case 2:
863 {
864 //GetRhsVar (1, "d", &m1, &n1, &l1);
865 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
866 if(readFlag==SWT_GWSUPPORT_ERROR)
867 {
868 return 0;
869 }
870 //GetRhsVar (2, "i", &m2, &n2, &l2);
871 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
872 if(readFlag==SWT_GWSUPPORT_ERROR)
873 {
874 return 0;
875 }
876 if (int_input2[0] % 2 == 0)
877 {
878 if (m1 > 1)
879 {
880 m3 = m1 * 2 - 1;
881 n3 = 1;
882 }
883 else
884 {
885 m3 = 1;
886 n3 = n1 * 2 - 1;
887 }
888 //CreateVar (3, "d", &m3, &n3, &l3);
889 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
890 if(readFlag==SWT_GWSUPPORT_ERROR)
891 {
892 return 0;
893 }
894 dyadup_1D_feed_odd (input1, n1 * m1, output1, n3 * m3);
895 }
896 else
897 {
898 if (m1 > 1)
899 {
900 m3 = m1 * 2 + 1;
901 n3 = 1;
902 }
903 else
904 {
905 m3 = 1;
906 n3 = n1 * 2 + 1;
907 }
908 //CreateVar (3, "d", &m3, &n3, &l3);
909 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
910 if(readFlag==SWT_GWSUPPORT_ERROR)
911 {
912 return 0;
913 }
914 dyadup_1D_feed_even (input1, n1 * m1, output1, n3 * m3);
915 }
916 //LhsVar (1) = 3;
917 break;
918 }
919 case 3:
920 {
921 //GetRhsVar (1, "d", &m1, &n1, &l1);
922 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
923 if(readFlag==SWT_GWSUPPORT_ERROR)
924 {
925 return 0;
926 }
927 //m2 = m1 * 2 + 1;
928 //n2 = n1 * 2 + 1;
929 m2 = m1;
930 n2 = n1 * 2 + 1;
931 //CreateVar (2, "d", &m2, &n2, &l2);
932 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
933 if(readFlag==SWT_GWSUPPORT_ERROR)
934 {
935 return 0;
936 }
937 dyadup_2D_feed_even_col (input1, m1, n1, output1, m2, n2);
938 //dyadup_2D_feed_even (input1, m1, n1, stk(l2), m2, n2);
939 //LhsVar (1) = 2;
940 break;
941 }
942 case 4:
943 {
944 //GetRhsVar (1, "d", &m1, &n1, &l1);
945 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
946 if(readFlag==SWT_GWSUPPORT_ERROR)
947 {
948 return 0;
949 }
950 //GetRhsVar (2, "c", &m2, &n2, &l2);
951 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string1 );
952 if(readFlag==SWT_GWSUPPORT_ERROR)
953 {
954 return 0;
955 }
956 dyadup_content_validate (pvApiCtx, input_string1, &errCode);
957 if (errCode != SUCCESS)
958 {
959 validate_print (errCode);
960 return 0;
961 }
962 if (strcmp(input_string1,"r")==0)
963 {
964 m3 = m1 * 2 + 1;
965 n3 = n1;
966 //CreateVar (3, "d", &m3, &n3, &l3);
967 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
968 if(readFlag==SWT_GWSUPPORT_ERROR)
969 {
970 return 0;
971 }
972 dyadup_2D_feed_even_row(input1, m1, n1,
973 output1, m3, n3);
974 }
975 if (strcmp(input_string1,"c")==0)
976 {
977 m3 = m1;
978 n3 = n1 * 2 + 1;
979 //CreateVar (3, "d", &m3, &n3, &l3);
980 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
981 if(readFlag==SWT_GWSUPPORT_ERROR)
982 {
983 return 0;
984 }
985 dyadup_2D_feed_even_col(input1, m1, n1,
986 output1, m3, n3);
987 }
988 if (strcmp(input_string1,"m")==0)
989 {
990 m3 = m1 * 2 + 1;
991 n3 = n1 * 2 + 1;
992 //CreateVar (3, "d", &m3, &n3, &l3);
993 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
994 if(readFlag==SWT_GWSUPPORT_ERROR)
995 {
996 return 0;
997 }
998 dyadup_2D_feed_even(input1, m1, n1, output1, m3, n3);
999 }
1000 //LhsVar (1) = 3;
1001 break;
1002 }
1003 case 5:
1004 {
1005 //GetRhsVar (1, "d", &m1, &n1, &l1);
1006 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1007 if(readFlag==SWT_GWSUPPORT_ERROR)
1008 {
1009 return 0;
1010 }
1011 //GetRhsVar (2, "i", &m2, &n2, &l2);
1012 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1013 if(readFlag==SWT_GWSUPPORT_ERROR)
1014 {
1015 return 0;
1016 }
1017 if (int_input2[0]%2==0)
1018 {
1019 //m3 = m1 * 2 - 1;
1020 //n3 = n1 * 2 - 1;
1021 m3 = m1;
1022 n3 = n1 * 2 - 1;
1023 //CreateVar (3, "d", &m3, &n3, &l3);
1024 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
1025 if(readFlag==SWT_GWSUPPORT_ERROR)
1026 {
1027 return 0;
1028 }
1029 //dyadup_2D_feed_odd(input1, m1, n1, stk(l3), m3, n3);
1030 dyadup_2D_feed_odd_col(input1, m1, n1, output1, m3, n3);
1031 }
1032 else
1033 {
1034 //m3 = m1 * 2 + 1;
1035 //n3 = n1 * 2 + 1;
1036 m3 = m1;
1037 n3 = n1 * 2 + 1;
1038 //CreateVar (3, "d", &m3, &n3, &l3);
1039 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
1040 if(readFlag==SWT_GWSUPPORT_ERROR)
1041 {
1042 return 0;
1043 }
1044 //dyadup_2D_feed_even(input1, m1, n1, stk(l3), m3, n3);
1045 dyadup_2D_feed_even_col(input1, m1, n1, output1, m3, n3);
1046 }
1047 //LhsVar (1) = 3;
1048 break;
1049 }
1050 case 6:
1051 {
1052 //GetRhsVar (1, "d", &m1, &n1, &l1);
1053 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1054 if(readFlag==SWT_GWSUPPORT_ERROR)
1055 {
1056 return 0;
1057 }
1058 //GetRhsVar (2, "i", &m2, &n2, &l2);
1059 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1060 if(readFlag==SWT_GWSUPPORT_ERROR)
1061 {
1062 return 0;
1063 }
1064 //GetRhsVar (3, "c", &m3, &n3, &l3);
1065 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
1066 m3=1;n3=1;
1067 if(readFlag==SWT_GWSUPPORT_ERROR)
1068 {
1069 return 0;
1070 }
1071 dyadup_content_validate (pvApiCtx, input_string1, &errCode);
1072 if (errCode != SUCCESS)
1073 {
1074 validate_print (errCode);
1075 return 0;
1076 }
1077 if ((int_input2[0])%2==0)
1078 {
1079 if (strcmp(input_string1,"r")==0)
1080 {
1081 m4 = m1 * 2 - 1;
1082 n4 = n1;
1083 //CreateVar (4, "d", &m4, &n4, &l4);
1084 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1085 if(readFlag==SWT_GWSUPPORT_ERROR)
1086 {
1087 return 0;
1088 }
1089 dyadup_2D_feed_odd_row(input1, m1, n1,
1090 output1, m4, n4);
1091 }
1092 if (strcmp(input_string1,"c")==0)
1093 {
1094 m4 = m1;
1095 n4 = n1 * 2 - 1;
1096 //CreateVar (4, "d", &m4, &n4, &l4);
1097 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1098 if(readFlag==SWT_GWSUPPORT_ERROR)
1099 {
1100 return 0;
1101 }
1102 dyadup_2D_feed_odd_col(input1, m1, n1,
1103 output1, m4, n4);
1104 }
1105 if (strcmp(input_string1,"m")==0)
1106 {
1107 m4 = m1 * 2 - 1;
1108 n4 = n1 * 2 - 1;
1109 //CreateVar (4, "d", &m4, &n4, &l4);
1110 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1111 if(readFlag==SWT_GWSUPPORT_ERROR)
1112 {
1113 return 0;
1114 }
1115 dyadup_2D_feed_odd(input1, m1, n1,
1116 output1, m4, n4);
1117 }
1118 }
1119 else
1120 {
1121 if (strcmp(input_string1,"r")==0)
1122 {
1123 m4 = m1 * 2 + 1;
1124 n4 = n1;
1125 //CreateVar (4, "d", &m4, &n4, &l4);
1126 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1127 if(readFlag==SWT_GWSUPPORT_ERROR)
1128 {
1129 return 0;
1130 }
1131 dyadup_2D_feed_even_row(input1, m1, n1,
1132 output1, m4, n4);
1133 }
1134 if (strcmp(input_string1,"c")==0)
1135 {
1136 m4 = m1;
1137 n4 = n1 * 2 + 1;
1138 //CreateVar (4, "d", &m4, &n4, &l4);
1139 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1140 if(readFlag==SWT_GWSUPPORT_ERROR)
1141 {
1142 return 0;
1143 }
1144 dyadup_2D_feed_even_col(input1, m1, n1,
1145 output1, m4, n4);
1146 }
1147 if (strcmp(input_string1,"m")==0)
1148 {
1149 m4 = m1 * 2 + 1;
1150 n4 = n1 * 2 + 1;
1151 //CreateVar (4, "d", &m4, &n4, &l4);
1152 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1153 if(readFlag==SWT_GWSUPPORT_ERROR)
1154 {
1155 return 0;
1156 }
1157 dyadup_2D_feed_even(input1, m1, n1,
1158 output1, m4, n4);
1159 }
1160 }
1161 LhsVar (1) = 4;
1162 break;
1163 }
1164 case 7:
1165 {
1166 //GetRhsVar (1, "d", &m1, &n1, &l1);
1167 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1168 if(readFlag==SWT_GWSUPPORT_ERROR)
1169 {
1170 return 0;
1171 }
1172 //GetRhsVar (2, "c", &m2, &n2, &l2);
1173 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string1 );
1174 if(readFlag==SWT_GWSUPPORT_ERROR)
1175 {
1176 return 0;
1177 }
1178 //GetRhsVar (3, "i", &m3, &n3, &l3);
1179 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 3, &m3, &n3, &int_input3);
1180 if(readFlag==SWT_GWSUPPORT_ERROR)
1181 {
1182 return 0;
1183 }
1184 dyadup_content_validate (pvApiCtx, input_string1, &errCode);
1185 if (errCode != SUCCESS)
1186 {
1187 validate_print (errCode);
1188 return 0;
1189 }
1190 if ((int_input3[0])%2==0)
1191 {
1192 if (strcmp(input_string1,"r")==0)
1193 {
1194 m4 = m1 * 2 - 1;
1195 n4 = n1;
1196 //CreateVar (4, "d", &m4, &n4, &l4);
1197 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1198 if(readFlag==SWT_GWSUPPORT_ERROR)
1199 {
1200 return 0;
1201 }
1202 dyadup_2D_feed_odd_row(input1, m1, n1,
1203 output1, m4, n4);
1204 }
1205 if (strcmp(input_string1,"c")==0)
1206 {
1207 m4 = m1;
1208 n4 = n1 * 2 - 1;
1209 //CreateVar (4, "d", &m4, &n4, &l4);
1210 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1211 if(readFlag==SWT_GWSUPPORT_ERROR)
1212 {
1213 return 0;
1214 }
1215 dyadup_2D_feed_odd_col(input1, m1, n1,
1216 output1, m4, n4);
1217 }
1218 if (strcmp(input_string1,"m")==0)
1219 {
1220 m4 = m1 * 2 - 1;
1221 n4 = n1 * 2 - 1;
1222 //CreateVar (4, "d", &m4, &n4, &l4);
1223 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1224 if(readFlag==SWT_GWSUPPORT_ERROR)
1225 {
1226 return 0;
1227 }
1228 dyadup_2D_feed_odd(input1, m1, n1,
1229 output1, m4, n4);
1230 }
1231 }
1232 else
1233 {
1234 if (strcmp(input_string1,"r")==0)
1235 {
1236 m4 = m1 * 2 + 1;
1237 n4 = n1;
1238 //CreateVar (4, "d", &m4, &n4, &l4);
1239 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1240 if(readFlag==SWT_GWSUPPORT_ERROR)
1241 {
1242 return 0;
1243 }
1244 dyadup_2D_feed_even_row(input1, m1, n1,
1245 output1, m4, n4);
1246 }
1247 if (strcmp(input_string1,"c")==0)
1248 {
1249 m4 = m1;
1250 n4 = n1 * 2 + 1;
1251 //CreateVar (4, "d", &m4, &n4, &l4);
1252 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1253 if(readFlag==SWT_GWSUPPORT_ERROR)
1254 {
1255 return 0;
1256 }
1257 dyadup_2D_feed_even_col(input1, m1, n1,
1258 output1, m4, n4);
1259 }
1260 if (strcmp(input_string1,"m")==0)
1261 {
1262 m4 = m1 * 2 + 1;
1263 n4 = n1 * 2 + 1;
1264 //CreateVar (4, "d", &m4, &n4, &l4);
1265 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1266 if(readFlag==SWT_GWSUPPORT_ERROR)
1267 {
1268 return 0;
1269 }
1270 dyadup_2D_feed_even(input1, m1, n1,
1271 output1, m4, n4);
1272 }
1273 }
1274 //LhsVar (1) = 4;
1275 break;
1276 }
1277 default:
1278 break;
1279 }
1280 return 0;
1281 }
1282
1283 /*-------------------------------------------
1284 * wkeep
1285 *-----------------------------------------*/
1286
1287 int
int_wkeep(char * fname,void * pvApiCtx)1288 int_wkeep
1289 #ifdef _SCILAB6_
1290 (char *fname, void* pvApiCtx)
1291 #else
1292 (char *fname)
1293 #endif
1294 {
1295 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, l4, m4, n4;
1296 static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 3;
1297 int flow, errCode;//, row1, row2, col1, col2;
1298 int readFlag;
1299 double *input1=NULL;
1300 int *int_input2=NULL;
1301 int *int_input3=NULL;
1302 char * input_string1 = NULL;
1303 double *output1;
1304 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
1305 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
1306
1307 flow = 0;
1308 wkeep_form_validate (pvApiCtx, &flow, &errCode, Rhs);
1309 if (errCode != SUCCESS)
1310 {
1311 validate_print (errCode);
1312 return 0;
1313 }
1314 l1 = 0;
1315 l2 = 0;
1316 l3 = 0;
1317 switch (flow){
1318 case 1:
1319 {
1320 //GetRhsVar (1, "d", &m1, &n1, &l1);
1321 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1322 if(readFlag==SWT_GWSUPPORT_ERROR)
1323 {
1324 return 0;
1325 }
1326 //GetRhsVar (2, "i", &m2, &n2, &l2);
1327 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1328 if(readFlag==SWT_GWSUPPORT_ERROR)
1329 {
1330 return 0;
1331 }
1332 wkeep_content_validate (pvApiCtx, flow, &errCode, input1, int_input2, NULL);
1333 if (errCode != SUCCESS)
1334 {
1335 validate_print (errCode);
1336 return 0;
1337 }
1338 if (n1 > 1)
1339 {
1340 m3 = 1;
1341 n3 = int_input2[0];
1342 }
1343 else
1344 {
1345 m3 = int_input2[0];
1346 n3 = 1;
1347 }
1348 //CreateVar (3, "d", &m3, &n3, &l3);
1349 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
1350 if(readFlag==SWT_GWSUPPORT_ERROR)
1351 {
1352 return 0;
1353 }
1354 wkeep_1D_center(input1, n1 * m1, output1, n3 * m3);
1355 //LhsVar (1) = 3;
1356 break;
1357 }
1358 case 2:
1359 {
1360 //GetRhsVar (1, "d", &m1, &n1, &l1);
1361 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1362 if(readFlag==SWT_GWSUPPORT_ERROR)
1363 {
1364 return 0;
1365 }
1366 //GetRhsVar (2, "i", &m2, &n2, &l2);
1367 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1368 if(readFlag==SWT_GWSUPPORT_ERROR)
1369 {
1370 return 0;
1371 }
1372 wkeep_content_validate (pvApiCtx, flow, &errCode, input1, int_input2, NULL);
1373 if (errCode != SUCCESS)
1374 {
1375 validate_print (errCode);
1376 return 0;
1377 }
1378 m3 = int_input2[0];
1379 n3 = int_input2[1];
1380 //CreateVar (3, "d", &m3, &n3, &l3);
1381 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
1382 if(readFlag==SWT_GWSUPPORT_ERROR)
1383 {
1384 return 0;
1385 }
1386 wkeep_2D_center(input1, m1, n1, output1, m3, n3);
1387 //LhsVar (1) = 3;
1388 break;
1389 }
1390 case 3:
1391 {
1392 //GetRhsVar (1, "d", &m1, &n1, &l1);
1393 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1394 if(readFlag==SWT_GWSUPPORT_ERROR)
1395 {
1396 return 0;
1397 }
1398 //GetRhsVar (2, "i", &m2, &n2, &l2);
1399 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1400 if(readFlag==SWT_GWSUPPORT_ERROR)
1401 {
1402 return 0;
1403 }
1404 //GetRhsVar (3, "c", &m3, &n3, &l3);
1405 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
1406 m3=1;n3=1;
1407 if(readFlag==SWT_GWSUPPORT_ERROR)
1408 {
1409 return 0;
1410 }
1411 wkeep_content_validate_string(pvApiCtx,flow, &errCode, input1, int_input2, input_string1);
1412 if (errCode != SUCCESS)
1413 {
1414 validate_print (errCode);
1415 return 0;
1416 }
1417 if (n1 > 1)
1418 {
1419 m4 = 1;
1420 n4 = int_input2[0];
1421 }
1422 else
1423 {
1424 m4 = int_input2[0];
1425 n4 = 1;
1426 }
1427 //CreateVar (4, "d", &m4, &n4, &l4);
1428 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1429 if(readFlag==SWT_GWSUPPORT_ERROR)
1430 {
1431 return 0;
1432 }
1433 if (((input_string1[0] - 'l') == 0)||((input_string1[0] - 'L') == 0))
1434 wkeep_1D_left(input1, n1 * m1, output1, n4 * m4);
1435 else if (((input_string1[0] - 'c') == 0)||((input_string1[0] - 'C') == 0))
1436 wkeep_1D_center(input1, n1 * m1, output1, n4 * m4);
1437 else if (((input_string1[0] - 'r') == 0)||((input_string1[0] - 'R') == 0))
1438 wkeep_1D_right(input1, n1 * m1, output1, n4 * m4);
1439 LhsVar (1) = 4;
1440 break;
1441 }
1442 case 4:
1443 {
1444 //GetRhsVar (1, "d", &m1, &n1, &l1);
1445 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1446 if(readFlag==SWT_GWSUPPORT_ERROR)
1447 {
1448 return 0;
1449 }
1450 //GetRhsVar (2, "i", &m2, &n2, &l2);
1451 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1452 if(readFlag==SWT_GWSUPPORT_ERROR)
1453 {
1454 return 0;
1455 }
1456 //GetRhsVar (3, "i", &m3, &n3, &l3);
1457 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 3, &m3, &n3, &int_input3);
1458 if(readFlag==SWT_GWSUPPORT_ERROR)
1459 {
1460 return 0;
1461 }
1462 wkeep_content_validate (pvApiCtx, flow, &errCode, input1, int_input2, int_input3);
1463 if (errCode != SUCCESS)
1464 {
1465 validate_print (errCode);
1466 return 0;
1467 }
1468 if (n1 > 1)
1469 {
1470 m4 = 1;
1471 n4 = int_input2[0];
1472 }
1473 else
1474 {
1475 m4 = int_input2[0];
1476 n4 = 1;
1477 }
1478 //CreateVar (4, "d", &m4, &n4, &l4);
1479 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1480 if(readFlag==SWT_GWSUPPORT_ERROR)
1481 {
1482 return 0;
1483 }
1484 wkeep_1D_index(input1,n1 * m1,output1,n4 * m4,int_input3[0]);
1485 //LhsVar (1) = 4;
1486 break;
1487 }
1488 case 5:
1489 {
1490 //GetRhsVar (1, "d", &m1, &n1, &l1);
1491 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
1492 if(readFlag==SWT_GWSUPPORT_ERROR)
1493 {
1494 return 0;
1495 }
1496 //GetRhsVar (2, "i", &m2, &n2, &l2);
1497 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
1498 if(readFlag==SWT_GWSUPPORT_ERROR)
1499 {
1500 return 0;
1501 }
1502 //GetRhsVar (3, "i", &m3, &n3, &l3);
1503 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 3, &m3, &n3, &int_input3);
1504 if(readFlag==SWT_GWSUPPORT_ERROR)
1505 {
1506 return 0;
1507 }
1508 wkeep_content_validate (pvApiCtx, flow, &errCode, input1, int_input2, int_input3);
1509 if (errCode != SUCCESS)
1510 {
1511 validate_print (errCode);
1512 return 0;
1513 }
1514 m4 = int_input2[0];
1515 n4 = int_input2[1];
1516 //CreateVar (4, "d", &m4, &n4, &l4);
1517 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
1518 if(readFlag==SWT_GWSUPPORT_ERROR)
1519 {
1520 return 0;
1521 }
1522 wkeep_2D_index(input1, m1, n1, output1,
1523 m4, n4, int_input3[0], int_input3[1]);
1524 // LhsVar (1) = 4;
1525 break;
1526 }
1527 default:
1528 break;
1529 }
1530 return 0;
1531 }
1532
1533 /*-------------------------------------------
1534 * wextend
1535 *-----------------------------------------*/
1536
1537 int
int_wextend(char * fname,void * pvApiCtx)1538 int_wextend
1539 #ifdef _SCILAB6_
1540 (char *fname, void* pvApiCtx)
1541 #else
1542 (char *fname)
1543 #endif
1544 {
1545
1546 static int l1, m1, n1, m2, n2, m3, n3;
1547 static int m4, n4, m5, n5, m6, n6;
1548 static int minlhs = 1, maxlhs = 1, minrhs = 4, maxrhs = 5;
1549 int flow, errCode;// adr, po, row;//col;
1550 char c = 'b';
1551 char cr[2] = "b";
1552 char **_pstStrings = NULL;
1553 int *_piLen=NULL;
1554 int *_piAddress;
1555 extend_method extMethod;
1556 int readFlag;
1557 double *input1;
1558 int *int_input1=NULL;
1559 int *int_input2;
1560 int *int_input3;
1561 double *input3;
1562 int *int_input4;
1563 char * input_string1 = NULL;
1564 char * input_string2 = NULL;
1565 char * input_string5 = NULL;
1566 double *output1;
1567 int i;
1568
1569 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
1570 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
1571
1572 if (swt_gwsupport_GetType(pvApiCtx,1) == sci_matrix){
1573 //GetRhsVar (1, "i", &m1, &n1, &l1);
1574 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 1, &m1, &n1, &int_input1);
1575 if(readFlag==SWT_GWSUPPORT_ERROR)
1576 {
1577 return 0;
1578 }
1579
1580
1581 } else if (swt_gwsupport_GetType(pvApiCtx,1) == sci_strings){
1582 //GetRhsVar (1, "c", &m1, &n1, &l1);
1583 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
1584 m1=1;n1=1;
1585 if(readFlag==SWT_GWSUPPORT_ERROR)
1586 {
1587 return 0;
1588 }
1589
1590
1591 }
1592
1593 flow = 0;
1594 //sciprint("before form validate\n");
1595 wextend_form_validate (pvApiCtx, &flow, &errCode,input_string1,int_input1, Rhs);
1596 //sciprint("flow=%d\n",flow);
1597 if (errCode != SUCCESS)
1598 {
1599 //sciprint("form validate error!\n");
1600 validate_print (errCode);
1601 return 0;
1602 }
1603
1604
1605 switch(flow) {
1606 case 1:
1607 {
1608 //GetRhsVar (2, "c", &m2, &n2, &l2);
1609 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1610 if(readFlag==SWT_GWSUPPORT_ERROR)
1611 {
1612 return 0;
1613 }
1614 //GetRhsVar (3, "d", &m3, &n3, &l3);
1615 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1616 if(readFlag==SWT_GWSUPPORT_ERROR)
1617 {
1618 return 0;
1619 }
1620 //GetRhsVar (4, "i", &m4, &n4, &l4);
1621 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1622 if(readFlag==SWT_GWSUPPORT_ERROR)
1623 {
1624 return 0;
1625 }
1626 //GetRhsVar (5, "c", &m5, &n5, &l5);
1627 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &input_string5 );
1628 if(readFlag==SWT_GWSUPPORT_ERROR)
1629 {
1630 return 0;
1631 }
1632 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, input_string5, NULL);
1633 if (errCode != SUCCESS)
1634 {
1635 validate_print (errCode);
1636 return 0;
1637 }
1638 extend_method_parse (input_string2, &extMethod);
1639 if ((extMethod == PER) && ((m3*n3)%2 != 0))
1640 {
1641 if (((input_string5[0]-'l') == 0) || ((input_string5[0]-'r') == 0))
1642 {
1643 if (m3 > 1)
1644 {
1645 m6 = m3 + int_input4[0] + 1;
1646 n6 = 1;
1647 }
1648 else
1649 {
1650 m6 = 1;
1651 n6 = n3 + int_input4[0] + 1;
1652 }
1653 }
1654 if ((input_string5[0]-'b') == 0)
1655 {
1656 if (m3 > 1)
1657 {
1658 m6 = m3 + 2*int_input4[0] + 1;
1659 n6 = 1;
1660 }
1661 else
1662 {
1663 m6 = 1;
1664 n6 = n3 + 2*int_input4[0] + 1;
1665 }
1666 }
1667 }
1668 else
1669 {
1670 if (((input_string5[0]-'l') == 0) || ((input_string5[0]-'r') == 0))
1671 {
1672 if (m3 > 1)
1673 {
1674 m6 = m3 + int_input4[0];
1675 n6 = 1;
1676 }
1677 else
1678 {
1679 m6 = 1;
1680 n6 = n3 + int_input4[0];
1681 }
1682 }
1683 if ((input_string5[0]-'b') == 0)
1684 {
1685 if (m3 > 1)
1686 {
1687 m6 = m3 + 2*int_input4[0];
1688 n6 = 1;
1689 }
1690 else
1691 {
1692 m6 = 1;
1693 n6 = n3 + 2*int_input4[0];
1694 }
1695 }
1696 }
1697 //CreateVar (6, "d", &m6, &n6, &l6);
1698 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
1699 if(readFlag==SWT_GWSUPPORT_ERROR)
1700 {
1701 return 0;
1702 }
1703 if (strcmp(input_string5,"l") == 0)
1704 wextend_1D_left(input3, m3*n3, output1, m6*n6, extMethod);
1705 else if (strcmp(input_string5,"r") == 0)
1706 wextend_1D_right(input3, m3*n3, output1, m6*n6, extMethod);
1707 else
1708 wextend_1D_center(input3, m3*n3, output1, m6*n6, extMethod);
1709 //LhsVar (1) = 6;
1710 break;
1711 }
1712 case 2:
1713 {
1714 //GetRhsVar (2, "c", &m2, &n2, &l2);
1715 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1716 if(readFlag==SWT_GWSUPPORT_ERROR)
1717 {
1718 return 0;
1719 }
1720 //GetRhsVar (3, "d", &m3, &n3, &l3);
1721 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1722 if(readFlag==SWT_GWSUPPORT_ERROR)
1723 {
1724 return 0;
1725 }
1726 //GetRhsVar (4, "i", &m4, &n4, &l4);
1727 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1728 if(readFlag==SWT_GWSUPPORT_ERROR)
1729 {
1730 return 0;
1731 }
1732 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, NULL, NULL);
1733 if (errCode != SUCCESS)
1734 {
1735 validate_print (errCode);
1736 return 0;
1737 }
1738 extend_method_parse (input_string2, &extMethod);
1739 if ((extMethod == PER) && ((m3*n3)%2 != 0))
1740 {
1741 if (m3 > 1)
1742 {
1743 m5 = m3 + 2*int_input4[0] + 1;
1744 n5 = 1;
1745 }
1746 else
1747 {
1748 m5 = 1;
1749 n5 = n3 + 2*int_input4[0] + 1;
1750 }
1751 }
1752 else
1753 {
1754 if (m3 > 1)
1755 {
1756 m5 = m3 + 2*int_input4[0];
1757 n5 = 1;
1758 }
1759 else
1760 {
1761 m5 = 1;
1762 n5 = n3 + 2*int_input4[0];
1763 }
1764 }
1765 //CreateVar (5, "d", &m5, &n5, &l5);
1766 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1767 if(readFlag==SWT_GWSUPPORT_ERROR)
1768 {
1769 return 0;
1770 }
1771 wextend_1D_center(input3, m3*n3, output1, m5*n5, extMethod);
1772 //LhsVar (1) = 5;
1773 break;
1774 }
1775 case 3:
1776 {
1777 //GetRhsVar (2, "c", &m2, &n2, &l2);
1778 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1779 if(readFlag==SWT_GWSUPPORT_ERROR)
1780 {
1781 return 0;
1782 }
1783 //GetRhsVar (3, "d", &m3, &n3, &l3);
1784 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1785 if(readFlag==SWT_GWSUPPORT_ERROR)
1786 {
1787 return 0;
1788 }
1789 //GetRhsVar (4, "i", &m4, &n4, &l4);
1790 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1791 if(readFlag==SWT_GWSUPPORT_ERROR)
1792 {
1793 return 0;
1794 }
1795 //GetRhsVar (5, "S", &m5, &n5, &str);
1796 //readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 5 , &str );
1797 _pstStrings = swt_gwsupport_GetMatrixOfString(pvApiCtx, fname, 5, &m5 , &n5);
1798 if(_pstStrings==NULL)
1799 {
1800 return 0;
1801 }
1802
1803 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, NULL, _pstStrings);
1804
1805 if (errCode != SUCCESS)
1806 {
1807 validate_print (errCode);
1808 return 0;
1809 }
1810 extend_method_parse (input_string2, &extMethod);
1811 if ((extMethod == PER) && (m3%2 != 0))
1812 {
1813 if (((_pstStrings[0][0]-'l') == 0) || ((_pstStrings[0][0]-'r') == 0))
1814 m6 = m3 + int_input4[0] + 1;
1815 if ((_pstStrings[0][0]-'b') == 0)
1816 m6 = m3 + 2*int_input4[0] + 1;
1817 }
1818 else
1819 {
1820 if (((_pstStrings[0][0]-'l') == 0) || ((_pstStrings[0][0]-'r') == 0))
1821 m6 = m3 + int_input4[0];
1822 if ((_pstStrings[0][0]-'b') == 0)
1823 m6 = m3 + 2*int_input4[0];
1824 }
1825 if ((extMethod == PER) && (n3%2 != 0))
1826 {
1827 if (((_pstStrings[1][0]-'l') == 0) || ((_pstStrings[1][0]-'r') == 0))
1828 n6 = n3 + int_input4[1] + 1;
1829 if ((_pstStrings[1][0]-'b') == 0)
1830 n6 = n3 + 2*int_input4[1] + 1;
1831 }
1832 else
1833 {
1834 if (((_pstStrings[1][0]-'l') == 0) || ((_pstStrings[1][0]-'r') == 0))
1835 n6 = n3 + int_input4[1];
1836 if ((_pstStrings[1][0]-'b') == 0)
1837 n6 = n3 + 2*int_input4[1];
1838 }
1839 //CreateVar (6, "d", &m6, &n6, &l6);
1840 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
1841 if(readFlag==SWT_GWSUPPORT_ERROR)
1842 {
1843 return 0;
1844 }
1845 //wextend_2D (stk(l3), m3, n3, stk(l6), m6, n6,
1846 // extMethod, &str[0][0], &str[1][0]);
1847 wextend_2D (input3, m3, n3, output1, m6, n6,
1848 extMethod, &_pstStrings[1][0], &_pstStrings[0][0]);
1849 //LhsVar (1) = 6;
1850 //FreeRhsSVar(str);
1851 //free memory
1852
1853
1854 for(i = 0 ; i < m5 * n5 ; i++)
1855 {
1856 free(_pstStrings[i]);
1857 }
1858
1859 free(_pstStrings);
1860 break;
1861 }
1862 case 4:
1863 {
1864 //GetRhsVar (2, "c", &m2, &n2, &l2);
1865 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1866 if(readFlag==SWT_GWSUPPORT_ERROR)
1867 {
1868 return 0;
1869 }
1870 //GetRhsVar (3, "d", &m3, &n3, &l3);
1871 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1872 if(readFlag==SWT_GWSUPPORT_ERROR)
1873 {
1874 return 0;
1875 }
1876 //GetRhsVar (4, "i", &m4, &n4, &l4);
1877 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1878 if(readFlag==SWT_GWSUPPORT_ERROR)
1879 {
1880 return 0;
1881 }
1882 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, NULL, NULL);
1883 if (errCode != SUCCESS)
1884 {
1885 validate_print (errCode);
1886 return 0;
1887 }
1888 extend_method_parse (input_string2, &extMethod);
1889 if ((extMethod == PER) && (m3%2 != 0))
1890 m5 = m3 + 2*int_input4[0] + 1;
1891 else
1892 m5 = m3 + 2*int_input4[0];
1893 if ((extMethod == PER) && (n3%2 != 0))
1894 n5 = n3 + 2*int_input4[0] + 1;
1895 else
1896 n5 = n3 + 2*int_input4[0];
1897 //CreateVar (5, "d", &m5, &n5, &l5);
1898 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1899 if(readFlag==SWT_GWSUPPORT_ERROR)
1900 {
1901 return 0;
1902 }
1903 wextend_2D (input3, m3, n3, output1, m5, n5,
1904 extMethod, &c, &c);
1905 //LhsVar (1) = 5;
1906 break;
1907 }
1908 case 5:
1909 {
1910 //GetRhsVar (2, "c", &m2, &n2, &l2);
1911 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1912 if(readFlag==SWT_GWSUPPORT_ERROR)
1913 {
1914 return 0;
1915 }
1916 //GetRhsVar (3, "d", &m3, &n3, &l3);
1917 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1918 if(readFlag==SWT_GWSUPPORT_ERROR)
1919 {
1920 return 0;
1921 }
1922 //GetRhsVar (4, "i", &m4, &n4, &l4);
1923 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1924 if(readFlag==SWT_GWSUPPORT_ERROR)
1925 {
1926 return 0;
1927 }
1928 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, NULL, NULL);
1929 if (errCode != SUCCESS)
1930 {
1931 validate_print (errCode);
1932 return 0;
1933 }
1934 extend_method_parse (input_string2, &extMethod);
1935 if ((extMethod == PER) && (m3%2 != 0))
1936 m5 = m3 + 2*int_input4[0] + 1;
1937 else
1938 m5 = m3 + 2*int_input4[0];
1939 if ((extMethod == PER) && (n3%2 != 0))
1940 n5 = n3 + 2*int_input4[1] + 1;
1941 else
1942 n5 = n3 + 2*int_input4[1];
1943 //CreateVar (5, "d", &m5, &n5, &l5);
1944 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
1945 if(readFlag==SWT_GWSUPPORT_ERROR)
1946 {
1947 return 0;
1948 }
1949 wextend_2D (input3, m3, n3, output1, m5, n5,
1950 extMethod, &c, &c);
1951 //LhsVar (1) = 5;
1952 break;
1953 }
1954 case 6:
1955 {
1956 //GetRhsVar (2, "c", &m2, &n2, &l2);
1957 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
1958 if(readFlag==SWT_GWSUPPORT_ERROR)
1959 {
1960 return 0;
1961 }
1962 //GetRhsVar (3, "d", &m3, &n3, &l3);
1963 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
1964 if(readFlag==SWT_GWSUPPORT_ERROR)
1965 {
1966 return 0;
1967 }
1968 //GetRhsVar (4, "i", &m4, &n4, &l4);
1969 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
1970 if(readFlag==SWT_GWSUPPORT_ERROR)
1971 {
1972 return 0;
1973 }
1974 //GetRhsVar (5, "c", &m5, &n5, &l5);
1975 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,5 , &input_string5 );
1976 if(readFlag==SWT_GWSUPPORT_ERROR)
1977 {
1978 return 0;
1979 }
1980 //sciprint("before wextend content validate!\n");
1981 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, input_string5, NULL);
1982 //sciprint("after wextend content validate!\n");
1983 if (errCode != SUCCESS)
1984 {
1985 validate_print (errCode);
1986 return 0;
1987 }
1988 extend_method_parse (input_string2, &extMethod);
1989 if ((extMethod == PER) && (m3%2 != 0))
1990 {
1991 if ((strcmp(input_string5,"l")==0) || (strcmp(input_string5,"r")==0))
1992 m6 = m3 + int_input4[0] + 1;
1993 if ((strcmp(input_string5,"b") == 0))
1994 m6 = m3 + 2*int_input4[0] + 1;
1995 }
1996 else
1997 {
1998 if ((strcmp(input_string5,"l")==0) || (strcmp(input_string5,"r")==0))
1999 m6 = m3 + int_input4[0];
2000 if ((strcmp(input_string5,"b") == 0))
2001 m6 = m3 + 2*int_input4[0];
2002 }
2003 n6 = n3;
2004 //CreateVar (6, "d", &m6, &n6, &l6);
2005 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2006 if(readFlag==SWT_GWSUPPORT_ERROR)
2007 {
2008 return 0;
2009 }
2010 //sciprint("after creation!flow=6\n");
2011 wextend_2D_row (input3, m3, n3, output1, m6, n6,
2012 extMethod, input_string5);
2013 //LhsVar (1) = 6;
2014 break;
2015 }
2016 case 7:
2017 {
2018 //GetRhsVar (2, "c", &m2, &n2, &l2);
2019 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
2020 if(readFlag==SWT_GWSUPPORT_ERROR)
2021 {
2022 return 0;
2023 }
2024 //GetRhsVar (3, "d", &m3, &n3, &l3);
2025 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
2026 if(readFlag==SWT_GWSUPPORT_ERROR)
2027 {
2028 return 0;
2029 }
2030 //GetRhsVar (4, "i", &m4, &n4, &l4);
2031 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
2032 if(readFlag==SWT_GWSUPPORT_ERROR)
2033 {
2034 return 0;
2035 }
2036 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, input_string5, NULL);
2037 if (errCode != SUCCESS)
2038 {
2039 validate_print (errCode);
2040 return 0;
2041 }
2042 extend_method_parse (input_string2, &extMethod);
2043 if ((extMethod == PER) && (m3%2 != 0))
2044 m5 = m3 + 2*int_input4[0] + 1;
2045 else
2046 m5 = m3 + 2*int_input4[0];
2047 n5 = n3;
2048 //CreateVar (5, "d", &m5, &n5, &l5);
2049 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2050 if(readFlag==SWT_GWSUPPORT_ERROR)
2051 {
2052 return 0;
2053 }
2054 wextend_2D_row (input3, m3, n3, output1, m5, n5,
2055 extMethod, &cr);
2056 //LhsVar (1) = 5;
2057 break;
2058 }
2059 case 8:
2060 {
2061 //GetRhsVar (2, "c", &m2, &n2, &l2);
2062 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
2063 if(readFlag==SWT_GWSUPPORT_ERROR)
2064 {
2065 return 0;
2066 }
2067 //GetRhsVar (3, "d", &m3, &n3, &l3);
2068 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
2069 if(readFlag==SWT_GWSUPPORT_ERROR)
2070 {
2071 return 0;
2072 }
2073 //GetRhsVar (4, "i", &m4, &n4, &l4);
2074 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
2075 if(readFlag==SWT_GWSUPPORT_ERROR)
2076 {
2077 return 0;
2078 }
2079 //GetRhsVar (5, "c", &m5, &n5, &l5);
2080 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,5 , &input_string5 );
2081 if(readFlag==SWT_GWSUPPORT_ERROR)
2082 {
2083 return 0;
2084 }
2085 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, input_string5, NULL);
2086 if (errCode != SUCCESS)
2087 {
2088 validate_print (errCode);
2089 return 0;
2090 }
2091 extend_method_parse (input_string2, &extMethod);
2092 if ((extMethod == PER) && (n3%2 != 0))
2093 {
2094 if ((strcmp(input_string5,"l")==0) || (strcmp(input_string5,"r")==0))
2095 n6 = n3 + int_input4[0] + 1;
2096 if ((strcmp(input_string5,"b") == 0))
2097 n6 = n3 + 2*int_input4[0] + 1;
2098 }
2099 else
2100 {
2101 if ((strcmp(input_string5,"l")==0) || (strcmp(input_string5,"r")==0))
2102 n6 = n3 + int_input4[0];
2103 if ((strcmp(input_string5,"b") == 0))
2104 n6 = n3 + 2*int_input4[0];
2105 }
2106 m6 = m3;
2107 //CreateVar (6, "d", &m6, &n6, &l6);
2108 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2109 if(readFlag==SWT_GWSUPPORT_ERROR)
2110 {
2111 return 0;
2112 }
2113 wextend_2D_col (input3, m3, n3, output1, m6, n6,
2114 extMethod, input_string5);
2115 //LhsVar (1) = 6;
2116 break;
2117 }
2118 case 9:
2119 {
2120 //GetRhsVar (2, "c", &m2, &n2, &l2);
2121 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
2122 if(readFlag==SWT_GWSUPPORT_ERROR)
2123 {
2124 return 0;
2125 }
2126 //GetRhsVar (3, "d", &m3, &n3, &l3);
2127 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
2128 if(readFlag==SWT_GWSUPPORT_ERROR)
2129 {
2130 return 0;
2131 }
2132 //GetRhsVar (4, "i", &m4, &n4, &l4);
2133 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
2134 if(readFlag==SWT_GWSUPPORT_ERROR)
2135 {
2136 return 0;
2137 }
2138 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, NULL, NULL);
2139 if (errCode != SUCCESS)
2140 {
2141 validate_print (errCode);
2142 return 0;
2143 }
2144 extend_method_parse (input_string2, &extMethod);
2145 if ((extMethod == PER) && (n3%2 != 0))
2146 n5 = n3 + 2*int_input4[0] + 1;
2147 else
2148 n5 = n3 + 2*int_input4[0];
2149 m5 = m3;
2150 //CreateVar (5, "d", &m5, &n5, &l5);
2151 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m5 , n5 , &output1 );
2152 if(readFlag==SWT_GWSUPPORT_ERROR)
2153 {
2154 return 0;
2155 }
2156 wextend_2D_col (input3, m3, n3, output1, m5, n5,
2157 extMethod, &cr);
2158 //LhsVar (1) = 5;
2159 break;
2160 }
2161 case 10:
2162 {
2163 //GetRhsVar (2, "c", &m2, &n2, &l2);
2164 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
2165 if(readFlag==SWT_GWSUPPORT_ERROR)
2166 {
2167 return 0;
2168 }
2169 //GetRhsVar (3, "d", &m3, &n3, &l3);
2170 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
2171 if(readFlag==SWT_GWSUPPORT_ERROR)
2172 {
2173 return 0;
2174 }
2175 //GetRhsVar (4, "i", &m4, &n4, &l4);
2176 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
2177 if(readFlag==SWT_GWSUPPORT_ERROR)
2178 {
2179 return 0;
2180 }
2181 //GetRhsVar (5, "c", &m5, &n5, &l5);
2182 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,5 , &input_string5 );
2183 if(readFlag==SWT_GWSUPPORT_ERROR)
2184 {
2185 return 0;
2186 }
2187 wextend_content_validate (pvApiCtx, flow, &errCode, input_string2, input3, int_input4, input_string5, NULL);
2188 if (errCode != SUCCESS)
2189 {
2190 validate_print (errCode);
2191 return 0;
2192 }
2193 extend_method_parse (input_string2, &extMethod);
2194 if ((extMethod == PER) && (m3%2 != 0))
2195 {
2196 if ((input_string5[0]=='l') || (input_string5[0]=='r'))
2197 m6 = m3 + int_input4[0] + 1;
2198 if (input_string5[0]=='b')
2199 m6 = m3 + 2*int_input4[0] + 1;
2200 }
2201 else
2202 {
2203 if ((input_string5[0]=='l') || (input_string5[0]=='r'))
2204 m6 = m3 + int_input4[0];
2205 if (input_string5[0]=='b')
2206 m6 = m3 + 2*int_input4[0];
2207 }
2208 if ((extMethod == PER) && (n3%2 != 0))
2209 {
2210 if ((input_string5[1]=='l') || (input_string5[1]=='r'))
2211 n6 = n3 + int_input4[1] + 1;
2212 if (input_string5[1]=='b')
2213 n6 = n3 + 2*int_input4[1] + 1;
2214 }
2215 else
2216 {
2217 if ((input_string5[1]=='l') || (input_string5[1]=='r'))
2218 n6 = n3 + int_input4[1];
2219 if (input_string5[1]=='b')
2220 n6 = n3 + 2*int_input4[1];
2221 }
2222
2223
2224 //CreateVar (6, "d", &m6, &n6, &l6);
2225 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m6 , n6 , &output1 );
2226 if(readFlag==SWT_GWSUPPORT_ERROR)
2227 {
2228 return 0;
2229 }
2230 wextend_2D (input3, m3, n3, output1, m6, n6,
2231 extMethod, &input_string5[1], &input_string5[0]);
2232 //wextend_2D (input3, m3, n3, stk(l6), m6, n6,
2233 // extMethod, &input_string5[0], &input_string5[1]);
2234 //LhsVar (1) = 6;
2235 break;
2236 }
2237 default:
2238 break;
2239 }
2240 //sciprint("flow=%d\n",flow);
2241 return 0;
2242 }
2243
2244 /*-------------------------------------------
2245 * wcodemat
2246 *-----------------------------------------*/
int_wcodemat(char * fname,void * pvApiCtx)2247 int int_wcodemat
2248 #ifdef _SCILAB6_
2249 (char *fname, void* pvApiCtx)
2250 #else
2251 (char *fname)
2252 #endif
2253 {
2254 static int m1, n1, m2, n2, m3, n3;
2255 static int m4, n4, m5, n5;
2256 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 4;
2257 int errCode, flow, op, zero, typ, mn, inc;
2258 double *var;
2259 int readFlag;
2260 double *input1;
2261 int *int_input2;
2262 int *int_input4;
2263 char * input_string1 = NULL;
2264 double *output1;
2265 //int *int_output1;
2266 //int *int_output1;
2267 unsigned short *int_output1;
2268 /* Input Validation */
2269 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
2270 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
2271
2272 wcodemat_form_validate (pvApiCtx, &flow, &errCode, Rhs);
2273 if (errCode != SUCCESS)
2274 {
2275 validate_print (errCode);
2276 return 0;
2277 }
2278
2279 typ = 12; //I_UINT16;;
2280 zero = 0;
2281 inc = 1;
2282
2283 switch (flow){
2284 case 1:
2285 {
2286 //GetRhsVar (1, "d", &m1, &n1, &l1);
2287 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
2288 if(readFlag==SWT_GWSUPPORT_ERROR)
2289 {
2290 return 0;
2291 }
2292 wcodemat_content_validate (pvApiCtx, &errCode, flow, int_input2);
2293 if (errCode != SUCCESS)
2294 {
2295 validate_print (errCode);
2296 return 0;
2297 }
2298 m2 = m1;
2299 n2 = n1;
2300 var=malloc(m2*n2*sizeof(double));
2301 typ = 12; //I_UINT16;;
2302 //CreateVar (2, "I", &m2, &n2, &l2);
2303
2304 //readFlag = swt_gwsupport_AllocMatrixOfInteger32(pvApiCtx, fname, 1, m2 , n2 , &int_output1 );
2305 readFlag = swt_gwsupport_AllocMatrixOfUnsignedInteger16(pvApiCtx, fname, 1, m2 , n2 , &int_output1 );
2306 if(readFlag==SWT_GWSUPPORT_ERROR)
2307 {
2308 return 0;
2309 }
2310
2311 wcodemat_matrix (input1, m1, n1, var, m2, n2, 1, 64, 1);
2312 mn = m2*n2;
2313 C2F(tpconv)(&zero,&typ,&mn,var, &inc,int_output1, &inc);
2314 free(var);
2315 //AssignOutputVariable(pvApiCtx,1) = 2;
2316 break;
2317 }
2318 case 2:
2319 {
2320 //GetRhsVar (1, "d", &m1, &n1, &l1);
2321 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
2322 if(readFlag==SWT_GWSUPPORT_ERROR)
2323 {
2324 return 0;
2325 }
2326 //GetRhsVar (2, "i", &m2, &n2, &l2);
2327 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
2328 if(readFlag==SWT_GWSUPPORT_ERROR)
2329 {
2330 return 0;
2331 }
2332 wcodemat_content_validate (pvApiCtx, &errCode, flow, int_input2);
2333 if (errCode != SUCCESS)
2334 {
2335 validate_print (errCode);
2336 return 0;
2337 }
2338 m3 = m1;
2339 n3 = n1;
2340 typ = 12; //I_UINT16;;
2341 //CreateVar (3, "I", &m3, &n3, &l3);
2342 //readFlag = swt_gwsupport_AllocMatrixOfInteger32(pvApiCtx, fname, 1, m3 , n3 , &int_output1 );
2343 readFlag = swt_gwsupport_AllocMatrixOfUnsignedInteger16(pvApiCtx, fname, 1, m3 , n3 , &int_output1 );
2344
2345 if(readFlag==SWT_GWSUPPORT_ERROR)
2346 {
2347 return 0;
2348 }
2349 var = malloc(m3*n3*sizeof(double));
2350 wcodemat_matrix (input1, m1, n1, var, m3, n3, 1, int_input2[0], 1);
2351 mn = m3*n3;
2352 C2F(tpconv)(&zero,&typ,&mn,var, &inc,int_output1, &inc);
2353 free(var);
2354 //AssignOutputVariable(pvApiCtx,1) = 3;
2355 break;
2356 }
2357 case 3:
2358 {
2359 //GetRhsVar (1, "d", &m1, &n1, &l1);
2360 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
2361 if(readFlag==SWT_GWSUPPORT_ERROR)
2362 {
2363 return 0;
2364 }
2365 //GetRhsVar (2, "i", &m2, &n2, &l2);
2366 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
2367 if(readFlag==SWT_GWSUPPORT_ERROR)
2368 {
2369 return 0;
2370 }
2371 //GetRhsVar (3, "c", &m3, &n3, &l3);
2372 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
2373 m3=1;n3=1;
2374 if(readFlag==SWT_GWSUPPORT_ERROR)
2375 {
2376 return 0;
2377 }
2378 wcodemat_content_validate (pvApiCtx, &errCode, flow, int_input2);
2379 if (errCode != SUCCESS)
2380 {
2381 validate_print (errCode);
2382 return 0;
2383 }
2384 if ((!strcmp(input_string1,"r")) || (!strcmp(input_string1,"row"))||
2385 (!strcmp(input_string1,"c")) || (!strcmp(input_string1,"col"))||
2386 (!strcmp(input_string1,"m")) || (!strcmp(input_string1,"mat")))
2387 {
2388
2389 m4 = m1;
2390 n4 = n1;
2391 var=malloc(m4*n4*sizeof(double));
2392 typ = 12; //I_UINT16;;
2393 //CreateVar (4, "I", &m4, &n4, &l4);
2394 //readFlag = swt_gwsupport_AllocMatrixOfInteger32(pvApiCtx, fname, 1, m4 , n4 , &int_output1 );
2395 readFlag = swt_gwsupport_AllocMatrixOfUnsignedInteger16(pvApiCtx, fname, 1, m4 , n4 , &int_output1 );
2396 if(readFlag==SWT_GWSUPPORT_ERROR)
2397 {
2398 return 0;
2399 }
2400 if ((!strcmp(input_string1,"c")) || (!strcmp(input_string1,"col")))
2401 wcodemat_matrix_col (input1, m1, n1, var, m4, n4, 1, int_input2[0], 1);
2402 else if ((!strcmp(input_string1,"r")) || (!strcmp(input_string1,"row")))
2403 wcodemat_matrix_row (input1, m1, n1, var, m4, n4, 1, int_input2[0], 1);
2404 else if ((!strcmp(input_string1,"m")) || (!strcmp(input_string1,"mat")))
2405 wcodemat_matrix (input1, m1, n1, var, m4, n4, 1, int_input2[0], 1);
2406 mn = m4*n4;
2407 C2F(tpconv)(&zero,&typ,&mn,var, &inc,int_output1, &inc);
2408 free(var);
2409 // AssignOutputVariable(pvApiCtx,1) = 4;
2410 }
2411 else
2412 {
2413 sciprint("option argument not valid!\n");
2414 return 0;
2415 }
2416 break;
2417 }
2418 case 4:
2419 {
2420 //GetRhsVar (1, "d", &m1, &n1, &l1);
2421 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
2422 if(readFlag==SWT_GWSUPPORT_ERROR)
2423 {
2424 return 0;
2425 }
2426 //GetRhsVar (2, "i", &m2, &n2, &l2);
2427 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
2428 if(readFlag==SWT_GWSUPPORT_ERROR)
2429 {
2430 return 0;
2431 }
2432 //GetRhsVar (3, "c", &m3, &n3, &l3);
2433 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 3 , &input_string1 );
2434 m3=1;n3=1;
2435 if(readFlag==SWT_GWSUPPORT_ERROR)
2436 {
2437 return 0;
2438 }
2439 //GetRhsVar (4, "i", &m4, &n4, &l4);
2440 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 4, &m4, &n4, &int_input4);
2441 if(readFlag==SWT_GWSUPPORT_ERROR)
2442 {
2443 return 0;
2444 }
2445 wcodemat_content_validate (pvApiCtx, &errCode, flow, int_input2);
2446 if (errCode != SUCCESS)
2447 {
2448 validate_print (errCode);
2449 return 0;
2450 }
2451 if ((!strcmp(input_string1,"r")) || (!strcmp(input_string1,"row"))||
2452 (!strcmp(input_string1,"c")) || (!strcmp(input_string1,"col"))||
2453 (!strcmp(input_string1,"m")) || (!strcmp(input_string1,"mat")))
2454 {
2455 m5 = m1;
2456 n5 = n1;
2457 typ = 12; //I_UINT16;
2458 //CreateVar (5, "I", &m5, &n5, &l5);
2459 //readFlag = swt_gwsupport_AllocMatrixOfInteger32(pvApiCtx, fname, 1, m5 , n5 , &int_output1 );
2460 readFlag = swt_gwsupport_AllocMatrixOfUnsignedInteger16(pvApiCtx, fname, 1, m5 , n5 , &int_output1 );
2461 if(readFlag==SWT_GWSUPPORT_ERROR)
2462 {
2463 return 0;
2464 }
2465 if (int_input4[0] !=0)
2466 op = 1;
2467 else
2468 op = 0;
2469 var = malloc(m5*n5*sizeof(double));
2470 if ((!strcmp(input_string1,"c")) || (!strcmp(input_string1,"col")))
2471 wcodemat_matrix_col (input1, m1, n1, var, m5, n5, 1, int_input2[0], op);
2472 else if ((!strcmp(input_string1,"r")) || (!strcmp(input_string1,"row")))
2473 wcodemat_matrix_row (input1, m1, n1, var, m5, n5, 1, int_input2[0], op);
2474 else if ((!strcmp(input_string1,"m")) || (!strcmp(input_string1,"mat")))
2475 wcodemat_matrix (input1, m1, n1, var, m5, n5, 1, int_input2[0], op);
2476 mn = m5*n5;
2477 C2F(tpconv)(&zero,&typ,&mn,var, &inc,int_output1, &inc);
2478 free(var);
2479 //AssignOutputVariable(pvApiCtx,1) = 5;
2480 }
2481 else
2482 {
2483 sciprint("option argument not valid!\n");
2484 return 0;
2485 }
2486 break;
2487 }
2488 default:
2489 break;
2490 }
2491
2492 return 0;
2493 }
2494 //
2495 // int_ind2rgb (char *fname
2496 //#ifdef _SCILAB6_
2497 //, void* pvApiCtx)
2498 //#else
2499 //)
2500 //#endif
2501 // {
2502 // static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
2503 // static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
2504 // int mL, nL, ms, ns, lc2, it, mi, ni, mn, inc, zero, count;
2505 // int si[3];
2506 // static char *Str[]= { "hm","dims","entries"};
2507 // double *var, *temp;
2508 // SciIntMat M;
2509 // int readFlag;
2510 // double *input1;
2511 // int *int_input2;
2512 // int *int_input3;
2513 // char * input_string1 = NULL;
2514 // double *output1;
2515 //
2516 // /* Input Validation */
2517 // CheckInputArgument(pvApiCtx,minrhs, maxrhs);
2518 // CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
2519 //
2520 // if ((GetType(1)!=sci_ints)|| (GetType(2)!=sci_matrix))
2521 // {
2522 // sciprint("Argument 1 should be integer matrix and 2 should be Nx3 double matrix");
2523 // return 0;
2524 // }
2525 // GetRhsVar (1, "I", &m1, &n1, &M);
2526 // mn = m1*n1;
2527 // inc = 1;
2528 // zero = 0;
2529 // //C2F(tpconv)(&M.it,&zero,&mn, M.D, &inc, stk(l1), &inc);
2530 //
2531 // if (M.it==1)
2532 // {
2533 // sciprint("index matrix should be real integer!\n");
2534 // return 0;
2535 // }
2536 //
2537 // GetRhsCVar(2, "d", &it, &m2, &n2, &l2, &lc2);
2538 //
2539 // if (it==1)
2540 // {
2541 // sciprint("colormap should be real matrix!\n");
2542 // return 0;
2543 // }
2544 // if ((n2!=3))
2545 // {
2546 // sciprint("colormap should be Nx3 matrix!\n");
2547 // return 0;
2548 // }
2549 //
2550 // si[0] = m1;
2551 // si[1] = n1;
2552 // si[2] = 3;
2553 // // ssi.m = 1;
2554 // // ssi.n = 3;
2555 // // ssi.l = 100;
2556 // // ssi.it = 4;
2557 // // ssi.D = si;
2558 // var = malloc(m1*n1*3*sizeof(double));
2559 // temp = malloc(m1*n1*sizeof(double));
2560 //
2561 //
2562 // C2F(tpconv)(&M.it,&zero,&mn, M.D, &inc, temp, &inc);
2563 // for(count=0;count<m1*n1;count++)
2564 // {
2565 // if ((int)(temp[count]) < 1)
2566 // {
2567 // var[count] = stk(l2)[0];
2568 // var[count+m1*n1] = stk(l2)[m2];
2569 // var[count+2*m1*n1] = stk(l2)[2*m2];
2570 // }
2571 // if ((int)(temp[count]) < m2)
2572 // {
2573 // var[count]=stk(l2)[(int)(temp[count])-1];
2574 // var[count+m1*n1]=stk(l2)[(int)(temp[count])+m2-1];
2575 // var[count+m1*n1*2]=stk(l2)[(int)(temp[count])+2*m2-1];
2576 // }
2577 // else
2578 // {
2579 // var[count] = stk(l2)[m2-1];
2580 // var[count+m1*n1] = stk(l2)[2*m2-1];
2581 // var[count+2*m1*n1] = stk(l2)[3*m2-1];
2582 // }
2583 // }
2584 // free(temp);
2585 // mi = 1;
2586 // ni = 3;
2587 // ms = 1;
2588 // ns = 3;
2589 // mL = 3;
2590 // nL = 1;
2591 // m3 = m1*n1*3;
2592 // n3 = 1;
2593 // // CreateVar(3, "m", &mL, &nL, &l3);
2594 // // CreateListVarFromPtr(3,1,"S",&ms,&ns,Str);
2595 // // CreateListVarFromPtr(3,2,"I",&mi,&ni,&ssi);
2596 // // CreateListVarFromPtr(3,3,"d",&m3, &n3, &var);
2597 // readFlag = swt_gwsupport_CreateHypermatOfDouble (pvApiCtx, fname, 1, si , 3 , var );
2598 // if(readFlag==SWT_GWSUPPORT_ERROR)
2599 // {
2600 // return 0;
2601 // }
2602 // free(var);
2603 // //AssignOutputVariable(pvApiCtx,1) = 3;
2604 //
2605 // return 0;
2606 // }
2607
2608
2609 int
int_mat3Dtran(char * fname,void * pvApiCtx)2610 int_mat3Dtran
2611 #ifdef _SCILAB6_
2612 (char *fname, void* pvApiCtx)
2613 #else
2614 (char *fname)
2615 #endif
2616 {
2617 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, mL2, nL2, s4;
2618 static int it3, mL3, nL3, lL3, lcL3, mL1, nL1, s3, l4, m4, n4;
2619 static int minlhs = 1, maxlhs = 1, minrhs = 3, maxrhs = 3;
2620 char **Str2;
2621 static char *Str[]= { "hm","dims","entries"};
2622 int mL=3, nL=1, ms=1, ns=3, mi=1, ni=3;
2623 int r, c, s, zero, inc, mn, row, col, sli, r2;
2624 //SciIntMat M;
2625 int si[3];
2626 double *temp, *var3, *var2;
2627 int errCode;
2628 int readFlag;
2629 double *input1;
2630 int *int_input2;
2631 int *int_input3;
2632 char * input_string1 = NULL;
2633 double *output1;
2634 int ndims1;
2635 int *dims1;
2636 /* Input Validation */
2637 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
2638 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
2639 /* Get Input */
2640 // GetRhsVar(1,"m",&m1,&n1,&l1);
2641 // CheckLength(1,m1,3);
2642 // GetListRhsVar(1,1,"S",&mL1,&nL1,&Str2);
2643 //
2644 // if ( strcmp(Str2[0],"hm") != 0)
2645 // {
2646 // Scierror(999,"Argument %d is not an hypermatrix\r\n",1);
2647 // return 0;
2648 // }
2649 // FreeRhsSVar(Str2);
2650 // GetListRhsVar(1,2,"I",&mL2,&nL2,&M);
2651 // GetListRhsCVar(1,3,"d",&it3,&mL3,&nL3,&lL3,&lcL3);
2652 readFlag = swt_gwsupport_GetRealHypermatofdouble (pvApiCtx, fname, 1, &dims1 , &ndims1 , &input1 );
2653 if(readFlag==SWT_GWSUPPORT_ERROR)
2654 {
2655 return 0;
2656 }
2657 if ((ndims1 != 3))
2658 {
2659 Scierror(999,"Argument %d dimension error\r\n",1);
2660 return 0;
2661 }
2662
2663 //GetRhsVar (2, "i", &m2, &n2, &l2);
2664 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
2665 if(readFlag==SWT_GWSUPPORT_ERROR)
2666 {
2667 return 0;
2668 }
2669 if ((int_input2[0] != 1) && (int_input2[0] != 2) && (int_input2[0] != 3) &&
2670 (int_input2[0] != 4) && (int_input2[0] != 5) && (int_input2[0] != 0))
2671 {
2672 sciprint("the second argument should be integer from 1 to 6!\n");
2673 return 0;
2674 }
2675
2676 //GetRhsVar (3, "i", &m3, &n3, &l3);
2677 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &int_input3);
2678 if(readFlag==SWT_GWSUPPORT_ERROR)
2679 {
2680 return 0;
2681 }
2682 if ((int_input3[0] != 0) && (int_input3[0] != 1) )
2683 {
2684 sciprint("the second argument should be integer 1 or 0!\n");
2685 return 0;
2686 }
2687
2688 // if (it3 == 1)
2689 // {
2690 // Scierror(999,"Argument %d should be real hypermatrix\r\n",1);
2691 // return 0;
2692 // }
2693 // if ((mL2 != 1) || (nL2 != 3))
2694 // {
2695 // Scierror(999,"Argument %d dimension error\r\n",1);
2696 // return 0;
2697 // }
2698
2699 // mn = mL2*nL2;
2700 // inc = 1;
2701 // zero = 0;
2702 //
2703 // temp = malloc(m1*n1*sizeof(double));
2704 // C2F(tpconv)(&M.it,&zero,&mn, M.D, &inc, temp, &inc);
2705 // row = (int)temp[0];
2706 // col = (int)temp[1];
2707 // sli = (int)temp[2];
2708 row = dims1[0];
2709 col = dims1[1];
2710 sli = dims1[2];
2711 if (int_input3[0]==0)
2712 {
2713 switch (int_input2[0])
2714 {
2715 case 0:
2716 {
2717 m4 = (int)dims1[0];
2718 n4 = (int)dims1[1];
2719 s4 = (int)dims1[2];
2720 break;
2721 }
2722 case 1:
2723 {
2724 m4 = (int)dims1[1];
2725 n4 = (int)dims1[0];
2726 s4 = (int)dims1[2];
2727 break;
2728 }
2729 case 2:
2730 {
2731 m4 = (int)dims1[0];
2732 n4 = (int)dims1[2];
2733 s4 = (int)dims1[1];
2734 break;
2735 }
2736 case 3:
2737 {
2738 m4 = (int)dims1[2];
2739 n4 = (int)dims1[0];
2740 s4 = (int)dims1[1];
2741 break;
2742 }
2743 case 4:
2744 {
2745 m4 = (int)dims1[1];
2746 n4 = (int)dims1[2];
2747 s4 = (int)dims1[0];
2748 break;
2749 }
2750 case 5:
2751 {
2752 m4 = (int)dims1[2];
2753 n4 = (int)dims1[1];
2754 s4 = (int)dims1[0];
2755 break;
2756 }
2757 default:break;
2758 }
2759 }
2760 else
2761 {
2762
2763 switch (int_input2[0])
2764 {
2765 case 0:
2766 {
2767 m4 = (int)dims1[0];
2768 n4 = (int)dims1[1];
2769 s4 = (int)dims1[2];
2770 break;
2771 }
2772 case 1:
2773 {
2774 m4 = (int)dims1[1];
2775 n4 = (int)dims1[0];
2776 s4 = (int)dims1[2];
2777 break;
2778 }
2779 case 2:
2780 {
2781 m4 = (int)dims1[0];
2782 n4 = (int)dims1[2];
2783 s4 = (int)dims1[1];
2784 break;
2785 }
2786 case 3:
2787 {
2788 m4 = (int)dims1[1];
2789 n4 = (int)dims1[2];
2790 s4 = (int)dims1[0];
2791 break;
2792 }
2793 case 4:
2794 {
2795 m4 = (int)dims1[2];
2796 n4 = (int)dims1[0];
2797 s4 = (int)dims1[1];
2798 break;
2799 }
2800 case 5:
2801 {
2802 m4 = (int)dims1[2];
2803 n4 = (int)dims1[1];
2804 s4 = (int)dims1[0];
2805 break;
2806 }
2807 default:break;
2808 }
2809 }
2810
2811 si[0] = m4;
2812 si[1] = n4;
2813 si[2] = s4;
2814 //si[3] = 8;
2815 // ssi.m = 1;
2816 // ssi.n = 3;
2817 // ssi.it = 4;
2818 // ssi.l = 100;
2819 // ssi.D = si;
2820 m4 = m4*n4*s4;
2821 n4 = 1;
2822 var3 = malloc(m4*n4*sizeof(double));
2823
2824 if (int_input3[0]==0)
2825 {
2826 switch (int_input2[0])
2827 {
2828 case 0:
2829 {
2830 verbatim_copy (input1, row*col*sli, var3, row*col*sli);
2831 break;
2832 }
2833 case 1:
2834 {
2835 dwt3d_tran(input1, col, row, sli, var3, row, col, sli);
2836 break;
2837 }
2838 case 2:
2839 {
2840 var2 = malloc(m4*n4*sizeof(double));
2841 dwt3d_tran_z(input1, col, row, sli, var2, row, sli, col);
2842 dwt3d_tran(var2, row, sli, col, var3, sli, row, col);
2843 free(var2);
2844 break;
2845 }
2846 case 3:
2847 {
2848 dwt3d_tran_z(input1, col, row, sli, var3, row, sli, col);
2849 break;
2850 }
2851 case 4:
2852 {
2853 var2 = malloc(m4*n4*sizeof(double));
2854 dwt3d_tran(input1, col, row, sli, var3, row, col, sli);
2855 dwt3d_tran_z(var3, row, col, sli, var2, col, sli, row);
2856 dwt3d_tran(var2, col, sli, row, var3, sli, col, row);
2857 free(var2);
2858 break;
2859 }
2860 case 5:
2861 {
2862 var2 = malloc(m4*n4*sizeof(double));
2863 dwt3d_tran(input1, col, row, sli, var2, row, col, sli);
2864 dwt3d_tran_z(var2, row, col, sli, var3, col, sli, row);
2865 free(var2);
2866 break;
2867 }
2868 default:break;
2869 }
2870 }
2871 else
2872 {
2873 switch (int_input2[0])
2874 {
2875 case 0:
2876 {
2877 verbatim_copy (input1, row*col*sli, var3, row*col*sli);
2878 break;
2879 }
2880 case 1:
2881 {
2882 dwt3d_tran(input1, col, row, sli, var3, row, col, sli);
2883 break;
2884 }
2885 case 2:
2886 {
2887 var2 = malloc(m4*n4*sizeof(double));
2888 dwt3d_tran(input1, col, row, sli, var2, row, col, sli);
2889 dwt3d_tran_z_inv(var2, row, col, sli, var3, row, sli, col);
2890 free(var2);
2891 break;
2892 }
2893 case 3:
2894 {
2895 dwt3d_tran_z_inv(input1, col, row, sli, var3, col, sli, row);
2896 break;
2897 }
2898 case 4:
2899 {
2900 dwt3d_tran_z(input1, col, row, sli, var3, col, sli, row);
2901 break;
2902 }
2903 case 5:
2904 {
2905 var2 = malloc(m4*n4*sizeof(double));
2906 dwt3d_tran(input1, col, row, sli, var2, row, col, sli);
2907 dwt3d_tran_z(var2, row, col, sli, var3, row, sli, col);
2908 free(var2);
2909 break;
2910 }
2911 default:break;
2912 }
2913 }
2914
2915
2916 // CreateVar(4, "m", &mL, &nL, &l4);
2917 // CreateListVarFromPtr(4,1,"S",&ms,&ns,Str);
2918 // CreateListVarFromPtr(4,2,"I",&mi,&ni,&ssi);
2919 // CreateListVarFromPtr(4,3,"d",&m4, &n4, &var3);
2920 readFlag = swt_gwsupport_CreateHypermatOfDouble (pvApiCtx, fname, 1, si , 3 , var3 );
2921 if(readFlag==SWT_GWSUPPORT_ERROR)
2922 {
2923 return 0;
2924 }
2925 free(var3);
2926 //AssignOutputVariable(pvApiCtx,1) = 4;
2927
2928 return 0;
2929 }
2930
2931 int
int_wrev3(char * fname,void * pvApiCtx)2932 int_wrev3
2933 #ifdef _SCILAB6_
2934 (char *fname, void* pvApiCtx)
2935 #else
2936 (char *fname)
2937 #endif
2938 {
2939 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, mL2, nL2, s4;
2940 static int it3, mL3, nL3, lL3, lcL3, mL1, nL1, s3, l4, m4, n4;
2941 static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
2942 char **Str2;
2943 static char *Str[]= { "hm","dims","entries"};
2944 int mL=3, nL=1, ms=1, ns=3, mi=1, ni=3;
2945 int r, c, s, zero, inc, mn, row, col, sli, r2, i;
2946 //SciIntMat M;
2947 int si[3];
2948 double *temp, *var3, *var2;
2949 int errCode;
2950 int readFlag;
2951 double *input1;
2952 int *int_input2;
2953 int *int_input3;
2954 char * input_string1 = NULL;
2955 double *output1;
2956 int *dims1;
2957 int ndims1;
2958 /* Input Validation */
2959 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
2960 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
2961 /* Get Input */
2962 // GetRhsVar(1,"m",&m1,&n1,&l1);
2963 // CheckLength(1,m1,3);
2964 // GetListRhsVar(1,1,"S",&mL1,&nL1,&Str2);
2965 //
2966 // if ( strcmp(Str2[0],"hm") != 0)
2967 // {
2968 // Scierror(999,"Argument %d is not an hypermatrix\r\n",1);
2969 // return 0;
2970 // }
2971 // FreeRhsSVar(Str2);
2972 // GetListRhsVar(1,2,"I",&mL2,&nL2,&M);
2973 // GetListRhsCVar(1,3,"d",&it3,&mL3,&nL3,&lL3,&lcL3);
2974 readFlag = swt_gwsupport_GetRealHypermatofdouble (pvApiCtx, fname, 1, &dims1 , &ndims1 , &input1 );
2975 if(readFlag==SWT_GWSUPPORT_ERROR)
2976 {
2977 return 0;
2978 }
2979 if ((ndims1 != 3))
2980 {
2981 Scierror(999,"Argument %d dimension error\r\n",1);
2982 return 0;
2983 }
2984
2985 //GetRhsVar (2, "i", &m2, &n2, &l2);
2986 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
2987 if(readFlag==SWT_GWSUPPORT_ERROR)
2988 {
2989 return 0;
2990 }
2991 if ((int_input2[0] != 1) && (int_input2[0] != 2) && (int_input2[0] != 3) &&
2992 (int_input2[0] != 4) && (int_input2[0] != 5) && (int_input2[0] != 6) && int_input2[0] != 7)
2993 {
2994 sciprint("the second argument should be integer from 1 to 7!\n");
2995 return 0;
2996 }
2997
2998 // if (it3 == 1)
2999 // {
3000 // Scierror(999,"Argument %d should be real hypermatrix\r\n",1);
3001 // return 0;
3002 // }
3003 // if ((mL2 != 1) || (nL2 != 3))
3004 // {
3005 // Scierror(999,"Argument %d dimension error\r\n",1);
3006 // return 0;
3007 // }
3008
3009 // mn = mL2*nL2;
3010 // inc = 1;
3011 // zero = 0;
3012 //
3013 // temp = malloc(m1*n1*sizeof(double));
3014 // C2F(tpconv)(&M.it,&zero,&mn, M.D, &inc, temp, &inc);
3015 // row = (int)temp[0];
3016 // col = (int)temp[1];
3017 // sli = (int)temp[2];
3018 // free(temp);
3019 row = dims1[0];
3020 col = dims1[1];
3021 sli = dims1[2];
3022
3023
3024 m3 = row;
3025 n3 = col;
3026 s3 = sli;
3027
3028 si[0] = m3;
3029 si[1] = n3;
3030 si[2] = s3;
3031
3032 // ssi.m = 1;
3033 // ssi.n = 3;
3034 // ssi.it = 4;
3035 // ssi.l = 100;
3036 // ssi.D = si;
3037 m3 = m3*n3*s3;
3038 n3 = 1;
3039 var3 = malloc(m3*n3*sizeof(double));
3040
3041 switch(int_input2[0])
3042 {
3043 case 1:
3044 {
3045 dwt3d_tran(input1, col, row, sli, var3, row, col, sli);
3046 var2 = malloc(m3*n3*sizeof(double));
3047 for(i=0;i<row*sli;i++)
3048 wrev(var3+i*col,col,var2+i*col,col);
3049 dwt3d_tran(var2, row, col, sli, var3, col, row, sli);
3050 free(var2);
3051 break;
3052 }
3053 case 2:
3054 {
3055 for(i=0;i<col*sli;i++)
3056 wrev(input1+i*row,row,var3+i*row,row);
3057 break;
3058 }
3059 case 3:
3060 {
3061 dwt3d_tran_z(input1, col, row, sli, var3, row, sli, col);
3062 var2 = malloc(m3*n3*sizeof(double));
3063 for(i=0;i<row*col;i++)
3064 wrev(var3+i*sli,sli,var2+i*sli,sli);
3065 dwt3d_tran_z_inv(var2, row, sli, col, var3, col, row, sli);
3066 free(var2);
3067 break;
3068 }
3069 case 4:
3070 {
3071 var2 = malloc(m3*n3*sizeof(double));
3072 dwt3d_tran(input1, col, row, sli, var2, row, col, sli);
3073 for(i=0;i<row*sli;i++)
3074 wrev(var2+i*col,col,var3+i*col,col);
3075 dwt3d_tran(var3, row, col, sli, var2, col, row, sli);
3076 for(i=0;i<col*sli;i++)
3077 wrev(var2+i*row,row,var3+i*row,row);
3078 free(var2);
3079 break;
3080 }
3081 case 5:
3082 {
3083 var2 = malloc(m3*n3*sizeof(double));
3084 dwt3d_tran(input1, col, row, sli, var2, row, col, sli);
3085 for(i=0;i<row*sli;i++)
3086 wrev(var2+i*col,col,var3+i*col,col);
3087 dwt3d_tran(var3, row, col, sli, var2, col, row, sli);
3088 dwt3d_tran_z(var2, col, row, sli, var3, row, sli, col);
3089 for(i=0;i<row*col;i++)
3090 wrev(var3+i*sli,sli,var2+i*sli,sli);
3091 dwt3d_tran_z_inv(var2, row, sli, col, var3, col, row, sli);
3092 free(var2);
3093 break;
3094 }
3095 case 6:
3096 {
3097 var2 = malloc(m3*n3*sizeof(double));
3098 for(i=0;i<col*sli;i++)
3099 wrev(input1+i*row,row,var2+i*row,row);
3100 dwt3d_tran_z(var2, col, row, sli, var3, row, sli, col);
3101 for(i=0;i<row*col;i++)
3102 wrev(var3+i*sli,sli,var2+i*sli,sli);
3103 dwt3d_tran_z_inv(var2, row, sli, col, var3, col, row, sli);
3104 free(var2);
3105 break;
3106 }
3107 case 7:
3108 {
3109 var2 = malloc(m3*n3*sizeof(double));
3110 for(i=0;i<col*sli;i++)
3111 wrev(input1+i*row,row,var3+i*row,row);
3112 dwt3d_tran_z(var3, col, row, sli, var2, row, sli, col);
3113 for(i=0;i<row*col;i++)
3114 wrev(var2+i*sli,sli,var3+i*sli,sli);
3115 dwt3d_tran_z_inv(var3, row, sli, col, var2, col, row, sli);
3116 dwt3d_tran(var2, col, row, sli, var3, row, col, sli);
3117 for(i=0;i<row*sli;i++)
3118 wrev(var3+i*col,col,var2+i*col,col);
3119 dwt3d_tran(var2, row, col, sli, var3, col, row, sli);
3120 free(var2);
3121 break;
3122 }
3123 default:break;
3124 }
3125
3126 // CreateVar(3, "m", &mL, &nL, &l3);
3127 // CreateListVarFromPtr(3,1,"S",&ms,&ns,Str);
3128 // CreateListVarFromPtr(3,2,"I",&mi,&ni,&ssi);
3129 // CreateListVarFromPtr(3,3,"d",&m3, &n3, &var3);
3130 readFlag = swt_gwsupport_CreateHypermatOfDouble (pvApiCtx, fname, 1, si , 3 , var3 );
3131 if(readFlag==SWT_GWSUPPORT_ERROR)
3132 {
3133 return 0;
3134 }
3135 free(var3);
3136 //AssignOutputVariable(pvApiCtx,1) = 3;
3137
3138 return 0;
3139 }
3140
3141 int
int_wrev2(char * fname,void * pvApiCtx)3142 int_wrev2
3143 #ifdef _SCILAB6_
3144 (char *fname, void* pvApiCtx)
3145 #else
3146 (char *fname)
3147 #endif
3148 {
3149 static int m1, n1, m2, n2, m3, n3;
3150 static int minlhs=1, maxlhs=1, minrhs=2, maxrhs=2;
3151 int i, errCode;
3152 double *var;
3153 double *input1;
3154 int *int_input2;
3155 double *output1;
3156 int readFlag;
3157
3158 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
3159 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
3160
3161 wrev2_form_validate (pvApiCtx, &errCode, Rhs);
3162 if (errCode != SUCCESS)
3163 {
3164 validate_print (errCode);
3165 return 0;
3166 }
3167
3168 //GetRhsVar (1, "d", &m1, &n1, &l1);
3169 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
3170 if(readFlag==SWT_GWSUPPORT_ERROR)
3171 {
3172 return 0;
3173 }
3174 //GetRhsVar (2, "i", &m2, &n2, &l2);
3175 readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger(pvApiCtx, fname, 2, &m2, &n2, &int_input2);
3176 if(readFlag==SWT_GWSUPPORT_ERROR)
3177 {
3178 return 0;
3179 }
3180
3181 if ((int_input2[0] != 1) && (int_input2[0] != 2) && (int_input2[0] != 3))
3182 {
3183 sciprint("second argument should be integer from 1 to 3!\n");
3184 return 0;
3185 }
3186
3187
3188 m3 = m1;
3189 n3 = n1;
3190
3191 //CreateVar (3, "d", &m3, &n3, &l3);
3192 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
3193 if(readFlag==SWT_GWSUPPORT_ERROR)
3194 {
3195 return 0;
3196 }
3197
3198 switch(int_input2[0])
3199 {
3200 case 1:
3201 {
3202 var = malloc(m1*n1*sizeof(double));
3203 matrix_tran(input1,n1,m1,output1,m1,n1);
3204 for(i=0;i<m1;i++)
3205 wrev(output1+i*n1,n1,var+i*n1,n1);
3206 matrix_tran(var,m1,n1,output1,n1,m1);
3207 free(var);
3208 break;
3209 }
3210 case 2:
3211 {
3212 for(i=0;i<n1;i++)
3213 wrev(input1+i*m1,m1,output1+i*m1,m1);
3214 break;
3215 }
3216 case 3:
3217 {
3218 var = malloc(m1*n1*sizeof(double));
3219 for(i=0;i<n1;i++)
3220 wrev(input1+i*m1,m1,var+i*m1,m1);
3221 matrix_tran(var,n1,m1,output1,m1,n1);
3222 for(i=0;i<m1;i++)
3223 wrev(output1+i*n1,n1,var+i*n1,n1);
3224 matrix_tran(var,m1,n1,output1,n1,m1);
3225 free(var);
3226 break;
3227 }
3228 default: break;
3229 }
3230
3231 //AssignOutputVariable(pvApiCtx,1) = 3;
3232
3233 return 0;
3234 }
3235
3236 int
int_wnorm(char * fname,void * pvApiCtx)3237 int_wnorm
3238 #ifdef _SCILAB6_
3239 (char *fname, void* pvApiCtx)
3240 #else
3241 (char *fname)
3242 #endif
3243 {
3244 static int l1, m1, n1, l2, m2, n2, l3, m3, n3, l4, m4, n4;
3245 static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 3;
3246 int errCode, flow;
3247 int readFlag;
3248 double *input1;
3249 int *int_input2;
3250 int *int_input3;
3251 double *input2;
3252 double *input3;
3253 char * input_string1 = NULL;
3254 double *output1;
3255 /* Input Validation */
3256 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
3257 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
3258
3259 /* Get Input */
3260 //GetRhsVar (1, "d", &m1, &n1, &l1);
3261 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
3262 if(readFlag==SWT_GWSUPPORT_ERROR)
3263 {
3264 return 0;
3265 }
3266 flow = 1;
3267 wnorm_form_validate (pvApiCtx, &flow, &errCode, Rhs);
3268 if (errCode != SUCCESS)
3269 {
3270 validate_print (errCode); /* Indicate error */
3271 return 0; /* Stop when validation fails */
3272 }
3273
3274 switch (flow){
3275 case 1:
3276 {
3277 m2 = m1;
3278 n2 = n1;
3279 //CreateVar (2, "d", &m2, &n2, &l2);
3280 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
3281 if(readFlag==SWT_GWSUPPORT_ERROR)
3282 {
3283 return 0;
3284 }
3285 wcodematd(input1, m1*n1, output1, m2*n2, 0.0, 1.0);
3286 //AssignOutputVariable(pvApiCtx,1) = 2;
3287 break;
3288 }
3289 case 2:
3290 {
3291 m4 = m1;
3292 n4 = n1;
3293 //GetRhsVar (2, "d", &m2, &n2, &l2);
3294 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 2, &m2, &n2, &input2);
3295 if(readFlag==SWT_GWSUPPORT_ERROR)
3296 {
3297 return 0;
3298 }
3299 //GetRhsVar (3, "d", &m3, &n3, &l3);
3300 readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 3, &m3, &n3, &input3);
3301 if(readFlag==SWT_GWSUPPORT_ERROR)
3302 {
3303 return 0;
3304 }
3305 //CreateVar (4, "d", &m4, &n4, &l4);
3306 readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m4 , n4 , &output1 );
3307 if(readFlag==SWT_GWSUPPORT_ERROR)
3308 {
3309 return 0;
3310 }
3311 if (input2[0] >= input3[0])
3312 {
3313 Scierror(999,"min value must be smaller than max value!\n");
3314 return 0;
3315 }
3316 wcodematd(input1, m1*n1, output1, m4*n4, input2[0], input3[0]);
3317 //AssignOutputVariable(pvApiCtx,1) = 4;
3318 break;
3319 }
3320 default:break;
3321 }
3322
3323 return 0;
3324 }
3325
3326
3327 int
int_waveletfamilies(char * fname,void * pvApiCtx)3328 int_waveletfamilies
3329 #ifdef _SCILAB6_
3330 (char *fname, void* pvApiCtx)
3331 #else
3332 (char *fname)
3333 #endif
3334 {
3335 int l1, m1, n1;
3336 int minlhs = 1, maxlhs = 1, minrhs = 0, maxrhs = 1;
3337 int errCode, flow;
3338 int readFlag;
3339 char * input_string = NULL;
3340 int i,j,count;
3341 /* Input Validation */
3342 CheckInputArgument(pvApiCtx,minrhs, maxrhs);
3343 CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
3344
3345 if (Rhs==0) {
3346 input_string = malloc(2 * sizeof(char));
3347 input_string[0]='f';
3348 // sciprint ("------------------------------------\n");
3349 // sciprint (" HAAR\t\t haar\t ORTH\n");
3350 // sciprint ("DAUBECHIES\t db\t ORTH\n");
3351 // sciprint ("COIFLETS\t coif\t ORTH\n");
3352 // sciprint ("SYMLETS\t\t sym\t ORTH\n");
3353 // sciprint ("SPLINE_BIORTH\t bior\t BIORTH\n");
3354 // sciprint ("SPLINE_RBIORTH\t rbior\t BIORTH\n");
3355 // sciprint ("BEYLKIN\t\t beylkin\t ORTH\n");
3356 // sciprint ("VAIDYANATHAN\t vaidyanathan\t ORTH\n");
3357 // sciprint ("DMEY\t\t dmey\t ORTH\n");
3358 // sciprint ("BATHLETS\t bath\t ORTH\n");
3359 // sciprint ("LEGENDRE\t legd\t ORTH\n");
3360 // sciprint ("FARRAS\t\t fa\t ORTH\n");
3361 // sciprint ("KINGSBURYQ\t ksq\t ORTH\n");
3362 // sciprint ("------------------------------------\n");
3363 // sciprint ("SINUS\t\t sinus\t REAL\n");
3364 // sciprint ("POISSON\t\t poisson\t REAL\n");
3365 // sciprint ("MEXICAN_HAT\t mexh\t REAL\n");
3366 // sciprint ("MORLET\t\t morl\t REAL\n");
3367 // sciprint ("DOGAUSS\t\t DOG\t REAL\n");
3368 // sciprint ("GAUSS\t\t gaus\t REAL\n");
3369 // sciprint ("CMORLET\t\t cmor\t COMPLEX\n");
3370 // sciprint ("SHANNON\t\t shan\t COMPLEX\n");
3371 // sciprint ("FBSP\t\t fbsp\t COMPLEX\n");
3372 // sciprint ("CAUCHY\t\t cauchy\t COMPLEX\n");
3373 // sciprint ("CGAUSS\t\t cgau\t COMPLEX\n");
3374 // sciprint ("------------------------------------\n");
3375
3376 // return 0;
3377
3378 } else {
3379 // GetRhsVar (1, "c", &m1, &n1, &l1);
3380 readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,1 , &input_string );
3381 m1=1;n1=1;
3382 if(readFlag==SWT_GWSUPPORT_ERROR)
3383 {
3384 return 0;
3385 }
3386 }
3387 if (input_string[0]=='n') {
3388
3389 for (j=0;j<waveletFamilyIdentityNum;j++){
3390 count=0;
3391 sciprint (wif[j].family);
3392 sciprint ("\t\t\t");
3393 sciprint (wif[j].wname);
3394
3395 sciprint ("\n------------------------------------\n");
3396 for (i=0;i<waveletIdentityNum;i++) {
3397 if (wi[i].family==j){
3398 sciprint (wi[i].wname);
3399 sciprint (" ");
3400 if (count%5==0 && count>4)
3401 sciprint ("\n");
3402 count=count+1;
3403 }
3404 }
3405 sciprint ("\n------------------------------------\n");
3406 }
3407
3408
3409 for (j=0;j<cwtFamilyNum;j++){
3410 count=0;
3411 sciprint (cif[j].family);
3412 sciprint ("\t\t\t");
3413 sciprint (cif[j].wname);
3414
3415 sciprint ("\n------------------------------------\n");
3416 for (i=0;i<cwtIdentityNum;i++) {
3417 if (ci[i].family==j){
3418 sciprint (ci[i].wname);
3419 sciprint (" ");
3420 if (count%5==0 && count>4)
3421 sciprint ("\n");
3422 count=count+1;
3423 }
3424 }
3425 sciprint ("\n------------------------------------\n");
3426 }
3427 } else if (input_string[0]=='f') {
3428 sciprint ("------------------------------------\n");
3429 sciprint (" HAAR\t\t haar\t ORTH\n");
3430 sciprint ("DAUBECHIES\t db\t ORTH\n");
3431 sciprint ("COIFLETS\t coif\t ORTH\n");
3432 sciprint ("SYMLETS\t\t sym\t ORTH\n");
3433 sciprint ("SPLINE_BIORTH\t bior\t BIORTH\n");
3434 sciprint ("SPLINE_RBIORTH\t rbior\t BIORTH\n");
3435 sciprint ("BEYLKIN\t\t beylkin\t ORTH\n");
3436 sciprint ("VAIDYANATHAN\t vaidyanathan\t ORTH\n");
3437 sciprint ("DMEY\t\t dmey\t ORTH\n");
3438 sciprint ("BATHLETS\t bath\t ORTH\n");
3439 sciprint ("LEGENDRE\t legd\t ORTH\n");
3440 sciprint ("FARRAS\t\t fa\t ORTH\n");
3441 sciprint ("KINGSBURYQ\t ksq\t ORTH\n");
3442 sciprint ("------------------------------------\n");
3443 sciprint ("SINUS\t\t sinus\t REAL\n");
3444 sciprint ("POISSON\t\t poisson\t REAL\n");
3445 sciprint ("MEXICAN_HAT\t mexh\t REAL\n");
3446 sciprint ("MORLET\t\t morl\t REAL\n");
3447 sciprint ("DOGAUSS\t\t DOG\t REAL\n");
3448 sciprint ("GAUSS\t\t gaus\t REAL\n");
3449 sciprint ("CMORLET\t\t cmor\t COMPLEX\n");
3450 sciprint ("SHANNON\t\t shan\t COMPLEX\n");
3451 sciprint ("FBSP\t\t fbsp\t COMPLEX\n");
3452 sciprint ("CAUCHY\t\t cauchy\t COMPLEX\n");
3453 sciprint ("CGAUSS\t\t cgau\t COMPLEX\n");
3454 sciprint ("------------------------------------\n");
3455 }
3456
3457 if (input_string != NULL)
3458 freeAllocatedSingleString(input_string);
3459 return 0;
3460
3461 }
3462