types_or fixed with []
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_or.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2012 - Scilab Enterprises - Antoine ELIAS
4  *  Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
5  *
6  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 extern "C"
15 {
16 #include "os_string.h"
17 }
18
19 #include "types_or.hxx"
20 #include "double.hxx"
21 #include "int.hxx"
22 #include "bool.hxx"
23 #include "sparse.hxx"
24
25 using namespace types;
26
27 //define arrays on operation functions
28 static or_function pOrfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
29
30 void fillOrFunction()
31 {
32 #define scilab_fill_or(id1, id2, func, typeIn1, typeIn2, typeOut) \
33     pOrfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (or_function)&or_##func<typeIn1, typeIn2, typeOut>
34
35     //Double
36     scilab_fill_or(Double, Double, M_M, Double, Double, Bool);
37     scilab_fill_or(Double, Bool, M_M, Double, Bool, Bool);
38
39     scilab_fill_or(Double, ScalarDouble, M_S, Double, Double, Bool);
40     scilab_fill_or(Double, ScalarBool, M_S, Double, Bool, Bool);
41
42     scilab_fill_or(Double, Empty, M_E, Double, Double, Double);
43     scilab_fill_or(Double, Identity, M_S, Double, Double, Bool);
44
45     scilab_fill_or(ScalarDouble, Double, S_M, Double, Double, Bool);
46     scilab_fill_or(ScalarDouble, Bool, S_M, Double, Bool, Bool);
47
48     scilab_fill_or(ScalarDouble, ScalarDouble, S_S, Double, Double, Bool);
49     scilab_fill_or(ScalarDouble, ScalarBool, S_S, Double, Bool, Bool);
50
51     scilab_fill_or(ScalarDouble, Empty, M_E, Double, Double, Double);
52     scilab_fill_or(ScalarDouble, Identity, S_S, Double, Double, Bool);
53
54     //Bool
55     scilab_fill_or(Bool, Double, M_M, Bool, Double, Bool);
56     scilab_fill_or(Bool, Bool, M_M, Bool, Bool, Bool);
57
58     scilab_fill_or(Bool, ScalarDouble, M_S, Bool, Double, Bool);
59     scilab_fill_or(Bool, ScalarBool, M_S, Bool, Bool, Bool);
60
61     scilab_fill_or(Bool, Empty, M_E, Bool, Double, Bool);
62     scilab_fill_or(Bool, Identity, M_S, Bool, Double, Bool);
63
64     scilab_fill_or(ScalarBool, Double, S_M, Bool, Double, Bool);
65     scilab_fill_or(ScalarBool, Bool, S_M, Bool, Bool, Bool);
66
67     scilab_fill_or(ScalarBool, ScalarDouble, S_S, Bool, Double, Bool);
68     scilab_fill_or(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
69
70     scilab_fill_or(ScalarBool, Empty, M_E, Bool, Double, Bool);
71     scilab_fill_or(ScalarBool, Identity, S_S, Bool, Double, Bool);
72
73     // []
74     scilab_fill_or(Empty, Double, E_M, Double, Double, Double);
75     scilab_fill_or(Empty, Bool, E_M, Double, Bool, Bool);
76     scilab_fill_or(Empty, ScalarDouble, E_M, Double, Double, Double);
77     scilab_fill_or(Empty, ScalarBool, E_M, Double, Bool, Bool);
78     scilab_fill_or(Empty, Empty, E_M, Double, Double, Double);
79     scilab_fill_or(Empty, Identity, E_M, Double, Double, Double);
80
81     // Identity
82     scilab_fill_or(Identity, Double, I_M, Double, Double, Bool);
83     scilab_fill_or(Identity, Bool, I_M, Double, Bool, Bool);
84
85     scilab_fill_or(Identity, ScalarDouble, I_S, Double, Double, Bool);
86     scilab_fill_or(Identity, ScalarBool, I_S, Double, Bool, Bool);
87
88     scilab_fill_or(Identity, Empty, M_E, Double, Double, Bool);
89     scilab_fill_or(Identity, Identity, I_S, Double, Double, Bool);
90
91
92     //int8
93     scilab_fill_or(Int8, Int8, int_M_M, Int8, Int8, Int8);
94     scilab_fill_or(Int8, UInt8, int_M_M, Int8, UInt8, UInt8);
95     scilab_fill_or(Int8, Int16, int_M_M, Int8, Int16, Int16);
96     scilab_fill_or(Int8, UInt16, int_M_M, Int8, UInt16, UInt16);
97     scilab_fill_or(Int8, Int32, int_M_M, Int8, Int32, Int32);
98     scilab_fill_or(Int8, UInt32, int_M_M, Int8, UInt32, UInt32);
99     scilab_fill_or(Int8, Int64, int_M_M, Int8, Int64, Int64);
100     scilab_fill_or(Int8, UInt64, int_M_M, Int8, UInt64, UInt64);
101
102     scilab_fill_or(Int8, ScalarInt8, int_M_S, Int8, Int8, Int8);
103     scilab_fill_or(Int8, ScalarUInt8, int_M_S, Int8, UInt8, UInt8);
104     scilab_fill_or(Int8, ScalarInt16, int_M_S, Int8, Int16, Int16);
105     scilab_fill_or(Int8, ScalarUInt16, int_M_S, Int8, UInt16, UInt16);
106     scilab_fill_or(Int8, ScalarInt32, int_M_S, Int8, Int32, Int32);
107     scilab_fill_or(Int8, ScalarUInt32, int_M_S, Int8, UInt32, UInt32);
108     scilab_fill_or(Int8, ScalarInt64, int_M_S, Int8, Int64, Int64);
109     scilab_fill_or(Int8, ScalarUInt64, int_M_S, Int8, UInt64, UInt64);
110
111     scilab_fill_or(ScalarInt8, Int8, int_S_M, Int8, Int8, Int8);
112     scilab_fill_or(ScalarInt8, UInt8, int_S_M, Int8, UInt8, UInt8);
113     scilab_fill_or(ScalarInt8, Int16, int_S_M, Int8, Int16, Int16);
114     scilab_fill_or(ScalarInt8, UInt16, int_S_M, Int8, UInt16, UInt16);
115     scilab_fill_or(ScalarInt8, Int32, int_S_M, Int8, Int32, Int32);
116     scilab_fill_or(ScalarInt8, UInt32, int_S_M, Int8, UInt32, UInt32);
117     scilab_fill_or(ScalarInt8, Int64, int_S_M, Int8, Int64, Int64);
118     scilab_fill_or(ScalarInt8, UInt64, int_S_M, Int8, UInt64, UInt64);
119
120     scilab_fill_or(ScalarInt8, ScalarInt8, int_S_S, Int8, Int8, Int8);
121     scilab_fill_or(ScalarInt8, ScalarUInt8, int_S_S, Int8, UInt8, UInt8);
122     scilab_fill_or(ScalarInt8, ScalarInt16, int_S_S, Int8, Int16, Int16);
123     scilab_fill_or(ScalarInt8, ScalarUInt16, int_S_S, Int8, UInt16, UInt16);
124     scilab_fill_or(ScalarInt8, ScalarInt32, int_S_S, Int8, Int32, Int32);
125     scilab_fill_or(ScalarInt8, ScalarUInt32, int_S_S, Int8, UInt32, UInt32);
126     scilab_fill_or(ScalarInt8, ScalarInt64, int_S_S, Int8, Int64, Int64);
127     scilab_fill_or(ScalarInt8, ScalarUInt64, int_S_S, Int8, UInt64, UInt64);
128
129     //uint8
130     scilab_fill_or(UInt8, Int8, int_M_M, UInt8, Int8, UInt8);
131     scilab_fill_or(UInt8, UInt8, int_M_M, UInt8, UInt8, UInt8);
132     scilab_fill_or(UInt8, Int16, int_M_M, UInt8, Int16, UInt16);
133     scilab_fill_or(UInt8, UInt16, int_M_M, UInt8, UInt16, UInt16);
134     scilab_fill_or(UInt8, Int32, int_M_M, UInt8, Int32, UInt32);
135     scilab_fill_or(UInt8, UInt32, int_M_M, UInt8, UInt32, UInt32);
136     scilab_fill_or(UInt8, Int64, int_M_M, UInt8, Int64, UInt64);
137     scilab_fill_or(UInt8, UInt64, int_M_M, UInt8, UInt64, UInt64);
138
139     scilab_fill_or(UInt8, ScalarInt8, int_M_S, UInt8, Int8, UInt8);
140     scilab_fill_or(UInt8, ScalarUInt8, int_M_S, UInt8, UInt8, UInt8);
141     scilab_fill_or(UInt8, ScalarInt16, int_M_S, UInt8, Int16, UInt16);
142     scilab_fill_or(UInt8, ScalarUInt16, int_M_S, UInt8, UInt16, UInt16);
143     scilab_fill_or(UInt8, ScalarInt32, int_M_S, UInt8, Int32, UInt32);
144     scilab_fill_or(UInt8, ScalarUInt32, int_M_S, UInt8, UInt32, UInt32);
145     scilab_fill_or(UInt8, ScalarInt64, int_M_S, UInt8, Int64, UInt64);
146     scilab_fill_or(UInt8, ScalarUInt64, int_M_S, UInt8, UInt64, UInt64);
147
148     scilab_fill_or(ScalarUInt8, Int8, int_S_M, UInt8, Int8, UInt8);
149     scilab_fill_or(ScalarUInt8, UInt8, int_S_M, UInt8, UInt8, UInt8);
150     scilab_fill_or(ScalarUInt8, Int16, int_S_M, UInt8, Int16, UInt16);
151     scilab_fill_or(ScalarUInt8, UInt16, int_S_M, UInt8, UInt16, UInt16);
152     scilab_fill_or(ScalarUInt8, Int32, int_S_M, UInt8, Int32, UInt32);
153     scilab_fill_or(ScalarUInt8, UInt32, int_S_M, UInt8, UInt32, UInt32);
154     scilab_fill_or(ScalarUInt8, Int64, int_S_M, UInt8, Int64, UInt64);
155     scilab_fill_or(ScalarUInt8, UInt64, int_S_M, UInt8, UInt64, UInt64);
156
157     scilab_fill_or(ScalarUInt8, ScalarInt8, int_S_S, UInt8, Int8, UInt8);
158     scilab_fill_or(ScalarUInt8, ScalarUInt8, int_S_S, UInt8, UInt8, UInt8);
159     scilab_fill_or(ScalarUInt8, ScalarInt16, int_S_S, UInt8, Int16, UInt16);
160     scilab_fill_or(ScalarUInt8, ScalarUInt16, int_S_S, UInt8, UInt16, UInt16);
161     scilab_fill_or(ScalarUInt8, ScalarInt32, int_S_S, UInt8, Int32, UInt32);
162     scilab_fill_or(ScalarUInt8, ScalarUInt32, int_S_S, UInt8, UInt32, UInt32);
163     scilab_fill_or(ScalarUInt8, ScalarInt64, int_S_S, UInt8, Int64, UInt64);
164     scilab_fill_or(ScalarUInt8, ScalarUInt64, int_S_S, UInt8, UInt64, UInt64);
165
166     //int16
167     scilab_fill_or(Int16, Int8, int_M_M, Int16, Int8, Int16);
168     scilab_fill_or(Int16, UInt8, int_M_M, Int16, UInt8, UInt16);
169     scilab_fill_or(Int16, Int16, int_M_M, Int16, Int16, Int16);
170     scilab_fill_or(Int16, UInt16, int_M_M, Int16, UInt16, UInt16);
171     scilab_fill_or(Int16, Int32, int_M_M, Int16, Int32, Int32);
172     scilab_fill_or(Int16, UInt32, int_M_M, Int16, UInt32, UInt32);
173     scilab_fill_or(Int16, Int64, int_M_M, Int16, Int64, Int64);
174     scilab_fill_or(Int16, UInt64, int_M_M, Int16, UInt64, UInt64);
175
176     scilab_fill_or(Int16, ScalarInt8, int_M_S, Int16, Int8, Int16);
177     scilab_fill_or(Int16, ScalarUInt8, int_M_S, Int16, UInt8, UInt16);
178     scilab_fill_or(Int16, ScalarInt16, int_M_S, Int16, Int16, Int16);
179     scilab_fill_or(Int16, ScalarUInt16, int_M_S, Int16, UInt16, UInt16);
180     scilab_fill_or(Int16, ScalarInt32, int_M_S, Int16, Int32, Int32);
181     scilab_fill_or(Int16, ScalarUInt32, int_M_S, Int16, UInt32, UInt32);
182     scilab_fill_or(Int16, ScalarInt64, int_M_S, Int16, Int64, Int64);
183     scilab_fill_or(Int16, ScalarUInt64, int_M_S, Int16, UInt64, UInt64);
184
185     scilab_fill_or(ScalarInt16, Int8, int_S_M, Int16, Int8, Int16);
186     scilab_fill_or(ScalarInt16, UInt8, int_S_M, Int16, UInt8, UInt16);
187     scilab_fill_or(ScalarInt16, Int16, int_S_M, Int16, Int16, Int16);
188     scilab_fill_or(ScalarInt16, UInt16, int_S_M, Int16, UInt16, UInt16);
189     scilab_fill_or(ScalarInt16, Int32, int_S_M, Int16, Int32, Int32);
190     scilab_fill_or(ScalarInt16, UInt32, int_S_M, Int16, UInt32, UInt32);
191     scilab_fill_or(ScalarInt16, Int64, int_S_M, Int16, Int64, Int64);
192     scilab_fill_or(ScalarInt16, UInt64, int_S_M, Int16, UInt64, UInt64);
193
194     scilab_fill_or(ScalarInt16, ScalarInt8, int_S_S, Int16, Int8, Int16);
195     scilab_fill_or(ScalarInt16, ScalarUInt8, int_S_S, Int16, UInt8, UInt16);
196     scilab_fill_or(ScalarInt16, ScalarInt16, int_S_S, Int16, Int16, Int16);
197     scilab_fill_or(ScalarInt16, ScalarUInt16, int_S_S, Int16, UInt16, UInt16);
198     scilab_fill_or(ScalarInt16, ScalarInt32, int_S_S, Int16, Int32, Int32);
199     scilab_fill_or(ScalarInt16, ScalarUInt32, int_S_S, Int16, UInt32, UInt32);
200     scilab_fill_or(ScalarInt16, ScalarInt64, int_S_S, Int16, Int64, Int64);
201     scilab_fill_or(ScalarInt16, ScalarUInt64, int_S_S, Int16, UInt64, UInt64);
202
203     //uint16
204     scilab_fill_or(UInt16, Int8, int_M_M, UInt16, Int8, UInt16);
205     scilab_fill_or(UInt16, UInt8, int_M_M, UInt16, UInt8, UInt16);
206     scilab_fill_or(UInt16, Int16, int_M_M, UInt16, Int16, UInt16);
207     scilab_fill_or(UInt16, UInt16, int_M_M, UInt16, UInt16, UInt16);
208     scilab_fill_or(UInt16, Int32, int_M_M, UInt16, Int32, UInt32);
209     scilab_fill_or(UInt16, UInt32, int_M_M, UInt16, UInt32, UInt32);
210     scilab_fill_or(UInt16, Int64, int_M_M, UInt16, Int64, UInt64);
211     scilab_fill_or(UInt16, UInt64, int_M_M, UInt16, UInt64, UInt64);
212
213     scilab_fill_or(UInt16, ScalarInt8, int_M_S, UInt16, Int8, UInt16);
214     scilab_fill_or(UInt16, ScalarUInt8, int_M_S, UInt16, UInt8, UInt16);
215     scilab_fill_or(UInt16, ScalarInt16, int_M_S, UInt16, Int16, UInt16);
216     scilab_fill_or(UInt16, ScalarUInt16, int_M_S, UInt16, UInt16, UInt16);
217     scilab_fill_or(UInt16, ScalarInt32, int_M_S, UInt16, Int32, UInt32);
218     scilab_fill_or(UInt16, ScalarUInt32, int_M_S, UInt16, UInt32, UInt32);
219     scilab_fill_or(UInt16, ScalarInt64, int_M_S, UInt16, Int64, UInt64);
220     scilab_fill_or(UInt16, ScalarUInt64, int_M_S, UInt16, UInt64, UInt64);
221
222     scilab_fill_or(ScalarUInt16, Int8, int_S_M, UInt16, Int8, UInt16);
223     scilab_fill_or(ScalarUInt16, UInt8, int_S_M, UInt16, UInt8, UInt16);
224     scilab_fill_or(ScalarUInt16, Int16, int_S_M, UInt16, Int16, UInt16);
225     scilab_fill_or(ScalarUInt16, UInt16, int_S_M, UInt16, UInt16, UInt16);
226     scilab_fill_or(ScalarUInt16, Int32, int_S_M, UInt16, Int32, UInt32);
227     scilab_fill_or(ScalarUInt16, UInt32, int_S_M, UInt16, UInt32, UInt32);
228     scilab_fill_or(ScalarUInt16, Int64, int_S_M, UInt16, Int64, UInt64);
229     scilab_fill_or(ScalarUInt16, UInt64, int_S_M, UInt16, UInt64, UInt64);
230
231     scilab_fill_or(ScalarUInt16, ScalarInt8, int_S_S, UInt16, Int8, UInt16);
232     scilab_fill_or(ScalarUInt16, ScalarUInt8, int_S_S, UInt16, UInt8, UInt16);
233     scilab_fill_or(ScalarUInt16, ScalarInt16, int_S_S, UInt16, Int16, UInt16);
234     scilab_fill_or(ScalarUInt16, ScalarUInt16, int_S_S, UInt16, UInt16, UInt16);
235     scilab_fill_or(ScalarUInt16, ScalarInt32, int_S_S, UInt16, Int32, UInt32);
236     scilab_fill_or(ScalarUInt16, ScalarUInt32, int_S_S, UInt16, UInt32, UInt32);
237     scilab_fill_or(ScalarUInt16, ScalarInt64, int_S_S, UInt16, Int64, UInt64);
238     scilab_fill_or(ScalarUInt16, ScalarUInt64, int_S_S, UInt16, UInt64, UInt64);
239
240     //int32
241     scilab_fill_or(Int32, Int8, int_M_M, Int32, Int8, Int32);
242     scilab_fill_or(Int32, UInt8, int_M_M, Int32, UInt8, UInt32);
243     scilab_fill_or(Int32, Int16, int_M_M, Int32, Int16, Int32);
244     scilab_fill_or(Int32, UInt16, int_M_M, Int32, UInt16, UInt32);
245     scilab_fill_or(Int32, Int32, int_M_M, Int32, Int32, Int32);
246     scilab_fill_or(Int32, UInt32, int_M_M, Int32, UInt32, UInt32);
247     scilab_fill_or(Int32, Int64, int_M_M, Int32, Int64, Int64);
248     scilab_fill_or(Int32, UInt64, int_M_M, Int32, UInt64, UInt64);
249
250     scilab_fill_or(Int32, ScalarInt8, int_M_S, Int32, Int8, Int32);
251     scilab_fill_or(Int32, ScalarUInt8, int_M_S, Int32, UInt8, UInt32);
252     scilab_fill_or(Int32, ScalarInt16, int_M_S, Int32, Int16, Int32);
253     scilab_fill_or(Int32, ScalarUInt16, int_M_S, Int32, UInt16, UInt32);
254     scilab_fill_or(Int32, ScalarInt32, int_M_S, Int32, Int32, Int32);
255     scilab_fill_or(Int32, ScalarUInt32, int_M_S, Int32, UInt32, UInt32);
256     scilab_fill_or(Int32, ScalarInt64, int_M_S, Int32, Int64, Int64);
257     scilab_fill_or(Int32, ScalarUInt64, int_M_S, Int32, UInt64, UInt64);
258
259     scilab_fill_or(ScalarInt32, Int8, int_S_M, Int32, Int8, Int32);
260     scilab_fill_or(ScalarInt32, UInt8, int_S_M, Int32, UInt8, UInt32);
261     scilab_fill_or(ScalarInt32, Int16, int_S_M, Int32, Int16, Int32);
262     scilab_fill_or(ScalarInt32, UInt16, int_S_M, Int32, UInt16, UInt32);
263     scilab_fill_or(ScalarInt32, Int32, int_S_M, Int32, Int32, Int32);
264     scilab_fill_or(ScalarInt32, UInt32, int_S_M, Int32, UInt32, UInt32);
265     scilab_fill_or(ScalarInt32, Int64, int_S_M, Int32, Int64, Int64);
266     scilab_fill_or(ScalarInt32, UInt64, int_S_M, Int32, UInt64, UInt64);
267
268     scilab_fill_or(ScalarInt32, ScalarInt8, int_S_S, Int32, Int8, Int32);
269     scilab_fill_or(ScalarInt32, ScalarUInt8, int_S_S, Int32, UInt8, UInt32);
270     scilab_fill_or(ScalarInt32, ScalarInt16, int_S_S, Int32, Int16, Int32);
271     scilab_fill_or(ScalarInt32, ScalarUInt16, int_S_S, Int32, UInt16, UInt32);
272     scilab_fill_or(ScalarInt32, ScalarInt32, int_S_S, Int32, Int32, Int32);
273     scilab_fill_or(ScalarInt32, ScalarUInt32, int_S_S, Int32, UInt32, UInt32);
274     scilab_fill_or(ScalarInt32, ScalarInt64, int_S_S, Int32, Int64, Int64);
275     scilab_fill_or(ScalarInt32, ScalarUInt64, int_S_S, Int32, UInt64, UInt64);
276
277     //uint32
278     scilab_fill_or(UInt32, Int8, int_M_M, UInt32, Int8, UInt32);
279     scilab_fill_or(UInt32, UInt8, int_M_M, UInt32, UInt8, UInt32);
280     scilab_fill_or(UInt32, Int16, int_M_M, UInt32, Int16, UInt32);
281     scilab_fill_or(UInt32, UInt16, int_M_M, UInt32, UInt16, UInt32);
282     scilab_fill_or(UInt32, Int32, int_M_M, UInt32, Int32, UInt32);
283     scilab_fill_or(UInt32, UInt32, int_M_M, UInt32, UInt32, UInt32);
284     scilab_fill_or(UInt32, Int64, int_M_M, UInt32, Int64, UInt64);
285     scilab_fill_or(UInt32, UInt64, int_M_M, UInt32, UInt64, UInt64);
286
287     scilab_fill_or(UInt32, ScalarInt8, int_M_S, UInt32, Int8, UInt32);
288     scilab_fill_or(UInt32, ScalarUInt8, int_M_S, UInt32, UInt8, UInt32);
289     scilab_fill_or(UInt32, ScalarInt16, int_M_S, UInt32, Int16, UInt32);
290     scilab_fill_or(UInt32, ScalarUInt16, int_M_S, UInt32, UInt16, UInt32);
291     scilab_fill_or(UInt32, ScalarInt32, int_M_S, UInt32, Int32, UInt32);
292     scilab_fill_or(UInt32, ScalarUInt32, int_M_S, UInt32, UInt32, UInt32);
293     scilab_fill_or(UInt32, ScalarInt64, int_M_S, UInt32, Int64, UInt64);
294     scilab_fill_or(UInt32, ScalarUInt64, int_M_S, UInt32, UInt64, UInt64);
295
296     scilab_fill_or(ScalarUInt32, Int8, int_S_M, UInt32, Int8, UInt32);
297     scilab_fill_or(ScalarUInt32, UInt8, int_S_M, UInt32, UInt8, UInt32);
298     scilab_fill_or(ScalarUInt32, Int16, int_S_M, UInt32, Int16, UInt32);
299     scilab_fill_or(ScalarUInt32, UInt16, int_S_M, UInt32, UInt16, UInt32);
300     scilab_fill_or(ScalarUInt32, Int32, int_S_M, UInt32, Int32, UInt32);
301     scilab_fill_or(ScalarUInt32, UInt32, int_S_M, UInt32, UInt32, UInt32);
302     scilab_fill_or(ScalarUInt32, Int64, int_S_M, UInt32, Int64, UInt64);
303     scilab_fill_or(ScalarUInt32, UInt64, int_S_M, UInt32, UInt64, UInt64);
304
305     scilab_fill_or(ScalarUInt32, ScalarInt8, int_S_S, UInt32, Int8, UInt32);
306     scilab_fill_or(ScalarUInt32, ScalarUInt8, int_S_S, UInt32, UInt8, UInt32);
307     scilab_fill_or(ScalarUInt32, ScalarInt16, int_S_S, UInt32, Int16, UInt32);
308     scilab_fill_or(ScalarUInt32, ScalarUInt16, int_S_S, UInt32, UInt16, UInt32);
309     scilab_fill_or(ScalarUInt32, ScalarInt32, int_S_S, UInt32, Int32, UInt32);
310     scilab_fill_or(ScalarUInt32, ScalarUInt32, int_S_S, UInt32, UInt32, UInt32);
311     scilab_fill_or(ScalarUInt32, ScalarInt64, int_S_S, UInt32, Int64, UInt64);
312     scilab_fill_or(ScalarUInt32, ScalarUInt64, int_S_S, UInt32, UInt64, UInt64);
313
314     //int64
315     scilab_fill_or(Int64, Int8, int_M_M, Int64, Int8, Int64);
316     scilab_fill_or(Int64, UInt8, int_M_M, Int64, UInt8, UInt64);
317     scilab_fill_or(Int64, Int16, int_M_M, Int64, Int16, Int64);
318     scilab_fill_or(Int64, UInt16, int_M_M, Int64, UInt16, UInt64);
319     scilab_fill_or(Int64, Int32, int_M_M, Int64, Int32, Int64);
320     scilab_fill_or(Int64, UInt32, int_M_M, Int64, UInt32, UInt64);
321     scilab_fill_or(Int64, Int64, int_M_M, Int64, Int64, Int64);
322     scilab_fill_or(Int64, UInt64, int_M_M, Int64, UInt64, UInt64);
323
324     scilab_fill_or(Int64, ScalarInt8, int_M_S, Int64, Int8, Int64);
325     scilab_fill_or(Int64, ScalarUInt8, int_M_S, Int64, UInt8, UInt64);
326     scilab_fill_or(Int64, ScalarInt16, int_M_S, Int64, Int16, Int64);
327     scilab_fill_or(Int64, ScalarUInt16, int_M_S, Int64, UInt16, UInt64);
328     scilab_fill_or(Int64, ScalarInt32, int_M_S, Int64, Int32, Int64);
329     scilab_fill_or(Int64, ScalarUInt32, int_M_S, Int64, UInt32, UInt64);
330     scilab_fill_or(Int64, ScalarInt64, int_M_S, Int64, Int64, Int64);
331     scilab_fill_or(Int64, ScalarUInt64, int_M_S, Int64, UInt64, UInt64);
332
333     scilab_fill_or(ScalarInt64, Int8, int_S_M, Int64, Int8, Int64);
334     scilab_fill_or(ScalarInt64, UInt8, int_S_M, Int64, UInt8, UInt64);
335     scilab_fill_or(ScalarInt64, Int16, int_S_M, Int64, Int16, Int64);
336     scilab_fill_or(ScalarInt64, UInt16, int_S_M, Int64, UInt16, UInt64);
337     scilab_fill_or(ScalarInt64, Int32, int_S_M, Int64, Int32, Int64);
338     scilab_fill_or(ScalarInt64, UInt32, int_S_M, Int64, UInt32, UInt64);
339     scilab_fill_or(ScalarInt64, Int64, int_S_M, Int64, Int64, Int64);
340     scilab_fill_or(ScalarInt64, UInt64, int_S_M, Int64, UInt64, UInt64);
341
342     scilab_fill_or(ScalarInt64, ScalarInt8, int_S_S, Int64, Int8, Int64);
343     scilab_fill_or(ScalarInt64, ScalarUInt8, int_S_S, Int64, UInt8, UInt64);
344     scilab_fill_or(ScalarInt64, ScalarInt16, int_S_S, Int64, Int16, Int64);
345     scilab_fill_or(ScalarInt64, ScalarUInt16, int_S_S, Int64, UInt16, UInt64);
346     scilab_fill_or(ScalarInt64, ScalarInt32, int_S_S, Int64, Int32, Int64);
347     scilab_fill_or(ScalarInt64, ScalarUInt32, int_S_S, Int64, UInt32, UInt64);
348     scilab_fill_or(ScalarInt64, ScalarInt64, int_S_S, Int64, Int64, Int64);
349     scilab_fill_or(ScalarInt64, ScalarUInt64, int_S_S, Int64, UInt64, UInt64);
350
351     //uint64
352     scilab_fill_or(UInt64, Int8, int_M_M, UInt64, Int8, UInt64);
353     scilab_fill_or(UInt64, UInt8, int_M_M, UInt64, UInt8, UInt64);
354     scilab_fill_or(UInt64, Int16, int_M_M, UInt64, Int16, UInt64);
355     scilab_fill_or(UInt64, UInt16, int_M_M, UInt64, UInt16, UInt64);
356     scilab_fill_or(UInt64, Int32, int_M_M, UInt64, Int32, UInt64);
357     scilab_fill_or(UInt64, UInt32, int_M_M, UInt64, UInt32, UInt64);
358     scilab_fill_or(UInt64, Int64, int_M_M, UInt64, Int64, UInt64);
359     scilab_fill_or(UInt64, UInt64, int_M_M, UInt64, UInt64, UInt64);
360
361     scilab_fill_or(UInt64, ScalarInt8, int_M_S, UInt64, Int8, UInt64);
362     scilab_fill_or(UInt64, ScalarUInt8, int_M_S, UInt64, UInt8, UInt64);
363     scilab_fill_or(UInt64, ScalarInt16, int_M_S, UInt64, Int16, UInt64);
364     scilab_fill_or(UInt64, ScalarUInt16, int_M_S, UInt64, UInt16, UInt64);
365     scilab_fill_or(UInt64, ScalarInt32, int_M_S, UInt64, Int32, UInt64);
366     scilab_fill_or(UInt64, ScalarUInt32, int_M_S, UInt64, UInt32, UInt64);
367     scilab_fill_or(UInt64, ScalarInt64, int_M_S, UInt64, Int64, UInt64);
368     scilab_fill_or(UInt64, ScalarUInt64, int_M_S, UInt64, UInt64, UInt64);
369
370     scilab_fill_or(ScalarUInt64, Int8, int_S_M, UInt64, Int8, UInt64);
371     scilab_fill_or(ScalarUInt64, UInt8, int_S_M, UInt64, UInt8, UInt64);
372     scilab_fill_or(ScalarUInt64, Int16, int_S_M, UInt64, Int16, UInt64);
373     scilab_fill_or(ScalarUInt64, UInt16, int_S_M, UInt64, UInt16, UInt64);
374     scilab_fill_or(ScalarUInt64, Int32, int_S_M, UInt64, Int32, UInt64);
375     scilab_fill_or(ScalarUInt64, UInt32, int_S_M, UInt64, UInt32, UInt64);
376     scilab_fill_or(ScalarUInt64, Int64, int_S_M, UInt64, Int64, UInt64);
377     scilab_fill_or(ScalarUInt64, UInt64, int_S_M, UInt64, UInt64, UInt64);
378
379     scilab_fill_or(ScalarUInt64, ScalarInt8, int_S_S, UInt64, Int8, UInt64);
380     scilab_fill_or(ScalarUInt64, ScalarUInt8, int_S_S, UInt64, UInt8, UInt64);
381     scilab_fill_or(ScalarUInt64, ScalarInt16, int_S_S, UInt64, Int16, UInt64);
382     scilab_fill_or(ScalarUInt64, ScalarUInt16, int_S_S, UInt64, UInt16, UInt64);
383     scilab_fill_or(ScalarUInt64, ScalarInt32, int_S_S, UInt64, Int32, UInt64);
384     scilab_fill_or(ScalarUInt64, ScalarUInt32, int_S_S, UInt64, UInt32, UInt64);
385     scilab_fill_or(ScalarUInt64, ScalarInt64, int_S_S, UInt64, Int64, UInt64);
386     scilab_fill_or(ScalarUInt64, ScalarUInt64, int_S_S, UInt64, UInt64, UInt64);
387
388     //boolean sparse
389     scilab_fill_or(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
390     scilab_fill_or(Bool, SparseBool, M_M, Bool, SparseBool, SparseBool);
391     scilab_fill_or(SparseBool, Bool, M_M, SparseBool, Bool, SparseBool);
392     scilab_fill_or(ScalarBool, SparseBool, M_M, Bool, SparseBool, SparseBool);
393     scilab_fill_or(SparseBool, ScalarBool, M_M, SparseBool, Bool, SparseBool);
394
395 #undef scilab_fill_or
396 }
397
398 // ||
399 InternalType* GenericShortcutOr(InternalType* _pL)
400 {
401     InternalType* pResult = NULL;
402
403     if (_pL->isBool())
404     {
405         BoolOrBool(_pL->getAs<Bool>(), (Bool**)&pResult);
406     }
407
408     if (_pL->isInt())
409     {
410         IntOrInt(_pL, (Bool**)&pResult);
411     }
412
413     if (_pL->isSparseBool())
414     {
415         SparseBoolOrSparseBool(_pL, (Bool**)&pResult);
416     }
417
418     return pResult;
419 }
420
421 // |
422 InternalType* GenericLogicalOr(InternalType* _pL, InternalType* _pR)
423 {
424     InternalType *pResult = NULL;
425
426     or_function bit_or = pOrfunction[_pL->getId()][_pR->getId()];
427     if (bit_or)
428     {
429         pResult = bit_or(_pL, _pR);
430         if (pResult)
431         {
432             return pResult;
433         }
434     }
435
436     /*
437     ** Default case : Return NULL will Call Overloading.
438     */
439     return NULL;
440 }
441
442 int BoolOrBool(Bool* _pL, Bool** _pOut)
443 {
444     for (int i = 0 ; i < _pL->getSize() ; i++)
445     {
446         if (_pL->get(i) == 0)
447         {
448             //call non shorcut opearion
449             *_pOut = NULL;
450             return 0;
451         }
452     }
453
454     *_pOut = new Bool(1); //true || something -> true
455     return 0;
456 }
457
458 template <class K>
459 static int IntOrInt(K* _pL, Bool** _pOut)
460 {
461     for (int i = 0 ; i < _pL->getSize() ; i++)
462     {
463         if (_pL->get(i) == 0)
464         {
465             //call non shorcut opearion
466             *_pOut = NULL;
467             return 0;
468         }
469     }
470
471     *_pOut = new Bool(1); //true || something -> true
472     return 0;
473 }
474
475 int IntOrInt(InternalType* _pL, Bool** _pOut)
476 {
477     switch (_pL->getType())
478     {
479         case InternalType::ScilabInt8 :
480         {
481             return IntOrInt(_pL->getAs<Int8>(), _pOut);
482         }
483         case InternalType::ScilabUInt8 :
484         {
485             return IntOrInt(_pL->getAs<UInt8>(), _pOut);
486         }
487         case InternalType::ScilabInt16 :
488         {
489             return IntOrInt(_pL->getAs<Int16>(), _pOut);
490         }
491         case InternalType::ScilabUInt16 :
492         {
493             return IntOrInt(_pL->getAs<UInt16>(), _pOut);
494         }
495         case InternalType::ScilabInt32 :
496         {
497             return IntOrInt(_pL->getAs<Int32>(), _pOut);
498         }
499         case InternalType::ScilabUInt32 :
500         {
501             return IntOrInt(_pL->getAs<UInt32>(), _pOut);
502         }
503         case InternalType::ScilabInt64 :
504         {
505             return IntOrInt(_pL->getAs<Int64>(), _pOut);
506         }
507         case InternalType::ScilabUInt64 :
508         {
509             return IntOrInt(_pL->getAs<UInt64>(), _pOut);
510         }
511         default:
512         {
513             return 3;
514         }
515     }
516 }
517
518 int SparseBoolOrSparseBool(InternalType* _pL, Bool** _pOut)
519 {
520     SparseBool* pL = _pL->getAs<SparseBool>();
521     if (pL->nbTrue() == pL->getSize())
522     {
523         *_pOut = new Bool(1);
524         return 0;
525     }
526
527     *_pOut = NULL;
528     return 0;
529 }
530
531 template<class T, class U, class O>
532 InternalType* or_M_M(T *_pL, U *_pR)
533 {
534     int iDimsL = _pL->getDims();
535     int iDimsR = _pR->getDims();
536
537     if (iDimsL != iDimsR)
538     {
539         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
540     }
541
542     int* piDimsL = _pL->getDimsArray();
543     int* piDimsR = _pR->getDimsArray();
544
545     for (int i = 0 ; i < iDimsL ; ++i)
546     {
547         if (piDimsL[i] != piDimsR[i])
548         {
549             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
550         }
551     }
552
553     O* pOut = new O(iDimsL, piDimsL);
554
555     bit_or(_pL->get(), (long long)_pL->getSize(), _pR->get(), pOut->get());
556     return pOut;
557 }
558
559 template<class T, class U, class O>
560 InternalType* or_S_M(T *_pL, U *_pR)
561 {
562     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
563     bit_or(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), pOut->get());
564     return pOut;
565 }
566
567 template<class T, class U, class O>
568 InternalType* or_M_S(T *_pL, U *_pR)
569 {
570     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
571     bit_or(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), pOut->get());
572     return pOut;
573 }
574
575 template<class T, class U, class O>
576 InternalType* or_S_S(T *_pL, U *_pR)
577 {
578     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
579     bit_or(_pL->get(0), _pR->get(0), pOut->get());
580     return pOut;
581 }
582
583 template<class T, class U, class O>
584 InternalType* or_M_E(T *_pL, U *_pR)
585 {
586     return _pR;
587 }
588
589 template<>
590 InternalType* or_M_E<Bool, Double, Bool>(Bool* _pL, Double* /* _pR */)
591 {
592     Bool* pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
593     pOut->setTrue();
594     return pOut;
595 }
596
597 template<class T, class U, class O>
598 InternalType* or_E_M(T *_pL, U *_pR)
599 {
600     return _pL;
601 }
602
603 template<>
604 InternalType* or_E_M<Double, Bool, Bool>(Double* /* _pL */, Bool*  _pR)
605 {
606     Bool* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
607     pOut->setTrue();
608     return pOut;
609 }
610
611 template<class T, class U, class O>
612 InternalType* or_I_S(T *_pL, U *_pR)
613 {
614     return or_S_S<U, T, O>(_pR, _pL);
615 }
616
617 template<class T, class U, class O>
618 InternalType* or_I_M(T *_pL, U *_pR)
619 {
620     return or_M_S<U, T, O>(_pR, _pL);
621 }
622
623
624 template<class T, class U, class O>
625 InternalType* or_int_M_M(T *_pL, U *_pR)
626 {
627     int iDimsL = _pL->getDims();
628     int iDimsR = _pR->getDims();
629
630     if (iDimsL != iDimsR)
631     {
632         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
633     }
634
635     int* piDimsL = _pL->getDimsArray();
636     int* piDimsR = _pR->getDimsArray();
637
638     for (int i = 0 ; i < iDimsL ; ++i)
639     {
640         if (piDimsL[i] != piDimsR[i])
641         {
642             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
643         }
644     }
645
646     O* pOut = new O(iDimsL, piDimsL);
647
648     int_or(_pL->get(), (long long)_pL->getSize(), _pR->get(), pOut->get());
649     return pOut;
650 }
651
652 template<class T, class U, class O>
653 InternalType* or_int_S_M(T *_pL, U *_pR)
654 {
655     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
656     int_or(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), pOut->get());
657     return pOut;
658 }
659
660 template<class T, class U, class O>
661 InternalType* or_int_M_S(T *_pL, U *_pR)
662 {
663     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
664     int_or(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), pOut->get());
665     return pOut;
666 }
667
668 template<class T, class U, class O>
669 InternalType* or_int_S_S(T *_pL, U *_pR)
670 {
671     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
672     int_or(_pL->get(0), _pR->get(0), pOut->get());
673     return pOut;
674 }
675
676 //boolean sparse
677 template<>
678 InternalType* or_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
679 {
680     SparseBool* pOut = NULL;
681     if (_pL->isScalar())
682     {
683         if (_pL->get(0, 0))
684         {
685             pOut = new SparseBool(_pR->getRows(), _pR->getCols());
686             int iCols = pOut->getCols();
687             int iRows = pOut->getRows();
688             for (int i = 0 ; i < iRows ; i++)
689             {
690                 for (int j = 0 ; j < iCols ; j++)
691                 {
692                     pOut->set(i, j, true);
693                 }
694             }
695         }
696         else
697         {
698             pOut = _pR;
699         }
700
701         return pOut;
702     }
703
704     if (_pR->isScalar())
705     {
706         if (_pR->get(0, 0))
707         {
708             pOut = new SparseBool(_pL->getRows(), _pL->getCols());
709             int iCols = pOut->getCols();
710             int iRows = pOut->getRows();
711             for (int i = 0 ; i < iRows ; i++)
712             {
713                 for (int j = 0 ; j < iCols ; j++)
714                 {
715                     pOut->set(i, j, true);
716                 }
717             }
718         }
719         else
720         {
721             pOut = _pL;
722         }
723
724         return pOut;
725     }
726
727     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
728     {
729         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
730     }
731
732     return _pL->newLogicalOr(*_pR);
733 }
734
735 template<>
736 InternalType* or_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
737 {
738     SparseBool* pR = new SparseBool(*_pR);
739     InternalType* pOut = or_M_M<SparseBool, SparseBool, SparseBool>(_pL, pR);
740     delete pR;
741     return pOut;
742 }
743
744 template<>
745 InternalType* or_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
746 {
747     SparseBool* pL = new SparseBool(*_pL);
748     InternalType* pOut = or_M_M<SparseBool, SparseBool, SparseBool>(pL, _pR);
749     delete pL;
750     return pOut;
751 }
752