1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2014-2015 - Scilab Enterprises - Calixte DENIZET
4 *
5 * Copyright (C) 2012 - 2016 - Scilab Enterprises
6 *
7 * This file is hereby licensed under the terms of the GNU GPL v2.0,
8 * pursuant to article 5.3.4 of the CeCILL v.2.1.
9 * This file was originally licensed under the terms of the CeCILL v2.1,
10 * and continues to be available under such terms.
11 * For more information, see the COPYING file which you should have received
12 * along with this program.
13 *
14 */
15
16 // This file has been generated, so don't modify it by hand !!
17
18 #include "checkers/Checkers.hxx"
19
20 namespace analysis
21 {
check_matrix(GVN & gvn,const TIType & in0,const TIType & in1)22 TIType Checkers::check_matrix(GVN & gvn, const TIType & in0, const TIType & in1)
23 {
24 switch (in0.type)
25 {
26 case TIType::EMPTY :
27 {
28 if (in1.type == TIType::DOUBLE)
29 {
30 if (in1.rows == 1 && in1.cols == 1)
31 {
32 return in0;
33 }
34 }
35 else
36 {
37 return TIType(gvn);
38 }
39 return TIType(gvn);
40 }
41 case TIType::BOOLEAN :
42 {
43 if (in1.type == TIType::DOUBLE)
44 {
45 if (in1.rows == 1 && in1.cols == 1)
46 {
47 return TIType(gvn, TIType::BOOLEAN, -2, -2);
48 }
49 }
50 else
51 {
52 return TIType(gvn);
53 }
54 return TIType(gvn);
55 }
56 case TIType::COMPLEX :
57 {
58 if (in1.type == TIType::DOUBLE)
59 {
60 if (in1.rows == 1 && in1.cols == 1)
61 {
62 return TIType(gvn, TIType::COMPLEX, -2, -2);
63 }
64 }
65 else
66 {
67 return TIType(gvn);
68 }
69 return TIType(gvn);
70 }
71 case TIType::DOUBLE :
72 {
73 if (in1.type == TIType::DOUBLE)
74 {
75 if (in1.rows == 1 && in1.cols == 1)
76 {
77 return TIType(gvn, TIType::DOUBLE, -2, -2);
78 }
79 }
80 else
81 {
82 return TIType(gvn);
83 }
84 return TIType(gvn);
85 }
86 case TIType::INT16 :
87 {
88 if (in1.type == TIType::DOUBLE)
89 {
90 if (in1.rows == 1 && in1.cols == 1)
91 {
92 return TIType(gvn, TIType::INT16, -2, -2);
93 }
94 }
95 else
96 {
97 return TIType(gvn);
98 }
99 return TIType(gvn);
100 }
101 case TIType::INT32 :
102 {
103 if (in1.type == TIType::DOUBLE)
104 {
105 if (in1.rows == 1 && in1.cols == 1)
106 {
107 return TIType(gvn, TIType::INT32, -2, -2);
108 }
109 }
110 else
111 {
112 return TIType(gvn);
113 }
114 return TIType(gvn);
115 }
116 case TIType::INT64 :
117 {
118 if (in1.type == TIType::DOUBLE)
119 {
120 if (in1.rows == 1 && in1.cols == 1)
121 {
122 return TIType(gvn, TIType::INT64, -2, -2);
123 }
124 }
125 else
126 {
127 return TIType(gvn);
128 }
129 return TIType(gvn);
130 }
131 case TIType::INT8 :
132 {
133 if (in1.type == TIType::DOUBLE)
134 {
135 if (in1.rows == 1 && in1.cols == 1)
136 {
137 return TIType(gvn, TIType::INT8, -2, -2);
138 }
139 }
140 else
141 {
142 return TIType(gvn);
143 }
144 return TIType(gvn);
145 }
146 case TIType::POLYNOMIAL :
147 {
148 if (in1.type == TIType::DOUBLE)
149 {
150 if (in1.rows == 1 && in1.cols == 1)
151 {
152 return TIType(gvn, TIType::POLYNOMIAL, -2, -2);
153 }
154 }
155 else
156 {
157 return TIType(gvn);
158 }
159 return TIType(gvn);
160 }
161 case TIType::STRING :
162 {
163 if (in1.type == TIType::DOUBLE)
164 {
165 if (in1.rows == 1 && in1.cols == 1)
166 {
167 return TIType(gvn, TIType::STRING, -2, -2);
168 }
169 }
170 else
171 {
172 return TIType(gvn);
173 }
174 return TIType(gvn);
175 }
176 case TIType::SPARSE :
177 {
178 if (in1.type == TIType::DOUBLE)
179 {
180 if (in1.rows == 1 && in1.cols == 1)
181 {
182 return TIType(gvn, TIType::SPARSE, -2, -2);
183 }
184 }
185 else
186 {
187 return TIType(gvn);
188 }
189 return TIType(gvn);
190 }
191 case TIType::UINT16 :
192 {
193 if (in1.type == TIType::DOUBLE)
194 {
195 if (in1.rows == 1 && in1.cols == 1)
196 {
197 return TIType(gvn, TIType::UINT16, -2, -2);
198 }
199 }
200 else
201 {
202 return TIType(gvn);
203 }
204 return TIType(gvn);
205 }
206 case TIType::UINT32 :
207 {
208 if (in1.type == TIType::DOUBLE)
209 {
210 if (in1.rows == 1 && in1.cols == 1)
211 {
212 return TIType(gvn, TIType::UINT32, -2, -2);
213 }
214 }
215 else
216 {
217 return TIType(gvn);
218 }
219 return TIType(gvn);
220 }
221 case TIType::UINT64 :
222 {
223 if (in1.type == TIType::DOUBLE)
224 {
225 if (in1.rows == 1 && in1.cols == 1)
226 {
227 return TIType(gvn, TIType::UINT64, -2, -2);
228 }
229 }
230 else
231 {
232 return TIType(gvn);
233 }
234 return TIType(gvn);
235 }
236 case TIType::UINT8 :
237 {
238 if (in1.type == TIType::DOUBLE)
239 {
240 if (in1.rows == 1 && in1.cols == 1)
241 {
242 return TIType(gvn, TIType::UINT8, -2, -2);
243 }
244 }
245 else
246 {
247 return TIType(gvn);
248 }
249 return TIType(gvn);
250 }
251 default :
252 return TIType(gvn);
253 }
254 }
255
check_matrix(GVN & gvn,const TIType & in0,const TIType & in1,const TIType & in2)256 TIType Checkers::check_matrix(GVN & gvn, const TIType & in0, const TIType & in1, const TIType & in2)
257 {
258 switch (in0.type)
259 {
260 case TIType::EMPTY :
261 {
262 if (in1.type == TIType::DOUBLE)
263 {
264 if (in2.type == TIType::DOUBLE)
265 {
266 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
267 {
268 return in0;
269 }
270 }
271 else
272 {
273 return TIType(gvn);
274 }
275 return TIType(gvn);
276 }
277 else
278 {
279 return TIType(gvn);
280 }
281 }
282 case TIType::BOOLEAN :
283 {
284 if (in1.type == TIType::DOUBLE)
285 {
286 if (in2.type == TIType::DOUBLE)
287 {
288 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
289 {
290 return TIType(gvn, TIType::BOOLEAN, -2, -2);
291 }
292 }
293 else
294 {
295 return TIType(gvn);
296 }
297 return TIType(gvn);
298 }
299 else
300 {
301 return TIType(gvn);
302 }
303 }
304 case TIType::COMPLEX :
305 {
306 if (in1.type == TIType::DOUBLE)
307 {
308 if (in2.type == TIType::DOUBLE)
309 {
310 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
311 {
312 return TIType(gvn, TIType::COMPLEX, -2, -2);
313 }
314 }
315 else
316 {
317 return TIType(gvn);
318 }
319 return TIType(gvn);
320 }
321 else
322 {
323 return TIType(gvn);
324 }
325 }
326 case TIType::DOUBLE :
327 {
328 if (in1.type == TIType::DOUBLE)
329 {
330 if (in2.type == TIType::DOUBLE)
331 {
332 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
333 {
334 return TIType(gvn, TIType::DOUBLE, -2, -2);
335 }
336 }
337 else
338 {
339 return TIType(gvn);
340 }
341 return TIType(gvn);
342 }
343 else
344 {
345 return TIType(gvn);
346 }
347 }
348 case TIType::INT16 :
349 {
350 if (in1.type == TIType::DOUBLE)
351 {
352 if (in2.type == TIType::DOUBLE)
353 {
354 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
355 {
356 return TIType(gvn, TIType::INT16, -2, -2);
357 }
358 }
359 else
360 {
361 return TIType(gvn);
362 }
363 return TIType(gvn);
364 }
365 else
366 {
367 return TIType(gvn);
368 }
369 }
370 case TIType::INT32 :
371 {
372 if (in1.type == TIType::DOUBLE)
373 {
374 if (in2.type == TIType::DOUBLE)
375 {
376 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
377 {
378 return TIType(gvn, TIType::INT32, -2, -2);
379 }
380 }
381 else
382 {
383 return TIType(gvn);
384 }
385 return TIType(gvn);
386 }
387 else
388 {
389 return TIType(gvn);
390 }
391 }
392 case TIType::INT64 :
393 {
394 if (in1.type == TIType::DOUBLE)
395 {
396 if (in2.type == TIType::DOUBLE)
397 {
398 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
399 {
400 return TIType(gvn, TIType::INT64, -2, -2);
401 }
402 }
403 else
404 {
405 return TIType(gvn);
406 }
407 return TIType(gvn);
408 }
409 else
410 {
411 return TIType(gvn);
412 }
413 }
414 case TIType::INT8 :
415 {
416 if (in1.type == TIType::DOUBLE)
417 {
418 if (in2.type == TIType::DOUBLE)
419 {
420 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
421 {
422 return TIType(gvn, TIType::INT8, -2, -2);
423 }
424 }
425 else
426 {
427 return TIType(gvn);
428 }
429 return TIType(gvn);
430 }
431 else
432 {
433 return TIType(gvn);
434 }
435 }
436 case TIType::POLYNOMIAL :
437 {
438 if (in1.type == TIType::DOUBLE)
439 {
440 if (in2.type == TIType::DOUBLE)
441 {
442 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
443 {
444 return TIType(gvn, TIType::POLYNOMIAL, -2, -2);
445 }
446 }
447 else
448 {
449 return TIType(gvn);
450 }
451 return TIType(gvn);
452 }
453 else
454 {
455 return TIType(gvn);
456 }
457 }
458 case TIType::STRING :
459 {
460 if (in1.type == TIType::DOUBLE)
461 {
462 if (in2.type == TIType::DOUBLE)
463 {
464 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
465 {
466 return TIType(gvn, TIType::STRING, -2, -2);
467 }
468 }
469 else
470 {
471 return TIType(gvn);
472 }
473 return TIType(gvn);
474 }
475 else
476 {
477 return TIType(gvn);
478 }
479 }
480 case TIType::SPARSE :
481 {
482 if (in1.type == TIType::DOUBLE)
483 {
484 if (in2.type == TIType::DOUBLE)
485 {
486 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
487 {
488 return TIType(gvn, TIType::SPARSE, -2, -2);
489 }
490 }
491 else
492 {
493 return TIType(gvn);
494 }
495 return TIType(gvn);
496 }
497 else
498 {
499 return TIType(gvn);
500 }
501 }
502 case TIType::UINT16 :
503 {
504 if (in1.type == TIType::DOUBLE)
505 {
506 if (in2.type == TIType::DOUBLE)
507 {
508 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
509 {
510 return TIType(gvn, TIType::UINT16, -2, -2);
511 }
512 }
513 else
514 {
515 return TIType(gvn);
516 }
517 return TIType(gvn);
518 }
519 else
520 {
521 return TIType(gvn);
522 }
523 }
524 case TIType::UINT32 :
525 {
526 if (in1.type == TIType::DOUBLE)
527 {
528 if (in2.type == TIType::DOUBLE)
529 {
530 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
531 {
532 return TIType(gvn, TIType::UINT32, -2, -2);
533 }
534 }
535 else
536 {
537 return TIType(gvn);
538 }
539 return TIType(gvn);
540 }
541 else
542 {
543 return TIType(gvn);
544 }
545 }
546 case TIType::UINT64 :
547 {
548 if (in1.type == TIType::DOUBLE)
549 {
550 if (in2.type == TIType::DOUBLE)
551 {
552 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
553 {
554 return TIType(gvn, TIType::UINT64, -2, -2);
555 }
556 }
557 else
558 {
559 return TIType(gvn);
560 }
561 return TIType(gvn);
562 }
563 else
564 {
565 return TIType(gvn);
566 }
567 }
568 case TIType::UINT8 :
569 {
570 if (in1.type == TIType::DOUBLE)
571 {
572 if (in2.type == TIType::DOUBLE)
573 {
574 if (in1.rows == 1 && in1.cols == 1 && in2.rows == 1 && in2.cols == 1)
575 {
576 return TIType(gvn, TIType::UINT8, -2, -2);
577 }
578 }
579 else
580 {
581 return TIType(gvn);
582 }
583 return TIType(gvn);
584 }
585 else
586 {
587 return TIType(gvn);
588 }
589 }
590 default :
591 return TIType(gvn);
592 }
593 }
594
595 } // namespace analysis