b4bb931f3788d13b0df4059119d8d1ea2b7b7377
[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->isDouble())
409     {
410         DoubleOrDouble(_pL->getAs<Double>(), (Bool**)&pResult);
411     }
412
413     if (_pL->isInt())
414     {
415         IntOrInt(_pL, (Bool**)&pResult);
416     }
417
418     if (_pL->isSparseBool())
419     {
420         SparseBoolOrSparseBool(_pL, (Bool**)&pResult);
421     }
422
423     return pResult;
424 }
425
426 // |
427 InternalType* GenericLogicalOr(InternalType* _pL, InternalType* _pR)
428 {
429     InternalType *pResult = NULL;
430
431     or_function bit_or = pOrfunction[_pL->getId()][_pR->getId()];
432     if (bit_or)
433     {
434         pResult = bit_or(_pL, _pR);
435         if (pResult)
436         {
437             return pResult;
438         }
439     }
440
441     /*
442     ** Default case : Return NULL will Call Overloading.
443     */
444     return NULL;
445 }
446
447 int BoolOrBool(Bool* _pL, Bool** _pOut)
448 {
449     for (int i = 0 ; i < _pL->getSize() ; i++)
450     {
451         if (_pL->get(i) == 0)
452         {
453             //call non shorcut opearion
454             *_pOut = NULL;
455             return 0;
456         }
457     }
458
459     *_pOut = new Bool(1); //true || something -> true
460     return 0;
461 }
462
463 int DoubleOrDouble(Double* _pL, Bool** _pOut)
464 {
465     for (int i = 0 ; i < _pL->getSize() ; i++)
466     {
467         if (_pL->get(i) == 0)
468         {
469             //call non shorcut operation
470             *_pOut = NULL;
471             return 0;
472         }
473     }
474
475     *_pOut = new Bool(1); //true || something -> true
476     return 0;
477 }
478
479 template <class K>
480 static int IntOrInt(K* _pL, Bool** _pOut)
481 {
482     for (int i = 0 ; i < _pL->getSize() ; i++)
483     {
484         if (_pL->get(i) == 0)
485         {
486             //call non shorcut opearion
487             *_pOut = NULL;
488             return 0;
489         }
490     }
491
492     *_pOut = new Bool(1); //true || something -> true
493     return 0;
494 }
495
496 int IntOrInt(InternalType* _pL, Bool** _pOut)
497 {
498     switch (_pL->getType())
499     {
500         case InternalType::ScilabInt8 :
501         {
502             return IntOrInt(_pL->getAs<Int8>(), _pOut);
503         }
504         case InternalType::ScilabUInt8 :
505         {
506             return IntOrInt(_pL->getAs<UInt8>(), _pOut);
507         }
508         case InternalType::ScilabInt16 :
509         {
510             return IntOrInt(_pL->getAs<Int16>(), _pOut);
511         }
512         case InternalType::ScilabUInt16 :
513         {
514             return IntOrInt(_pL->getAs<UInt16>(), _pOut);
515         }
516         case InternalType::ScilabInt32 :
517         {
518             return IntOrInt(_pL->getAs<Int32>(), _pOut);
519         }
520         case InternalType::ScilabUInt32 :
521         {
522             return IntOrInt(_pL->getAs<UInt32>(), _pOut);
523         }
524         case InternalType::ScilabInt64 :
525         {
526             return IntOrInt(_pL->getAs<Int64>(), _pOut);
527         }
528         case InternalType::ScilabUInt64 :
529         {
530             return IntOrInt(_pL->getAs<UInt64>(), _pOut);
531         }
532         default:
533         {
534             return 3;
535         }
536     }
537 }
538
539 int SparseBoolOrSparseBool(InternalType* _pL, Bool** _pOut)
540 {
541     SparseBool* pL = _pL->getAs<SparseBool>();
542     if (pL->nbTrue() == pL->getSize())
543     {
544         *_pOut = new Bool(1);
545         return 0;
546     }
547
548     *_pOut = NULL;
549     return 0;
550 }
551
552 template<class T, class U, class O>
553 InternalType* or_M_M(T *_pL, U *_pR)
554 {
555     int iDimsL = _pL->getDims();
556     int iDimsR = _pR->getDims();
557
558     if (iDimsL != iDimsR)
559     {
560         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
561     }
562
563     int* piDimsL = _pL->getDimsArray();
564     int* piDimsR = _pR->getDimsArray();
565
566     for (int i = 0 ; i < iDimsL ; ++i)
567     {
568         if (piDimsL[i] != piDimsR[i])
569         {
570             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
571         }
572     }
573
574     O* pOut = new O(iDimsL, piDimsL);
575
576     bit_or(_pL->get(), (long long)_pL->getSize(), _pR->get(), pOut->get());
577     return pOut;
578 }
579
580 template<class T, class U, class O>
581 InternalType* or_S_M(T *_pL, U *_pR)
582 {
583     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
584     bit_or(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), pOut->get());
585     return pOut;
586 }
587
588 template<class T, class U, class O>
589 InternalType* or_M_S(T *_pL, U *_pR)
590 {
591     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
592     bit_or(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), pOut->get());
593     return pOut;
594 }
595
596 template<class T, class U, class O>
597 InternalType* or_S_S(T *_pL, U *_pR)
598 {
599     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
600     bit_or(_pL->get(0), _pR->get(0), pOut->get());
601     return pOut;
602 }
603
604 template<class T, class U, class O>
605 InternalType* or_M_E(T *_pL, U *_pR)
606 {
607     return _pR;
608 }
609
610 template<>
611 InternalType* or_M_E<Bool, Double, Bool>(Bool* _pL, Double* /* _pR */)
612 {
613     Bool* pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
614     pOut->setTrue();
615     return pOut;
616 }
617
618 template<class T, class U, class O>
619 InternalType* or_E_M(T *_pL, U *_pR)
620 {
621     return _pL;
622 }
623
624 template<>
625 InternalType* or_E_M<Double, Bool, Bool>(Double* /* _pL */, Bool*  _pR)
626 {
627     Bool* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
628     pOut->setTrue();
629     return pOut;
630 }
631
632 template<class T, class U, class O>
633 InternalType* or_I_S(T *_pL, U *_pR)
634 {
635     return or_S_S<U, T, O>(_pR, _pL);
636 }
637
638 template<class T, class U, class O>
639 InternalType* or_I_M(T *_pL, U *_pR)
640 {
641     return or_M_S<U, T, O>(_pR, _pL);
642 }
643
644
645 template<class T, class U, class O>
646 InternalType* or_int_M_M(T *_pL, U *_pR)
647 {
648     int iDimsL = _pL->getDims();
649     int iDimsR = _pR->getDims();
650
651     if (iDimsL != iDimsR)
652     {
653         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
654     }
655
656     int* piDimsL = _pL->getDimsArray();
657     int* piDimsR = _pR->getDimsArray();
658
659     for (int i = 0 ; i < iDimsL ; ++i)
660     {
661         if (piDimsL[i] != piDimsR[i])
662         {
663             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
664         }
665     }
666
667     O* pOut = new O(iDimsL, piDimsL);
668
669     int_or(_pL->get(), (long long)_pL->getSize(), _pR->get(), pOut->get());
670     return pOut;
671 }
672
673 template<class T, class U, class O>
674 InternalType* or_int_S_M(T *_pL, U *_pR)
675 {
676     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
677     int_or(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), pOut->get());
678     return pOut;
679 }
680
681 template<class T, class U, class O>
682 InternalType* or_int_M_S(T *_pL, U *_pR)
683 {
684     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
685     int_or(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), pOut->get());
686     return pOut;
687 }
688
689 template<class T, class U, class O>
690 InternalType* or_int_S_S(T *_pL, U *_pR)
691 {
692     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
693     int_or(_pL->get(0), _pR->get(0), pOut->get());
694     return pOut;
695 }
696
697 //boolean sparse
698 template<>
699 InternalType* or_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
700 {
701     SparseBool* pOut = NULL;
702     if (_pL->isScalar())
703     {
704         if (_pL->get(0, 0))
705         {
706             pOut = new SparseBool(_pR->getRows(), _pR->getCols());
707             int iCols = pOut->getCols();
708             int iRows = pOut->getRows();
709             for (int i = 0 ; i < iRows ; i++)
710             {
711                 for (int j = 0 ; j < iCols ; j++)
712                 {
713                     pOut->set(i, j, true);
714                 }
715             }
716         }
717         else
718         {
719             pOut = _pR;
720         }
721
722         return pOut;
723     }
724
725     if (_pR->isScalar())
726     {
727         if (_pR->get(0, 0))
728         {
729             pOut = new SparseBool(_pL->getRows(), _pL->getCols());
730             int iCols = pOut->getCols();
731             int iRows = pOut->getRows();
732             for (int i = 0 ; i < iRows ; i++)
733             {
734                 for (int j = 0 ; j < iCols ; j++)
735                 {
736                     pOut->set(i, j, true);
737                 }
738             }
739         }
740         else
741         {
742             pOut = _pL;
743         }
744
745         return pOut;
746     }
747
748     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
749     {
750         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
751     }
752
753     return _pL->newLogicalOr(*_pR);
754 }
755
756 template<>
757 InternalType* or_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
758 {
759     SparseBool* pR = new SparseBool(*_pR);
760     InternalType* pOut = or_M_M<SparseBool, SparseBool, SparseBool>(_pL, pR);
761     delete pR;
762     return pOut;
763 }
764
765 template<>
766 InternalType* or_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
767 {
768     SparseBool* pL = new SparseBool(*_pL);
769     InternalType* pOut = or_M_M<SparseBool, SparseBool, SparseBool>(pL, _pR);
770     delete pL;
771     return pOut;
772 }
773