Replace Min, Max and Abs by std::min, std::max and std::abs
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_addition.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4  *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
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 #include "types_addition.hxx"
15 #include "operations.hxx"
16 #include "double.hxx"
17 #include "int.hxx"
18
19 #include "scilabexception.hxx"
20
21 extern "C"
22 {
23 #include <stdio.h>
24 #include "core_math.h"
25 #include "matrix_addition.h"
26 #include "localization.h"
27 #include "charEncoding.h"
28 #include "os_swprintf.h"
29 #include "elem_common.h" //dset
30 }
31
32 using namespace types;
33
34
35 //define arrays on operation functions
36 static add_function pAddfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
37
38 add_function getAddFunction(types::InternalType::ScilabId leftId, types::InternalType::ScilabId rightId)
39 {
40     return pAddfunction[leftId][rightId];
41 }
42
43
44 void fillAddFunction()
45 {
46 #define scilab_fill_add(id1, id2, func, typeIn1, typeIn2, typeOut) \
47     pAddfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (add_function)&add_##func<typeIn1, typeIn2, typeOut>
48
49     //Double
50     //Matrix + Matrix
51     scilab_fill_add(Double, Double, M_M, Double, Double, Double);
52     scilab_fill_add(Double, Int8, M_M, Double, Int8, Int8);
53     scilab_fill_add(Double, UInt8, M_M, Double, UInt8, UInt8);
54     scilab_fill_add(Double, Int16, M_M, Double, Int16, Int16);
55     scilab_fill_add(Double, UInt16, M_M, Double, UInt16, UInt16);
56     scilab_fill_add(Double, Int32, M_M, Double, Int32, Int32);
57     scilab_fill_add(Double, UInt32, M_M, Double, UInt32, UInt32);
58     scilab_fill_add(Double, Int64, M_M, Double, Int64, Int64);
59     scilab_fill_add(Double, UInt64, M_M, Double, UInt64, UInt64);
60     scilab_fill_add(Double, Bool, M_M, Double, Bool, Double);
61     scilab_fill_add(Double, Polynom, M_M, Double, Polynom, Polynom);
62     scilab_fill_add(Double, Sparse, M_M, Double, Sparse, Double);
63
64     //Matrix + Matrix Complex
65     scilab_fill_add(Double, DoubleComplex, M_MC, Double, Double, Double);
66     scilab_fill_add(Double, PolynomComplex, M_M, Double, Polynom, Polynom);
67     scilab_fill_add(Double, SparseComplex, M_M, Double, Sparse, Double);
68
69     //Matrix + Scalar
70     scilab_fill_add(Double, ScalarDouble, M_S, Double, Double, Double);
71     scilab_fill_add(Double, ScalarInt8, M_S, Double, Int8, Int8);
72     scilab_fill_add(Double, ScalarUInt8, M_S, Double, UInt8, UInt8);
73     scilab_fill_add(Double, ScalarInt16, M_S, Double, Int16, Int16);
74     scilab_fill_add(Double, ScalarUInt16, M_S, Double, UInt16, UInt16);
75     scilab_fill_add(Double, ScalarInt32, M_S, Double, Int32, Int32);
76     scilab_fill_add(Double, ScalarUInt32, M_S, Double, UInt32, UInt32);
77     scilab_fill_add(Double, ScalarInt64, M_S, Double, Int64, Int64);
78     scilab_fill_add(Double, ScalarUInt64, M_S, Double, UInt64, UInt64);
79     scilab_fill_add(Double, ScalarBool, M_S, Double, Bool, Double);
80     scilab_fill_add(Double, ScalarPolynom, M_M, Double, Polynom, Polynom);
81
82     //Matrix + Scalar Complex
83     scilab_fill_add(Double, ScalarDoubleComplex, M_SC, Double, Double, Double);
84     scilab_fill_add(Double, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
85     //Matrix + Empty
86     scilab_fill_add(Double, Empty, M_E, Double, Double, Double);
87
88
89     //Matrix Complex + Matrix
90     scilab_fill_add(DoubleComplex, Double, MC_M, Double, Double, Double);
91     scilab_fill_add(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Double);
92     scilab_fill_add(DoubleComplex, ScalarDouble, MC_S, Double, Double, Double);
93     scilab_fill_add(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Double);
94     scilab_fill_add(DoubleComplex, Empty, MC_E, Double, Double, Double);
95     scilab_fill_add(DoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
96     scilab_fill_add(DoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
97     scilab_fill_add(DoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
98     scilab_fill_add(DoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
99     scilab_fill_add(DoubleComplex, Sparse, M_M, Double, Sparse, Double);
100     scilab_fill_add(DoubleComplex, SparseComplex, M_M, Double, Sparse, Double);
101
102     //Scalar + Matrix
103     scilab_fill_add(ScalarDouble, Double, S_M, Double, Double, Double);
104     scilab_fill_add(ScalarDouble, Int8, S_M, Double, Int8, Int8);
105     scilab_fill_add(ScalarDouble, UInt8, S_M, Double, UInt8, UInt8);
106     scilab_fill_add(ScalarDouble, Int16, S_M, Double, Int16, Int16);
107     scilab_fill_add(ScalarDouble, UInt16, S_M, Double, UInt16, UInt16);
108     scilab_fill_add(ScalarDouble, Int32, S_M, Double, Int32, Int32);
109     scilab_fill_add(ScalarDouble, UInt32, S_M, Double, UInt32, UInt32);
110     scilab_fill_add(ScalarDouble, Int64, S_M, Double, Int64, Int64);
111     scilab_fill_add(ScalarDouble, UInt64, S_M, Double, UInt64, UInt64);
112     scilab_fill_add(ScalarDouble, Bool, S_M, Double, Bool, Double);
113     scilab_fill_add(ScalarDouble, Polynom, M_M, Double, Polynom, Polynom);
114     scilab_fill_add(ScalarDouble, Sparse, M_M, Double, Sparse, Double);
115
116     //Scalar + Matrix Complex
117     scilab_fill_add(ScalarDouble, DoubleComplex, S_MC, Double, Double, Double);
118     scilab_fill_add(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
119     scilab_fill_add(ScalarDouble, SparseComplex, M_M, Double, Sparse, Double);
120
121     //Scalar + Scalar
122     scilab_fill_add(ScalarDouble, ScalarDouble, S_S, Double, Double, Double);
123     scilab_fill_add(ScalarDouble, ScalarInt8, S_S, Double, Int8, Int8);
124     scilab_fill_add(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, UInt8);
125     scilab_fill_add(ScalarDouble, ScalarInt16, S_S, Double, Int16, Int16);
126     scilab_fill_add(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, UInt16);
127     scilab_fill_add(ScalarDouble, ScalarInt32, S_S, Double, Int32, Int32);
128     scilab_fill_add(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, UInt32);
129     scilab_fill_add(ScalarDouble, ScalarInt64, S_S, Double, Int64, Int64);
130     scilab_fill_add(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, UInt64);
131     scilab_fill_add(ScalarDouble, ScalarBool, S_S, Double, Bool, Double);
132     scilab_fill_add(ScalarDouble, ScalarPolynom, M_M, Double, Polynom, Polynom);
133
134     //Scalar + Scalar Complex
135     scilab_fill_add(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Double);
136     scilab_fill_add(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
137     scilab_fill_add(ScalarDouble, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
138
139     //Scalar + Empty
140     scilab_fill_add(ScalarDouble, Empty, S_E, Double, Double, Double);
141
142     //Scalar Complex + Matrix
143     scilab_fill_add(ScalarDoubleComplex, Double, SC_M, Double, Double, Double);
144     scilab_fill_add(ScalarDoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
145     scilab_fill_add(ScalarDoubleComplex, Sparse, M_M, Double, Sparse, Double);
146     //Scalar Complex + Matrix Complex
147     scilab_fill_add(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Double);
148     scilab_fill_add(ScalarDoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
149     scilab_fill_add(ScalarDoubleComplex, SparseComplex, M_M, Double, Sparse, Double);
150     //Scalar Complex + Scalar
151     scilab_fill_add(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Double);
152     scilab_fill_add(ScalarDoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
153     //Scalar Complex + Scalar Complex
154     scilab_fill_add(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Double);
155     scilab_fill_add(ScalarDoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
156     //Scalar Complex + Empty
157     scilab_fill_add(ScalarDoubleComplex, Empty, SC_E, Double, Double, Double);
158
159     //Empty + Matrix
160     scilab_fill_add(Empty, Double, E_M, Double, Double, Double);
161     scilab_fill_add(Empty, Int8, E_M, Double, Int8, Int8);
162     scilab_fill_add(Empty, UInt8, E_M, Double, UInt8, UInt8);
163     scilab_fill_add(Empty, Int16, E_M, Double, Int16, Int16);
164     scilab_fill_add(Empty, UInt16, E_M, Double, UInt16, UInt16);
165     //scilab_fill_add(Empty, Int32, E_M, Double, Int32, Int32);
166     scilab_fill_add(Empty, UInt32, E_M, Double, UInt32, UInt32);
167     scilab_fill_add(Empty, Int64, E_M, Double, Int64, Int64);
168     scilab_fill_add(Empty, UInt64, E_M, Double, UInt64, UInt64);
169     //scilab_fill_add(Empty, Bool, E_M, Double, Bool, Double);
170     scilab_fill_add(Empty, String, E_M, Double, String, String);
171     scilab_fill_add(Empty, Polynom, M_M, Double, Polynom, Polynom);
172     scilab_fill_add(Empty, PolynomComplex, M_M, Double, Polynom, Polynom);
173     scilab_fill_add(Empty, Sparse, M_M, Double, Sparse, Sparse);
174     scilab_fill_add(Empty, SparseComplex, M_M, Double, Sparse, Sparse);
175
176     //Empty + Matrix Complex
177     scilab_fill_add(Empty, DoubleComplex, E_MC, Double, Double, Double);
178     //Empty + Scalar
179     scilab_fill_add(Empty, ScalarDouble, E_S, Double, Double, Double);
180     scilab_fill_add(Empty, ScalarInt8, E_S, Double, Int8, Int8);
181     scilab_fill_add(Empty, ScalarUInt8, E_S, Double, UInt8, UInt8);
182     scilab_fill_add(Empty, ScalarInt16, E_S, Double, Int16, Int16);
183     scilab_fill_add(Empty, ScalarUInt16, E_S, Double, UInt16, UInt16);
184     scilab_fill_add(Empty, ScalarInt32, E_S, Double, Int32, Int32);
185     scilab_fill_add(Empty, ScalarUInt32, E_S, Double, UInt32, UInt32);
186     scilab_fill_add(Empty, ScalarInt64, E_S, Double, Int64, Int64);
187     scilab_fill_add(Empty, ScalarUInt64, E_S, Double, UInt64, UInt64);
188     scilab_fill_add(Empty, ScalarBool, E_S, Double, Bool, Double);
189     scilab_fill_add(Empty, ScalarString, E_S, Double, String, String);
190     scilab_fill_add(Empty, ScalarPolynom, M_M, Double, Polynom, Polynom);
191
192     //Empty + Scalar Complex
193     scilab_fill_add(Empty, ScalarDoubleComplex, E_SC, Double, Double, Double);
194     scilab_fill_add(Empty, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
195     //Empty + Empty
196     scilab_fill_add(Empty, Empty, E_E, Double, Double, Double);
197     //Empty + eye
198     scilab_fill_add(Empty, Identity, E_I, Double, Double, Double);
199     scilab_fill_add(Empty, IdentityComplex, E_IC, Double, Double, Double);
200
201     //Matrix + Identity
202     scilab_fill_add(Double, Identity, M_I, Double, Double, Double);
203     scilab_fill_add(Double, IdentityComplex, M_IC, Double, Double, Double);
204     scilab_fill_add(DoubleComplex, Identity, MC_I, Double, Double, Double);
205     scilab_fill_add(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Double);
206     scilab_fill_add(ScalarDouble, Identity, S_I, Double, Double, Double);
207     scilab_fill_add(ScalarDouble, IdentityComplex, S_IC, Double, Double, Double);
208     scilab_fill_add(ScalarDoubleComplex, Identity, SC_I, Double, Double, Double);
209     scilab_fill_add(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Double);
210
211
212     //Int8
213     //Matrix + Matrix
214     scilab_fill_add(Int8, Double, M_M, Int8, Double, Int8);
215     scilab_fill_add(Int8, Int8, M_M, Int8, Int8, Int8);
216     scilab_fill_add(Int8, UInt8, M_M, Int8, UInt8, UInt8);
217     scilab_fill_add(Int8, Int16, M_M, Int8, Int16, Int16);
218     scilab_fill_add(Int8, UInt16, M_M, Int8, UInt16, UInt16);
219     scilab_fill_add(Int8, Int32, M_M, Int8, Int32, Int32);
220     scilab_fill_add(Int8, UInt32, M_M, Int8, UInt32, UInt32);
221     scilab_fill_add(Int8, Int64, M_M, Int8, Int64, Int64);
222     scilab_fill_add(Int8, UInt64, M_M, Int8, UInt64, UInt64);
223     scilab_fill_add(Int8, Bool, M_M, Int8, Bool, Int8);
224     scilab_fill_add(Int8, Empty, M_M, Int8, Double, Int8);
225
226     //Matrix + Scalar
227     scilab_fill_add(Int8, ScalarDouble, M_S, Int8, Double, Int8);
228     scilab_fill_add(Int8, ScalarInt8, M_S, Int8, Int8, Int8);
229     scilab_fill_add(Int8, ScalarUInt8, M_S, Int8, UInt8, UInt8);
230     scilab_fill_add(Int8, ScalarInt16, M_S, Int8, Int16, Int16);
231     scilab_fill_add(Int8, ScalarUInt16, M_S, Int8, UInt16, UInt16);
232     scilab_fill_add(Int8, ScalarInt32, M_S, Int8, Int32, Int32);
233     scilab_fill_add(Int8, ScalarUInt32, M_S, Int8, UInt32, UInt32);
234     scilab_fill_add(Int8, ScalarInt64, M_S, Int8, Int64, Int64);
235     scilab_fill_add(Int8, ScalarUInt64, M_S, Int8, UInt64, UInt64);
236     scilab_fill_add(Int8, ScalarBool, M_S, Int8, Bool, Int8);
237
238     //Scalar + Matrix
239     scilab_fill_add(ScalarInt8, Double, S_M, Int8, Double, Int8);
240     scilab_fill_add(ScalarInt8, Int8, S_M, Int8, Int8, Int8);
241     scilab_fill_add(ScalarInt8, UInt8, S_M, Int8, UInt8, UInt8);
242     scilab_fill_add(ScalarInt8, Int16, S_M, Int8, Int16, Int16);
243     scilab_fill_add(ScalarInt8, UInt16, S_M, Int8, UInt16, UInt16);
244     scilab_fill_add(ScalarInt8, Int32, S_M, Int8, Int32, Int32);
245     scilab_fill_add(ScalarInt8, UInt32, S_M, Int8, UInt32, UInt32);
246     scilab_fill_add(ScalarInt8, Int64, S_M, Int8, Int64, Int64);
247     scilab_fill_add(ScalarInt8, UInt64, S_M, Int8, UInt64, UInt64);
248     scilab_fill_add(ScalarInt8, Bool, S_M, Int8, Bool, Int8);
249     scilab_fill_add(ScalarInt8, Empty, M_M, Int8, Double, Int8);
250
251     //Scalar + Scalar
252     scilab_fill_add(ScalarInt8, ScalarDouble, S_S, Int8, Double, Int8);
253     scilab_fill_add(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Int8);
254     scilab_fill_add(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, UInt8);
255     scilab_fill_add(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Int16);
256     scilab_fill_add(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, UInt16);
257     scilab_fill_add(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Int32);
258     scilab_fill_add(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, UInt32);
259     scilab_fill_add(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Int64);
260     scilab_fill_add(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, UInt64);
261     scilab_fill_add(ScalarInt8, ScalarBool, S_S, Int8, Bool, Int8);
262
263     //UInt8
264     //Matrix + Matrix
265     scilab_fill_add(UInt8, Double, M_M, UInt8, Double, UInt8);
266     scilab_fill_add(UInt8, Int8, M_M, UInt8, Int8, UInt8);
267     scilab_fill_add(UInt8, UInt8, M_M, UInt8, UInt8, UInt8);
268     scilab_fill_add(UInt8, Int16, M_M, UInt8, Int16, UInt16);
269     scilab_fill_add(UInt8, UInt16, M_M, UInt8, UInt16, UInt16);
270     scilab_fill_add(UInt8, Int32, M_M, UInt8, Int32, UInt32);
271     scilab_fill_add(UInt8, UInt32, M_M, UInt8, UInt32, UInt32);
272     scilab_fill_add(UInt8, Int64, M_M, UInt8, Int64, UInt64);
273     scilab_fill_add(UInt8, UInt64, M_M, UInt8, UInt64, UInt64);
274     scilab_fill_add(UInt8, Bool, M_M, UInt8, Bool, UInt8);
275     scilab_fill_add(UInt8, Empty, M_M, UInt8, Double, UInt8);
276
277     //Matrix + Scalar
278     scilab_fill_add(UInt8, ScalarDouble, M_S, UInt8, Double, UInt8);
279     scilab_fill_add(UInt8, ScalarInt8, M_S, UInt8, Int8, UInt8);
280     scilab_fill_add(UInt8, ScalarUInt8, M_S, UInt8, UInt8, UInt8);
281     scilab_fill_add(UInt8, ScalarInt16, M_S, UInt8, Int16, UInt16);
282     scilab_fill_add(UInt8, ScalarUInt16, M_S, UInt8, UInt16, UInt16);
283     scilab_fill_add(UInt8, ScalarInt32, M_S, UInt8, Int32, UInt32);
284     scilab_fill_add(UInt8, ScalarUInt32, M_S, UInt8, UInt32, UInt32);
285     scilab_fill_add(UInt8, ScalarInt64, M_S, UInt8, Int64, UInt64);
286     scilab_fill_add(UInt8, ScalarUInt64, M_S, UInt8, UInt64, UInt64);
287     scilab_fill_add(UInt8, ScalarBool, M_S, UInt8, Bool, UInt8);
288
289     //Scalar + Matrix
290     scilab_fill_add(ScalarUInt8, Double, S_M, UInt8, Double, UInt8);
291     scilab_fill_add(ScalarUInt8, Int8, S_M, UInt8, Int8, UInt8);
292     scilab_fill_add(ScalarUInt8, UInt8, S_M, UInt8, UInt8, UInt8);
293     scilab_fill_add(ScalarUInt8, Int16, S_M, UInt8, Int16, UInt16);
294     scilab_fill_add(ScalarUInt8, UInt16, S_M, UInt8, UInt16, UInt16);
295     scilab_fill_add(ScalarUInt8, Int32, S_M, UInt8, Int32, UInt32);
296     scilab_fill_add(ScalarUInt8, UInt32, S_M, UInt8, UInt32, UInt32);
297     scilab_fill_add(ScalarUInt8, Int64, S_M, UInt8, Int64, UInt64);
298     scilab_fill_add(ScalarUInt8, UInt64, S_M, UInt8, UInt64, UInt64);
299     scilab_fill_add(ScalarUInt8, Bool, S_M, UInt8, Bool, UInt8);
300     scilab_fill_add(ScalarUInt8, Empty, S_M, UInt8, Double, UInt8);
301
302     //Scalar + Scalar
303     scilab_fill_add(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, UInt8);
304     scilab_fill_add(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, UInt8);
305     scilab_fill_add(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, UInt8);
306     scilab_fill_add(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, UInt16);
307     scilab_fill_add(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, UInt16);
308     scilab_fill_add(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, UInt32);
309     scilab_fill_add(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, UInt32);
310     scilab_fill_add(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, UInt64);
311     scilab_fill_add(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, UInt64);
312     scilab_fill_add(ScalarUInt8, ScalarBool, S_S, UInt8, Bool, UInt8);
313
314     //Int16
315     //Matrix + Matrix
316     scilab_fill_add(Int16, Double, M_M, Int16, Double, Int16);
317     scilab_fill_add(Int16, Int8, M_M, Int16, Int8, Int16);
318     scilab_fill_add(Int16, UInt8, M_M, Int16, UInt8, UInt16);
319     scilab_fill_add(Int16, Int16, M_M, Int16, Int16, Int16);
320     scilab_fill_add(Int16, UInt16, M_M, Int16, UInt16, UInt16);
321     scilab_fill_add(Int16, Int32, M_M, Int16, Int32, Int32);
322     scilab_fill_add(Int16, UInt32, M_M, Int16, UInt32, UInt32);
323     scilab_fill_add(Int16, Int64, M_M, Int16, Int64, Int64);
324     scilab_fill_add(Int16, UInt64, M_M, Int16, UInt64, UInt64);
325     scilab_fill_add(Int16, Bool, M_M, Int16, Bool, Int16);
326     scilab_fill_add(Int16, Empty, M_M, Int16, Double, Int16);
327
328     //Matrix + Scalar
329     scilab_fill_add(Int16, ScalarDouble, M_S, Int16, Double, Int16);
330     scilab_fill_add(Int16, ScalarInt8, M_S, Int16, Int8, Int16);
331     scilab_fill_add(Int16, ScalarUInt8, M_S, Int16, UInt8, UInt16);
332     scilab_fill_add(Int16, ScalarInt16, M_S, Int16, Int16, Int16);
333     scilab_fill_add(Int16, ScalarUInt16, M_S, Int16, UInt16, UInt16);
334     scilab_fill_add(Int16, ScalarInt32, M_S, Int16, Int32, Int32);
335     scilab_fill_add(Int16, ScalarUInt32, M_S, Int16, UInt32, UInt32);
336     scilab_fill_add(Int16, ScalarInt64, M_S, Int16, Int64, Int64);
337     scilab_fill_add(Int16, ScalarUInt64, M_S, Int16, UInt64, UInt64);
338     scilab_fill_add(Int16, ScalarBool, M_S, Int16, Bool, Int16);
339
340     //Scalar + Matrix
341     scilab_fill_add(ScalarInt16, Double, S_M, Int16, Double, Int16);
342     scilab_fill_add(ScalarInt16, Int8, S_M, Int16, Int8, Int16);
343     scilab_fill_add(ScalarInt16, UInt8, S_M, Int16, UInt8, UInt16);
344     scilab_fill_add(ScalarInt16, Int16, S_M, Int16, Int16, Int16);
345     scilab_fill_add(ScalarInt16, UInt16, S_M, Int16, UInt16, UInt16);
346     scilab_fill_add(ScalarInt16, Int32, S_M, Int16, Int32, Int32);
347     scilab_fill_add(ScalarInt16, UInt32, S_M, Int16, UInt32, UInt32);
348     scilab_fill_add(ScalarInt16, Int64, S_M, Int16, Int64, Int64);
349     scilab_fill_add(ScalarInt16, UInt64, S_M, Int16, UInt64, UInt64);
350     scilab_fill_add(ScalarInt16, Bool, S_M, Int16, Bool, Int16);
351     scilab_fill_add(ScalarInt16, Empty, M_M, Int16, Double, Int16);
352
353     //Scalar + Scalar
354     scilab_fill_add(ScalarInt16, ScalarDouble, S_S, Int16, Double, Int16);
355     scilab_fill_add(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Int16);
356     scilab_fill_add(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, UInt16);
357     scilab_fill_add(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Int16);
358     scilab_fill_add(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, UInt16);
359     scilab_fill_add(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Int32);
360     scilab_fill_add(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, UInt32);
361     scilab_fill_add(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Int64);
362     scilab_fill_add(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, UInt64);
363     scilab_fill_add(ScalarInt16, ScalarBool, S_S, Int16, Bool, Int16);
364
365     //UInt16
366     //Matrix + Matrix
367     scilab_fill_add(UInt16, Double, M_M, UInt16, Double, UInt16);
368     scilab_fill_add(UInt16, Int8, M_M, UInt16, Int8, UInt16);
369     scilab_fill_add(UInt16, UInt8, M_M, UInt16, UInt8, UInt16);
370     scilab_fill_add(UInt16, Int16, M_M, UInt16, Int16, UInt16);
371     scilab_fill_add(UInt16, UInt16, M_M, UInt16, UInt16, UInt16);
372     scilab_fill_add(UInt16, Int32, M_M, UInt16, Int32, UInt32);
373     scilab_fill_add(UInt16, UInt32, M_M, UInt16, UInt32, UInt32);
374     scilab_fill_add(UInt16, Int64, M_M, UInt16, Int64, UInt64);
375     scilab_fill_add(UInt16, UInt64, M_M, UInt16, UInt64, UInt64);
376     scilab_fill_add(UInt16, Bool, M_M, UInt16, Bool, UInt16);
377     scilab_fill_add(UInt16, Empty, M_M, UInt16, Double, UInt16);
378
379     //Matrix + Scalar
380     scilab_fill_add(UInt16, ScalarDouble, M_S, UInt16, Double, UInt16);
381     scilab_fill_add(UInt16, ScalarInt8, M_S, UInt16, Int8, UInt16);
382     scilab_fill_add(UInt16, ScalarUInt8, M_S, UInt16, UInt8, UInt16);
383     scilab_fill_add(UInt16, ScalarInt16, M_S, UInt16, Int16, UInt16);
384     scilab_fill_add(UInt16, ScalarUInt16, M_S, UInt16, UInt16, UInt16);
385     scilab_fill_add(UInt16, ScalarInt32, M_S, UInt16, Int32, UInt32);
386     scilab_fill_add(UInt16, ScalarUInt32, M_S, UInt16, UInt32, UInt32);
387     scilab_fill_add(UInt16, ScalarInt64, M_S, UInt16, Int64, UInt64);
388     scilab_fill_add(UInt16, ScalarUInt64, M_S, UInt16, UInt64, UInt64);
389     scilab_fill_add(UInt16, ScalarBool, M_S, UInt16, Bool, UInt16);
390
391     //Scalar + Matrix
392     scilab_fill_add(ScalarUInt16, Double, S_M, UInt16, Double, UInt16);
393     scilab_fill_add(ScalarUInt16, Int8, S_M, UInt16, Int8, UInt16);
394     scilab_fill_add(ScalarUInt16, UInt8, S_M, UInt16, UInt8, UInt16);
395     scilab_fill_add(ScalarUInt16, Int16, S_M, UInt16, Int16, UInt16);
396     scilab_fill_add(ScalarUInt16, UInt16, S_M, UInt16, UInt16, UInt16);
397     scilab_fill_add(ScalarUInt16, Int32, S_M, UInt16, Int32, UInt32);
398     scilab_fill_add(ScalarUInt16, UInt32, S_M, UInt16, UInt32, UInt32);
399     scilab_fill_add(ScalarUInt16, Int64, S_M, UInt16, Int64, UInt64);
400     scilab_fill_add(ScalarUInt16, UInt64, S_M, UInt16, UInt64, UInt64);
401     scilab_fill_add(ScalarUInt16, Bool, S_M, UInt16, Bool, UInt16);
402     scilab_fill_add(ScalarUInt16, Empty, S_M, UInt16, Double, UInt16);
403
404     //Scalar + Scalar
405     scilab_fill_add(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, UInt16);
406     scilab_fill_add(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, UInt16);
407     scilab_fill_add(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, UInt16);
408     scilab_fill_add(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, UInt16);
409     scilab_fill_add(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, UInt16);
410     scilab_fill_add(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, UInt32);
411     scilab_fill_add(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, UInt32);
412     scilab_fill_add(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, UInt64);
413     scilab_fill_add(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, UInt64);
414     scilab_fill_add(ScalarUInt16, ScalarBool, S_S, UInt16, Bool, UInt16);
415
416     //Int32
417     //Matrix + Matrix
418     scilab_fill_add(Int32, Double, M_M, Int32, Double, Int32);
419     scilab_fill_add(Int32, Int8, M_M, Int32, Int8, Int32);
420     scilab_fill_add(Int32, UInt8, M_M, Int32, UInt8, UInt32);
421     scilab_fill_add(Int32, Int16, M_M, Int32, Int16, Int32);
422     scilab_fill_add(Int32, UInt16, M_M, Int32, UInt16, UInt32);
423     scilab_fill_add(Int32, Int32, M_M, Int32, Int32, Int32);
424     scilab_fill_add(Int32, UInt32, M_M, Int32, UInt32, UInt32);
425     scilab_fill_add(Int32, Int64, M_M, Int32, Int64, Int64);
426     scilab_fill_add(Int32, UInt64, M_M, Int32, UInt64, UInt64);
427     scilab_fill_add(Int32, Bool, M_M, Int32, Bool, Int32);
428     scilab_fill_add(Int32, Empty, M_M, Int32, Double, Int32);
429
430     //Matrix + Scalar
431     scilab_fill_add(Int32, ScalarDouble, M_S, Int32, Double, Int32);
432     scilab_fill_add(Int32, ScalarInt8, M_S, Int32, Int8, Int32);
433     scilab_fill_add(Int32, ScalarUInt8, M_S, Int32, UInt8, UInt32);
434     scilab_fill_add(Int32, ScalarInt16, M_S, Int32, Int16, Int32);
435     scilab_fill_add(Int32, ScalarUInt16, M_S, Int32, UInt16, UInt32);
436     scilab_fill_add(Int32, ScalarInt32, M_S, Int32, Int32, Int32);
437     scilab_fill_add(Int32, ScalarUInt32, M_S, Int32, UInt32, UInt32);
438     scilab_fill_add(Int32, ScalarInt64, M_S, Int32, Int64, Int64);
439     scilab_fill_add(Int32, ScalarUInt64, M_S, Int32, UInt64, UInt64);
440     scilab_fill_add(Int32, ScalarBool, M_S, Int32, Bool, Int32);
441
442     //Scalar + Matrix
443     scilab_fill_add(ScalarInt32, Double, S_M, Int32, Double, Int32);
444     scilab_fill_add(ScalarInt32, Int8, S_M, Int32, Int8, Int32);
445     scilab_fill_add(ScalarInt32, UInt8, S_M, Int32, UInt8, UInt32);
446     scilab_fill_add(ScalarInt32, Int16, S_M, Int32, Int16, Int32);
447     scilab_fill_add(ScalarInt32, UInt16, S_M, Int32, UInt16, UInt32);
448     scilab_fill_add(ScalarInt32, Int32, S_M, Int32, Int32, Int32);
449     scilab_fill_add(ScalarInt32, UInt32, S_M, Int32, UInt32, UInt32);
450     scilab_fill_add(ScalarInt32, Int64, S_M, Int32, Int64, Int64);
451     scilab_fill_add(ScalarInt32, UInt64, S_M, Int32, UInt64, UInt64);
452     scilab_fill_add(ScalarInt32, Bool, S_M, Int32, Bool, Int32);
453     scilab_fill_add(ScalarInt32, Empty, M_M, Int32, Double, Int32);
454
455     //Scalar + Scalar
456     scilab_fill_add(ScalarInt32, ScalarDouble, S_S, Int32, Double, Int32);
457     scilab_fill_add(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Int32);
458     scilab_fill_add(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, UInt32);
459     scilab_fill_add(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Int32);
460     scilab_fill_add(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, UInt32);
461     scilab_fill_add(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Int32);
462     scilab_fill_add(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, UInt32);
463     scilab_fill_add(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Int64);
464     scilab_fill_add(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, UInt64);
465     scilab_fill_add(ScalarInt32, ScalarBool, S_S, Int32, Bool, Int32);
466
467     //UInt32
468     //Matrix + Matrix
469     scilab_fill_add(UInt32, Double, M_M, UInt32, Double, UInt32);
470     scilab_fill_add(UInt32, Int8, M_M, UInt32, Int8, UInt32);
471     scilab_fill_add(UInt32, UInt8, M_M, UInt32, UInt8, UInt32);
472     scilab_fill_add(UInt32, Int16, M_M, UInt32, Int16, UInt32);
473     scilab_fill_add(UInt32, UInt16, M_M, UInt32, UInt16, UInt32);
474     scilab_fill_add(UInt32, Int32, M_M, UInt32, Int32, UInt32);
475     scilab_fill_add(UInt32, UInt32, M_M, UInt32, UInt32, UInt32);
476     scilab_fill_add(UInt32, Int64, M_M, UInt32, Int64, UInt64);
477     scilab_fill_add(UInt32, UInt64, M_M, UInt32, UInt64, UInt64);
478     scilab_fill_add(UInt32, Bool, M_M, UInt32, Bool, UInt32);
479     scilab_fill_add(UInt32, Empty, M_M, UInt32, Double, UInt32);
480
481     //Matrix + Scalar
482     scilab_fill_add(UInt32, ScalarDouble, M_S, UInt32, Double, UInt32);
483     scilab_fill_add(UInt32, ScalarInt8, M_S, UInt32, Int8, UInt32);
484     scilab_fill_add(UInt32, ScalarUInt8, M_S, UInt32, UInt8, UInt32);
485     scilab_fill_add(UInt32, ScalarInt16, M_S, UInt32, Int16, UInt32);
486     scilab_fill_add(UInt32, ScalarUInt16, M_S, UInt32, UInt16, UInt32);
487     scilab_fill_add(UInt32, ScalarInt32, M_S, UInt32, Int32, UInt32);
488     scilab_fill_add(UInt32, ScalarUInt32, M_S, UInt32, UInt32, UInt32);
489     scilab_fill_add(UInt32, ScalarInt64, M_S, UInt32, Int64, UInt64);
490     scilab_fill_add(UInt32, ScalarUInt64, M_S, UInt32, UInt64, UInt64);
491     scilab_fill_add(UInt32, ScalarBool, M_S, UInt32, Bool, UInt32);
492
493     //Scalar + Matrix
494     scilab_fill_add(ScalarUInt32, Double, S_M, UInt32, Double, UInt32);
495     scilab_fill_add(ScalarUInt32, Int8, S_M, UInt32, Int8, UInt32);
496     scilab_fill_add(ScalarUInt32, UInt8, S_M, UInt32, UInt8, UInt32);
497     scilab_fill_add(ScalarUInt32, Int16, S_M, UInt32, Int16, UInt32);
498     scilab_fill_add(ScalarUInt32, UInt16, S_M, UInt32, UInt16, UInt32);
499     scilab_fill_add(ScalarUInt32, Int32, S_M, UInt32, Int32, UInt32);
500     scilab_fill_add(ScalarUInt32, UInt32, S_M, UInt32, UInt32, UInt32);
501     scilab_fill_add(ScalarUInt32, Int64, S_M, UInt32, Int64, UInt64);
502     scilab_fill_add(ScalarUInt32, UInt64, S_M, UInt32, UInt64, UInt64);
503     scilab_fill_add(ScalarUInt32, Bool, S_M, UInt32, Bool, UInt32);
504     scilab_fill_add(ScalarUInt32, Empty, S_M, UInt32, Double, UInt32);
505
506     //Scalar + Scalar
507     scilab_fill_add(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, UInt32);
508     scilab_fill_add(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, UInt32);
509     scilab_fill_add(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, UInt32);
510     scilab_fill_add(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, UInt32);
511     scilab_fill_add(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, UInt32);
512     scilab_fill_add(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, UInt32);
513     scilab_fill_add(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, UInt32);
514     scilab_fill_add(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, UInt64);
515     scilab_fill_add(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, UInt64);
516     scilab_fill_add(ScalarUInt32, ScalarBool, S_S, UInt32, Bool, UInt32);
517
518     //Int64
519     //Matrix + Matrix
520     scilab_fill_add(Int64, Double, M_M, Int64, Double, Int64);
521     scilab_fill_add(Int64, Int8, M_M, Int64, Int8, Int64);
522     scilab_fill_add(Int64, UInt8, M_M, Int64, UInt8, UInt64);
523     scilab_fill_add(Int64, Int16, M_M, Int64, Int16, Int64);
524     scilab_fill_add(Int64, UInt16, M_M, Int64, UInt16, UInt64);
525     scilab_fill_add(Int64, Int32, M_M, Int64, Int32, Int64);
526     scilab_fill_add(Int64, UInt32, M_M, Int64, UInt32, UInt64);
527     scilab_fill_add(Int64, Int64, M_M, Int64, Int64, Int64);
528     scilab_fill_add(Int64, UInt64, M_M, Int64, UInt64, UInt64);
529     scilab_fill_add(Int64, Bool, M_M, Int64, Bool, Int64);
530     scilab_fill_add(Int64, Empty, M_M, Int64, Double, Int64);
531
532     //Matrix + Scalar
533     scilab_fill_add(Int64, ScalarDouble, M_S, Int64, Double, Int64);
534     scilab_fill_add(Int64, ScalarInt8, M_S, Int64, Int8, Int64);
535     scilab_fill_add(Int64, ScalarUInt8, M_S, Int64, UInt8, UInt64);
536     scilab_fill_add(Int64, ScalarInt16, M_S, Int64, Int16, Int64);
537     scilab_fill_add(Int64, ScalarUInt16, M_S, Int64, UInt16, UInt64);
538     scilab_fill_add(Int64, ScalarInt32, M_S, Int64, Int32, Int64);
539     scilab_fill_add(Int64, ScalarUInt32, M_S, Int64, UInt32, UInt64);
540     scilab_fill_add(Int64, ScalarInt64, M_S, Int64, Int64, Int64);
541     scilab_fill_add(Int64, ScalarUInt64, M_S, Int64, UInt64, UInt64);
542     scilab_fill_add(Int64, ScalarBool, M_S, Int64, Bool, Int64);
543
544     //Scalar + Matrix
545     scilab_fill_add(ScalarInt64, Double, S_M, Int64, Double, Int64);
546     scilab_fill_add(ScalarInt64, Int8, S_M, Int64, Int8, Int64);
547     scilab_fill_add(ScalarInt64, UInt8, S_M, Int64, UInt8, UInt64);
548     scilab_fill_add(ScalarInt64, Int16, S_M, Int64, Int16, Int64);
549     scilab_fill_add(ScalarInt64, UInt16, S_M, Int64, UInt16, UInt64);
550     scilab_fill_add(ScalarInt64, Int32, S_M, Int64, Int32, Int64);
551     scilab_fill_add(ScalarInt64, UInt32, S_M, Int64, UInt32, UInt64);
552     scilab_fill_add(ScalarInt64, Int64, S_M, Int64, Int64, Int64);
553     scilab_fill_add(ScalarInt64, UInt64, S_M, Int64, UInt64, UInt64);
554     scilab_fill_add(ScalarInt64, Bool, S_M, Int64, Bool, Int64);
555     scilab_fill_add(ScalarInt64, Empty, M_M, Int64, Double, Int64);
556
557     //Scalar + Scalar
558     scilab_fill_add(ScalarInt64, ScalarDouble, S_S, Int64, Double, Int64);
559     scilab_fill_add(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Int64);
560     scilab_fill_add(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, UInt64);
561     scilab_fill_add(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Int64);
562     scilab_fill_add(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, UInt64);
563     scilab_fill_add(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Int64);
564     scilab_fill_add(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, UInt64);
565     scilab_fill_add(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Int64);
566     scilab_fill_add(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, UInt64);
567     scilab_fill_add(ScalarInt64, ScalarBool, S_S, Int64, Bool, Int64);
568
569     //UInt64
570     //Matrix + Matrix
571     scilab_fill_add(UInt64, Double, M_M, UInt64, Double, UInt64);
572     scilab_fill_add(UInt64, Int8, M_M, UInt64, Int8, UInt64);
573     scilab_fill_add(UInt64, UInt8, M_M, UInt64, UInt8, UInt64);
574     scilab_fill_add(UInt64, Int16, M_M, UInt64, Int16, UInt64);
575     scilab_fill_add(UInt64, UInt16, M_M, UInt64, UInt16, UInt64);
576     scilab_fill_add(UInt64, Int32, M_M, UInt64, Int32, UInt64);
577     scilab_fill_add(UInt64, UInt32, M_M, UInt64, UInt32, UInt64);
578     scilab_fill_add(UInt64, Int64, M_M, UInt64, Int64, UInt64);
579     scilab_fill_add(UInt64, UInt64, M_M, UInt64, UInt64, UInt64);
580     scilab_fill_add(UInt64, Bool, M_M, UInt64, Bool, UInt64);
581     scilab_fill_add(UInt64, Empty, M_M, UInt64, Double, UInt64);
582
583     //Matrix + Scalar
584     scilab_fill_add(UInt64, ScalarDouble, M_S, UInt64, Double, UInt64);
585     scilab_fill_add(UInt64, ScalarInt8, M_S, UInt64, Int8, UInt64);
586     scilab_fill_add(UInt64, ScalarUInt8, M_S, UInt64, UInt8, UInt64);
587     scilab_fill_add(UInt64, ScalarInt16, M_S, UInt64, Int16, UInt64);
588     scilab_fill_add(UInt64, ScalarUInt16, M_S, UInt64, UInt16, UInt64);
589     scilab_fill_add(UInt64, ScalarInt32, M_S, UInt64, Int32, UInt64);
590     scilab_fill_add(UInt64, ScalarUInt32, M_S, UInt64, UInt32, UInt64);
591     scilab_fill_add(UInt64, ScalarInt64, M_S, UInt64, Int64, UInt64);
592     scilab_fill_add(UInt64, ScalarUInt64, M_S, UInt64, UInt64, UInt64);
593     scilab_fill_add(UInt64, ScalarBool, M_S, UInt64, Bool, UInt64);
594
595     //Scalar + Matrix
596     scilab_fill_add(ScalarUInt64, Double, S_M, UInt64, Double, UInt64);
597     scilab_fill_add(ScalarUInt64, Int8, S_M, UInt64, Int8, UInt64);
598     scilab_fill_add(ScalarUInt64, UInt8, S_M, UInt64, UInt8, UInt64);
599     scilab_fill_add(ScalarUInt64, Int16, S_M, UInt64, Int16, UInt64);
600     scilab_fill_add(ScalarUInt64, UInt16, S_M, UInt64, UInt16, UInt64);
601     scilab_fill_add(ScalarUInt64, Int32, S_M, UInt64, Int32, UInt64);
602     scilab_fill_add(ScalarUInt64, UInt32, S_M, UInt64, UInt32, UInt64);
603     scilab_fill_add(ScalarUInt64, Int64, S_M, UInt64, Int64, UInt64);
604     scilab_fill_add(ScalarUInt64, UInt64, S_M, UInt64, UInt64, UInt64);
605     scilab_fill_add(ScalarUInt64, Bool, S_M, UInt64, Bool, UInt64);
606     scilab_fill_add(ScalarUInt64, Empty, S_M, UInt64, Double, UInt64);
607
608     //Scalar + Scalar
609     scilab_fill_add(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, UInt64);
610     scilab_fill_add(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, UInt64);
611     scilab_fill_add(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, UInt64);
612     scilab_fill_add(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, UInt64);
613     scilab_fill_add(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, UInt64);
614     scilab_fill_add(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, UInt64);
615     scilab_fill_add(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, UInt64);
616     scilab_fill_add(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, UInt64);
617     scilab_fill_add(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, UInt64);
618     scilab_fill_add(ScalarUInt64, ScalarBool, S_S, UInt64, Bool, UInt64);
619
620     //Bool
621     //Matrix + Matrix
622     scilab_fill_add(Bool, Double, M_M, Bool, Double, Double);
623     scilab_fill_add(Bool, Int8, M_M, Bool, Int8, Int8);
624     scilab_fill_add(Bool, UInt8, M_M, Bool, UInt8, UInt8);
625     scilab_fill_add(Bool, Int16, M_M, Bool, Int16, Int16);
626     scilab_fill_add(Bool, UInt16, M_M, Bool, UInt16, UInt16);
627     scilab_fill_add(Bool, Int32, M_M, Bool, Int32, Int32);
628     scilab_fill_add(Bool, UInt32, M_M, Bool, UInt32, UInt32);
629     scilab_fill_add(Bool, Int64, M_M, Bool, Int64, Int64);
630     scilab_fill_add(Bool, UInt64, M_M, Bool, UInt64, UInt64);
631     scilab_fill_add(Bool, Bool, M_M, Bool, Bool, Bool);
632     scilab_fill_add(Bool, Empty, M_M, Bool, Double, Double);
633
634     //Matrix + Scalar
635     scilab_fill_add(Bool, ScalarDouble, M_S, Bool, Double, Double);
636     scilab_fill_add(Bool, ScalarInt8, M_S, Bool, Int8, Int8);
637     scilab_fill_add(Bool, ScalarUInt8, M_S, Bool, UInt8, UInt8);
638     scilab_fill_add(Bool, ScalarInt16, M_S, Bool, Int16, Int16);
639     scilab_fill_add(Bool, ScalarUInt16, M_S, Bool, UInt16, UInt16);
640     scilab_fill_add(Bool, ScalarInt32, M_S, Bool, Int32, Int32);
641     scilab_fill_add(Bool, ScalarUInt32, M_S, Bool, UInt32, UInt32);
642     scilab_fill_add(Bool, ScalarInt64, M_S, Bool, Int64, Int64);
643     scilab_fill_add(Bool, ScalarUInt64, M_S, Bool, UInt64, UInt64);
644     scilab_fill_add(Bool, ScalarBool, M_S, Bool, Bool, Bool);
645
646     //Scalar + Matrix
647     scilab_fill_add(ScalarBool, Double, S_M, Bool, Double, Double);
648     scilab_fill_add(ScalarBool, Int8, S_M, Bool, Int8, Int8);
649     scilab_fill_add(ScalarBool, UInt8, S_M, Bool, UInt8, UInt8);
650     scilab_fill_add(ScalarBool, Int16, S_M, Bool, Int16, Int16);
651     scilab_fill_add(ScalarBool, UInt16, S_M, Bool, UInt16, UInt16);
652     scilab_fill_add(ScalarBool, Int32, S_M, Bool, Int32, Int32);
653     scilab_fill_add(ScalarBool, UInt32, S_M, Bool, UInt32, UInt32);
654     scilab_fill_add(ScalarBool, Int64, S_M, Bool, Int64, Int64);
655     scilab_fill_add(ScalarBool, UInt64, S_M, Bool, UInt64, UInt64);
656     scilab_fill_add(ScalarBool, Bool, S_M, Bool, Bool, Bool);
657     scilab_fill_add(ScalarBool, Empty, M_M, Bool, Double, Double);
658
659     //Scalar + Scalar
660     scilab_fill_add(ScalarBool, ScalarDouble, S_S, Bool, Double, Double);
661     scilab_fill_add(ScalarBool, ScalarInt8, S_S, Bool, Int8, Int8);
662     scilab_fill_add(ScalarBool, ScalarUInt8, S_S, Bool, UInt8, UInt8);
663     scilab_fill_add(ScalarBool, ScalarInt16, S_S, Bool, Int16, Int16);
664     scilab_fill_add(ScalarBool, ScalarUInt16, S_S, Bool, UInt16, UInt16);
665     scilab_fill_add(ScalarBool, ScalarInt32, S_S, Bool, Int32, Int32);
666     scilab_fill_add(ScalarBool, ScalarUInt32, S_S, Bool, UInt32, UInt32);
667     scilab_fill_add(ScalarBool, ScalarInt64, S_S, Bool, Int64, Int64);
668     scilab_fill_add(ScalarBool, ScalarUInt64, S_S, Bool, UInt64, UInt64);
669     scilab_fill_add(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
670
671     //String
672     scilab_fill_add(String, String, M_M, String, String, String);
673     scilab_fill_add(String, ScalarString, M_S, String, String, String);
674     scilab_fill_add(String, Empty, M_E, String, Double, String);
675
676     scilab_fill_add(ScalarString, String, S_M, String, String, String);
677     scilab_fill_add(ScalarString, ScalarString, S_S, String, String, String);
678     scilab_fill_add(ScalarString, Empty, S_E, String, Double, String);
679
680     //Identity
681     scilab_fill_add(Identity, Double, I_M, Double, Double, Double);
682     scilab_fill_add(Identity, DoubleComplex, I_MC, Double, Double, Double);
683     scilab_fill_add(Identity, ScalarDouble, I_S, Double, Double, Double);
684     scilab_fill_add(Identity, ScalarDoubleComplex, I_SC, Double, Double, Double);
685     scilab_fill_add(Identity, Identity, I_I, Double, Double, Double);
686     scilab_fill_add(Identity, IdentityComplex, I_IC, Double, Double, Double);
687     scilab_fill_add(Identity, Empty, I_E, Double, Double, Double);
688
689     scilab_fill_add(Identity, Polynom, M_M, Double, Polynom, Polynom);
690     scilab_fill_add(Identity, PolynomComplex, M_M, Double, Polynom, Polynom);
691     scilab_fill_add(Identity, ScalarPolynom, M_M, Double, Polynom, Polynom);
692     scilab_fill_add(Identity, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
693     scilab_fill_add(Identity, Sparse, M_M, Double, Sparse, Sparse);
694     scilab_fill_add(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
695
696     scilab_fill_add(IdentityComplex, Double, IC_M, Double, Double, Double);
697     scilab_fill_add(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
698     scilab_fill_add(IdentityComplex, ScalarDouble, IC_S, Double, Double, Double);
699     scilab_fill_add(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Double);
700     scilab_fill_add(IdentityComplex, Identity, IC_I, Double, Double, Double);
701     scilab_fill_add(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Double);
702     scilab_fill_add(IdentityComplex, Empty, IC_E, Double, Double, Double);
703
704     scilab_fill_add(IdentityComplex, Polynom, M_M, Double, Polynom, Polynom);
705     scilab_fill_add(IdentityComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
706     scilab_fill_add(IdentityComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
707     scilab_fill_add(IdentityComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
708     scilab_fill_add(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
709     scilab_fill_add(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
710
711     //Polynom
712
713     //poly + poly
714     scilab_fill_add(Polynom, Polynom, M_M, Polynom, Polynom, Polynom);
715     scilab_fill_add(Polynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
716     scilab_fill_add(PolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
717     scilab_fill_add(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
718
719     //poly + scalar poly
720     scilab_fill_add(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
721     scilab_fill_add(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
722     scilab_fill_add(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
723     scilab_fill_add(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
724
725     //poly + double
726     scilab_fill_add(Polynom, Double, M_M, Polynom, Double, Polynom);
727     scilab_fill_add(Polynom, DoubleComplex, M_M, Polynom, Double, Polynom);
728     scilab_fill_add(PolynomComplex, Double, M_M, Polynom, Double, Polynom);
729     scilab_fill_add(PolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
730
731     //poly + scalar double
732     scilab_fill_add(Polynom, ScalarDouble, M_M, Polynom, Double, Polynom);
733     scilab_fill_add(Polynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
734     scilab_fill_add(PolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
735     scilab_fill_add(PolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
736
737     //poly + []
738     scilab_fill_add(Polynom, Empty, M_M, Polynom, Double, Polynom);
739     scilab_fill_add(PolynomComplex, Empty, M_M, Polynom, Double, Polynom);
740
741     //poly + eye
742     scilab_fill_add(Polynom, Identity, M_M, Polynom, Double, Polynom);
743     scilab_fill_add(Polynom, IdentityComplex, M_M, Polynom, Double, Polynom);
744     scilab_fill_add(PolynomComplex, Identity, M_M, Polynom, Double, Polynom);
745     scilab_fill_add(PolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
746
747     //scalar poly + poly
748     scilab_fill_add(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Polynom);
749     scilab_fill_add(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
750     scilab_fill_add(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
751     scilab_fill_add(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
752
753     //scalar poly + scalar poly
754     scilab_fill_add(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
755     scilab_fill_add(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
756     scilab_fill_add(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
757     scilab_fill_add(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
758
759     //scalar poly + double
760     scilab_fill_add(ScalarPolynom, Double, M_M, Polynom, Double, Polynom);
761     scilab_fill_add(ScalarPolynom, DoubleComplex, M_M, Polynom, Double, Polynom);
762     scilab_fill_add(ScalarPolynomComplex, Double, M_M, Polynom, Double, Polynom);
763     scilab_fill_add(ScalarPolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
764
765     //scalar poly + scalar double
766     scilab_fill_add(ScalarPolynom, ScalarDouble, M_M, Polynom, Double, Polynom);
767     scilab_fill_add(ScalarPolynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
768     scilab_fill_add(ScalarPolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
769     scilab_fill_add(ScalarPolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
770
771     //scalar poly + []
772     scilab_fill_add(ScalarPolynom, Empty, M_M, Polynom, Double, Polynom);
773     scilab_fill_add(ScalarPolynomComplex, Empty, M_M, Polynom, Double, Polynom);
774
775     //scalar poly + eye
776     scilab_fill_add(ScalarPolynom, Identity, M_M, Polynom, Double, Polynom);
777     scilab_fill_add(ScalarPolynom, IdentityComplex, M_M, Polynom, Double, Polynom);
778     scilab_fill_add(ScalarPolynomComplex, Identity, M_M, Polynom, Double, Polynom);
779     scilab_fill_add(ScalarPolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
780
781     //Sparse
782     scilab_fill_add(Sparse, Sparse, M_M, Sparse, Sparse, Sparse);
783     scilab_fill_add(Sparse, SparseComplex, M_M, Sparse, Sparse, Sparse);
784     scilab_fill_add(Sparse, Double, M_M, Sparse, Double, Double);
785     scilab_fill_add(Sparse, DoubleComplex, M_M, Sparse, Double, Double);
786     scilab_fill_add(Sparse, ScalarDouble, M_M, Sparse, Double, Double);
787     scilab_fill_add(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Double);
788
789     scilab_fill_add(Sparse, Empty, M_M, Sparse, Double, Sparse);
790     scilab_fill_add(Sparse, Identity, M_M, Sparse, Double, Sparse);
791     scilab_fill_add(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
792
793     scilab_fill_add(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
794     scilab_fill_add(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
795     scilab_fill_add(SparseComplex, Double, M_M, Sparse, Double, Double);
796     scilab_fill_add(SparseComplex, DoubleComplex, M_M, Sparse, Double, Double);
797     scilab_fill_add(SparseComplex, ScalarDouble, M_M, Sparse, Double, Double);
798     scilab_fill_add(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Double);
799
800     scilab_fill_add(SparseComplex, Empty, M_M, Sparse, Double, Sparse);
801     scilab_fill_add(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
802     scilab_fill_add(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
803
804 #undef scilab_fill_add
805 }
806
807 InternalType *GenericPlus(InternalType *_pLeftOperand, InternalType *_pRightOperand)
808 {
809     InternalType *pResult = NULL;
810
811     add_function add = pAddfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
812     if (add)
813     {
814         pResult = add(_pLeftOperand, _pRightOperand);
815         if (pResult)
816         {
817             return pResult;
818         }
819     }
820
821     /*
822     ** Default case : Return NULL will Call Overloading.
823     */
824     return NULL;
825 }
826
827 int AddSparseToSparse(Sparse* sp1, Sparse* sp2, Sparse** pSpRes)
828 {
829     //check scalar hidden in a sparse ;)
830     if (sp1->getRows() == 1 && sp1->getCols() == 1)
831     {
832         //do scalar + sp
833         Double* pDbl = NULL;
834         if (sp1->isComplex())
835         {
836             std::complex<double> dbl = sp1->getImg(0, 0);
837             pDbl = new Double(dbl.real(), dbl.imag());
838         }
839         else
840         {
841             pDbl = new Double(sp1->get(0, 0));
842         }
843
844         AddSparseToDouble(sp2, pDbl, (GenericType**)pSpRes);
845         delete pDbl;
846         return 0;
847     }
848
849     if (sp2->getRows() == 1 && sp2->getCols() == 1)
850     {
851         //do sp + scalar
852         Double* pDbl = NULL;
853         if (sp2->isComplex())
854         {
855             std::complex<double> dbl = sp2->getImg(0, 0);
856             pDbl = new Double(dbl.real(), dbl.imag());
857         }
858         else
859         {
860             pDbl = new Double(sp2->get(0, 0));
861         }
862
863         AddSparseToDouble(sp1, pDbl, (GenericType**)pSpRes);
864         delete pDbl;
865         return 0;
866     }
867
868     if (sp1->getRows() != sp2->getRows() || sp1->getCols() != sp2->getCols())
869     {
870         //dimensions not match
871         return 1;
872     }
873
874     if (sp1->nonZeros() == 0)
875     {
876         //sp([]) + sp
877         *pSpRes = new Sparse(*sp2);
878         return 0;
879     }
880
881     if (sp2->nonZeros() == 0)
882     {
883         //sp + sp([])
884         *pSpRes = new Sparse(*sp1);
885         return 0;
886     }
887
888     //copy sp1 in pSpRes
889     *pSpRes = sp1->add(*sp2);
890     return 0;
891 }
892
893 int AddSparseToDouble(Sparse* sp, Double* d, GenericType** pDRes)
894 {
895     int iOne = 1; //fortran
896     bool bComplex1 = sp->isComplex();
897     bool bComplex2 = d->isComplex();
898
899     if (d->isIdentity())
900     {
901         //convert to sp
902         Sparse* pS = new Sparse(sp->getRows(), sp->getCols(), d->isComplex());
903         if (pS->isComplex())
904         {
905             for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
906             {
907                 pS->set(i, i, std::complex<double>(d->get(0), d->getImg(0)));
908             }
909         }
910         else
911         {
912             for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
913             {
914                 pS->set(i, i, d->get(0));
915             }
916         }
917
918         AddSparseToSparse(sp, pS, (Sparse**)pDRes);
919         delete pS;
920         return 0;
921     }
922
923     if (sp->isScalar() && d->isScalar())
924     {
925         //sp + d
926         Double* pRes = (Double*)d->clone();
927         pRes->setComplex(bComplex1 | bComplex2);
928         if (bComplex1)
929         {
930             std::complex<double> dbl = sp->getImg(0, 0);
931             pRes->set(0, pRes->get(0) + dbl.real());
932             pRes->setImg(0, pRes->getImg(0) + dbl.imag());
933         }
934         else
935         {
936             pRes->set(0, pRes->get(0) + sp->get(0, 0));
937         }
938
939         *pDRes = pRes;
940         return 0;
941     }
942
943     if (d->isScalar())
944     {
945         //SP + d
946         Double* pRes = new Double(sp->getRows(), sp->getCols(), bComplex1 | bComplex2);
947         int iSize = sp->getSize();
948         double dblVal = d->get(0);
949         C2F(dset)(&iSize, &dblVal, pRes->get(), &iOne);
950         if (bComplex2)
951         {
952             double dblValI = d->getImg(0);
953             C2F(dset)(&iSize, &dblValI, pRes->getImg(), &iOne);
954         }
955         else if (bComplex1)
956         {
957             //initialize imag part at 0
958             double dblValI = 0;
959             C2F(dset)(&iSize, &dblValI, pRes->getImg(), &iOne);
960         }
961
962         int nonZeros = static_cast<int>(sp->nonZeros());
963         int* pRows = new int[nonZeros * 2];
964         sp->outputRowCol(pRows);
965         int* pCols = pRows + nonZeros;
966
967         if (bComplex1)
968         {
969             for (int i = 0 ; i < nonZeros ; i++)
970             {
971                 int iRow = static_cast<int>(pRows[i]) - 1;
972                 int iCol = static_cast<int>(pCols[i]) - 1;
973                 std::complex<double> dbl = sp->getImg(iRow, iCol);
974                 pRes->set(iRow, iCol, pRes->get(iRow, iCol) + dbl.real());
975                 pRes->setImg(iRow, iCol, pRes->getImg(iRow, iCol) + dbl.imag());
976             }
977         }
978         else
979         {
980             for (int i = 0 ; i < nonZeros ; i++)
981             {
982                 int iRow = static_cast<int>(pRows[i]) - 1;
983                 int iCol = static_cast<int>(pCols[i]) - 1;
984                 pRes->set(iRow, iCol, pRes->get(iRow, iCol) + sp->get(iRow, iCol));
985             }
986         }
987         *pDRes = pRes;
988
989         //clear
990         delete[] pRows;
991
992         return 0;
993     }
994
995     if (sp->isScalar())
996     {
997         //sp + D
998         Double* pRes = (Double*)d->clone();
999         pRes->setComplex(bComplex1 | bComplex2);
1000
1001         if (bComplex1)
1002         {
1003             double* pReal = pRes->get();
1004             double* pImg = pRes->getImg();
1005             for (int i = 0 ; i < pRes->getSize() ; i++)
1006             {
1007                 std::complex<double> dbl = sp->getImg(0, 0);
1008                 pReal[i] += dbl.real();
1009                 pImg[i] += dbl.imag();
1010             }
1011         }
1012         else
1013         {
1014             double* pReal = pRes->get();
1015             for (int i = 0 ; i < pRes->getSize() ; i++)
1016             {
1017                 pReal[i] += sp->get(0, 0);
1018             }
1019         }
1020
1021         *pDRes = pRes;
1022         return 0;
1023     }
1024
1025
1026     if (sp->getRows() == d->getRows() && sp->getCols() == d->getCols())
1027     {
1028         //SP + D
1029         Double* pRes = (Double*)d->clone();
1030         pRes->setComplex(bComplex1 | bComplex2);
1031
1032         int nonZeros = static_cast<int>(sp->nonZeros());
1033         int* pRows = new int[nonZeros * 2];
1034         sp->outputRowCol(pRows);
1035         int* pCols = pRows + nonZeros;
1036
1037         if (bComplex1)
1038         {
1039             for (int i = 0 ; i < nonZeros ; i++)
1040             {
1041                 int iRow = static_cast<int>(pRows[i]) - 1;
1042                 int iCol = static_cast<int>(pCols[i]) - 1;
1043                 std::complex<double> dbl = sp->getImg(iRow, iCol);
1044                 pRes->set(iRow, iCol, pRes->get(iRow, iCol) + dbl.real());
1045                 pRes->setImg(iRow, iCol, pRes->getImg(iRow, iCol) + dbl.imag());
1046             }
1047         }
1048         else
1049         {
1050             for (int i = 0 ; i < nonZeros ; i++)
1051             {
1052                 int iRow = static_cast<int>(pRows[i]) - 1;
1053                 int iCol = static_cast<int>(pCols[i]) - 1;
1054                 pRes->set(iRow, iCol, pRes->get(iRow, iCol) + sp->get(iRow, iCol));
1055             }
1056         }
1057
1058         //clear
1059         delete[] pRows;
1060         *pDRes = pRes;
1061         return 0;
1062     }
1063     return 1;
1064 }
1065
1066 int AddDoubleToSparse(Double* d, Sparse* sp, GenericType** pDRes)
1067 {
1068     /* uses commutativity */
1069     return AddSparseToDouble(sp, d, pDRes);
1070 }
1071
1072 template<class T, class U, class O>
1073 InternalType* add_M_M(T *_pL, U *_pR)
1074 {
1075     int iDimsL = _pL->getDims();
1076     int iDimsR = _pR->getDims();
1077
1078     if (iDimsL != iDimsR)
1079     {
1080         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1081     }
1082
1083     int* piDimsL = _pL->getDimsArray();
1084     int* piDimsR = _pR->getDimsArray();
1085
1086     for (int i = 0 ; i < iDimsL ; ++i)
1087     {
1088         if (piDimsL[i] != piDimsR[i])
1089         {
1090             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1091         }
1092     }
1093
1094     O* pOut = new O(iDimsL, piDimsL);
1095
1096     add(_pL->get(), (long long)_pL->getSize(), _pR->get(), pOut->get());
1097     return pOut;
1098 }
1099
1100 template<class T, class U, class O>
1101 InternalType* add_M_MC(T *_pL, U *_pR)
1102 {
1103     int iDimsL = _pL->getDims();
1104     int iDimsR = _pR->getDims();
1105
1106     if (iDimsL != iDimsR)
1107     {
1108         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1109     }
1110
1111     int* piDimsL = _pL->getDimsArray();
1112     int* piDimsR = _pR->getDimsArray();
1113
1114     for (int i = 0 ; i < iDimsL ; ++i)
1115     {
1116         if (piDimsL[i] != piDimsR[i])
1117         {
1118             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1119         }
1120     }
1121
1122     O* pOut = new O(iDimsL, piDimsL, true);
1123
1124     add(_pL->get(), (long long)_pL->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1125     return pOut;
1126 }
1127
1128 template<class T, class U, class O>
1129 InternalType* add_M_S(T *_pL, U *_pR)
1130 {
1131     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1132     add(_pL->get(), (long long)_pL->getSize(), _pR->get(0), pOut->get());
1133     return pOut;
1134 }
1135
1136 template<class T, class U, class O>
1137 InternalType* add_M_SC(T *_pL, U *_pR)
1138 {
1139     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
1140     add(_pL->get(), (long long)_pL->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1141     return pOut;
1142 }
1143
1144 template<class T, class U, class O>
1145 InternalType* add_M_E(T *_pL, U *_pR)
1146 {
1147     return _pL;
1148 }
1149
1150
1151 template<class T, class U, class O>
1152 InternalType* add_MC_M(T *_pL, U *_pR)
1153 {
1154     return add_M_MC<U, T, O>(_pR, _pL);
1155 }
1156
1157 template<class T, class U, class O>
1158 InternalType* add_MC_MC(T *_pL, U *_pR)
1159 {
1160     int iDimsL = _pL->getDims();
1161     int iDimsR = _pR->getDims();
1162
1163     if (iDimsL != iDimsR)
1164     {
1165         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1166     }
1167
1168     int* piDimsL = _pL->getDimsArray();
1169     int* piDimsR = _pR->getDimsArray();
1170
1171     for (int i = 0 ; i < iDimsL ; ++i)
1172     {
1173         if (piDimsL[i] != piDimsR[i])
1174         {
1175             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1176         }
1177     }
1178
1179     O* pOut = new O(iDimsL, piDimsL, true);
1180
1181     add(_pL->get(), _pL->getImg(), (long long)_pL->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1182     return pOut;
1183 }
1184
1185 template<class T, class U, class O>
1186 InternalType* add_MC_S(T *_pL, U *_pR)
1187 {
1188     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
1189     add(_pL->get(), _pL->getImg(), (long long)_pL->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
1190     return pOut;
1191 }
1192
1193 template<class T, class U, class O>
1194 InternalType* add_MC_SC(T *_pL, U *_pR)
1195 {
1196     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
1197     add(_pL->get(), _pL->getImg(), (long long)_pL->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1198     return pOut;
1199 }
1200
1201 template<class T, class U, class O>
1202 InternalType* add_MC_E(T *_pL, U *_pR)
1203 {
1204     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
1205     add(_pL->get(), _pL->getImg(), (long long)_pL->getSize(), pOut->get(), pOut->getImg());
1206     return pOut;
1207 }
1208
1209
1210 template<class T, class U, class O>
1211 InternalType* add_S_M(T *_pL, U *_pR)
1212 {
1213     return add_M_S<U, T, O>(_pR, _pL);
1214 }
1215
1216 template<class T, class U, class O>
1217 InternalType* add_S_MC(T *_pL, U *_pR)
1218 {
1219     return add_MC_S<U, T, O>(_pR, _pL);
1220 }
1221
1222 template<class T, class U, class O>
1223 InternalType* add_S_S(T *_pL, U *_pR)
1224 {
1225     O* pOut = new O(0);
1226     add(_pL->get(0), _pR->get(0), pOut->get());
1227     return pOut;
1228 }
1229
1230 template<class T, class U, class O>
1231 InternalType* add_S_SC(T *_pL, U *_pR)
1232 {
1233     O* pOut = new O(0.0, 0.0);
1234     add(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1235     return pOut;
1236 }
1237
1238 template<class T, class U, class O>
1239 InternalType* add_S_E(T *_pL, U *_pR)
1240 {
1241     O* pOut = new O(0);
1242     add(_pL->get(0), pOut->get());
1243     return pOut;
1244 }
1245
1246
1247 template<class T, class U, class O>
1248 InternalType* add_SC_M(T *_pL, U *_pR)
1249 {
1250     return add_M_SC<U, T, O>(_pR, _pL);
1251 }
1252
1253 template<class T, class U, class O>
1254 InternalType* add_SC_MC(T *_pL, U *_pR)
1255 {
1256     return add_MC_SC<U, T, O>(_pR, _pL);
1257 }
1258
1259 template<class T, class U, class O>
1260 InternalType* add_SC_S(T *_pL, U *_pR)
1261 {
1262     return add_S_SC<U, T, O>(_pR, _pL);
1263 }
1264
1265 template<class T, class U, class O>
1266 InternalType* add_SC_SC(T *_pL, U *_pR)
1267 {
1268     O* pOut = new O(0.0, 0.0);
1269     add(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1270     return pOut;
1271 }
1272
1273 template<class T, class U, class O>
1274 InternalType* add_SC_E(T *_pL, U *_pR)
1275 {
1276     O* pOut = new O(0.0, 0.0);
1277     add(_pL->get(0), _pL->getImg(0), pOut->get(), pOut->getImg());
1278     return pOut;
1279 }
1280
1281
1282 template<class T, class U, class O>
1283 InternalType* add_E_M(T *_pL, U *_pR)
1284 {
1285     return add_M_E<U, T, O>(_pR, _pL);
1286 }
1287
1288 template<class T, class U, class O>
1289 InternalType* add_E_MC(T *_pL, U *_pR)
1290 {
1291     return add_MC_E<U, T, O>(_pR, _pL);
1292 }
1293
1294 template<class T, class U, class O>
1295 InternalType* add_E_S(T *_pL, U *_pR)
1296 {
1297     return add_S_E<U, T, O>(_pR, _pL);
1298 }
1299
1300 template<class T, class U, class O>
1301 InternalType* add_E_SC(T *_pL, U *_pR)
1302 {
1303     return add_SC_E<U, T, O>(_pR, _pL);
1304 }
1305
1306 template<class T, class U, class O>
1307 InternalType* add_E_E(T *_pL, U *_pR)
1308 {
1309     Double* pOut = Double::Empty();
1310     add();
1311     return pOut;
1312 }
1313
1314 template<class T, class U, class O>
1315 InternalType* add_I_M(T *_pL, U *_pR)
1316 {
1317     int iDims = _pR->getDims();
1318     int* piDims = _pR->getDimsArray();
1319     O* pOut = (O*)_pR->clone();
1320     double* pdblOut = pOut->get();
1321     double* pdblRight = _pR->get();
1322     double dblLeft = _pL->get(0);
1323     int iLeadDims = piDims[0];
1324     int* piIndex = new int[iDims];
1325     piIndex[0] = 0;
1326
1327     //find smaller dims
1328     for (int i = 1 ; i < iDims ; ++i)
1329     {
1330         //init
1331         piIndex[i] = 0;
1332
1333         if (iLeadDims > piDims[i])
1334         {
1335             iLeadDims = piDims[i];
1336         }
1337     }
1338
1339     for (int i = 0 ; i < iLeadDims ; ++i)
1340     {
1341         for (int j = 0 ; j < iDims ; ++j)
1342         {
1343             piIndex[j] = i;
1344         }
1345
1346         int index = _pR->getIndex(piIndex);
1347         add(dblLeft, pdblRight[index], pdblOut + index);
1348     }
1349
1350     return pOut;
1351 }
1352
1353 template<class T, class U, class O>
1354 InternalType* add_I_MC(T *_pL, U *_pR)
1355 {
1356     return add_I_M<T, U, O>(_pL, _pR);
1357 }
1358
1359 template<class T, class U, class O>
1360 InternalType* add_IC_M(T *_pL, U *_pR)
1361 {
1362     int iDims = _pR->getDims();
1363     int* piDims = _pR->getDimsArray();
1364     O* pOut = (O*)_pR->clone();
1365     pOut->setComplex(true);
1366     int iLeadDims = piDims[0];
1367     int* piIndex = new int[iDims];
1368     piIndex[0] = 0;
1369     //find smaller dims
1370     for (int i = 1 ; i < iDims ; ++i)
1371     {
1372         //init
1373         piIndex[i] = 0;
1374
1375         if (iLeadDims > piDims[i])
1376         {
1377             iLeadDims = piDims[i];
1378         }
1379     }
1380
1381     for (int i = 0 ; i < iLeadDims ; ++i)
1382     {
1383         for (int j = 0 ; j < iDims ; ++j)
1384         {
1385             piIndex[j] = i;
1386         }
1387
1388         int index = _pR->getIndex(piIndex);
1389         add(_pR->get() + index, 1, _pL->get(0), _pL->getImg(0), pOut->get() + index, pOut->getImg() + index);
1390     }
1391
1392     return pOut;
1393 }
1394
1395 template<class T, class U, class O>
1396 InternalType* add_IC_MC(T *_pL, U *_pR)
1397 {
1398     int iDims = _pR->getDims();
1399     int* piDims = _pR->getDimsArray();
1400     O* pOut = (O*)_pR->clone();
1401     int iLeadDims = piDims[0];
1402     int* piIndex = new int[iDims];
1403     piIndex[0] = 0;
1404     //find smaller dims
1405     for (int i = 1 ; i < iDims ; ++i)
1406     {
1407         //init
1408         piIndex[i] = 0;
1409
1410         if (iLeadDims > piDims[i])
1411         {
1412             iLeadDims = piDims[i];
1413         }
1414     }
1415
1416     for (int i = 0 ; i < iLeadDims ; ++i)
1417     {
1418         for (int j = 0 ; j < iDims ; ++j)
1419         {
1420             piIndex[j] = i;
1421         }
1422
1423         int index = _pR->getIndex(piIndex);
1424
1425         add(_pL->get(0), _pL->getImg(0), _pR->get(index), _pR->getImg(index), pOut->get() + index, pOut->getImg() + index);
1426     }
1427
1428     return pOut;
1429 }
1430
1431 template<class T, class U, class O>
1432 InternalType* add_I_S(T *_pL, U *_pR)
1433 {
1434     O* pOut = new O(0);
1435     add(_pL->get(0), _pR->get(0), pOut->get());
1436     return pOut;
1437 }
1438
1439 template<class T, class U, class O>
1440 InternalType* add_IC_S(T *_pL, U *_pR)
1441 {
1442     O* pOut = new O(0.0, 0.0);
1443     add( _pR->get(), 1, _pL->get(0), _pL->getImg(0), pOut->get(), pOut->getImg());
1444     return pOut;
1445 }
1446
1447 template<class T, class U, class O>
1448 InternalType* add_I_SC(T *_pL, U *_pR)
1449 {
1450     O* pOut = new O(0.0, 0.0);
1451     add(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1452     return pOut;
1453 }
1454
1455 template<class T, class U, class O>
1456 InternalType* add_IC_SC(T *_pL, U *_pR)
1457 {
1458     O* pOut = new O(0.0, 0.0);
1459     add(_pL->get(), _pL->getImg(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1460     return pOut;
1461 }
1462
1463 template<class T, class U, class O> InternalType* add_M_I(T *_pL, U *_pR)
1464 {
1465     return add_I_M<U, T, O>(_pR, _pL);
1466 }
1467
1468 template<class T, class U, class O> InternalType* add_MC_I(T *_pL, U *_pR)
1469 {
1470     return add_I_MC<U, T, O>(_pR, _pL);
1471 }
1472
1473 template<class T, class U, class O> InternalType* add_M_IC(T *_pL, U *_pR)
1474 {
1475     return add_IC_M<U, T, O>(_pR, _pL);
1476 }
1477
1478 template<class T, class U, class O> InternalType* add_MC_IC(T *_pL, U *_pR)
1479 {
1480     return add_IC_MC<U, T, O>(_pR, _pL);
1481 }
1482
1483 template<class T, class U, class O> InternalType* add_S_I(T *_pL, U *_pR)
1484 {
1485     return add_I_S<U, T, O>(_pR, _pL);
1486 }
1487
1488 template<class T, class U, class O> InternalType* add_SC_I(T *_pL, U *_pR)
1489 {
1490     return add_I_SC<U, T, O>(_pR, _pL);
1491 }
1492
1493 template<class T, class U, class O> InternalType* add_S_IC(T *_pL, U *_pR)
1494 {
1495     return add_IC_S<U, T, O>(_pR, _pL);
1496 }
1497
1498 template<class T, class U, class O> InternalType* add_SC_IC(T *_pL, U *_pR)
1499 {
1500     return add_IC_SC<U, T, O>(_pR, _pL);
1501 }
1502
1503 template<class T, class U, class O> InternalType* add_I_I(T *_pL, U *_pR)
1504 {
1505     O* pOut = (O*)_pL->clone();
1506     add(_pL->get(0), _pR->get(0), pOut->get());
1507     return pOut;
1508 }
1509
1510 template<class T, class U, class O> InternalType* add_I_IC(T *_pL, U *_pR)
1511 {
1512     O* pOut = (O*)_pR->clone();
1513     add(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1514     return pOut;
1515 }
1516
1517 template<class T, class U, class O> InternalType* add_IC_I(T *_pL, U *_pR)
1518 {
1519     return add_I_IC<U, T, O>(_pR, _pL);
1520 }
1521
1522 template<class T, class U, class O> InternalType* add_IC_IC(T *_pL, U *_pR)
1523 {
1524     O* pOut = (O*)_pL->clone();
1525     add(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1526     return pOut;
1527 }
1528
1529 template<class T, class U, class O> types::InternalType* add_I_E(T *_pL, U *_pR)
1530 {
1531     O* pOut = (O*)_pL->clone();
1532     return pOut;
1533 }
1534
1535 template<class T, class U, class O> types::InternalType* add_IC_E(T *_pL, U *_pR)
1536 {
1537     O* pOut = (O*)_pL->clone();
1538     return pOut;
1539 }
1540
1541 template<class T, class U, class O> types::InternalType* add_E_I(T *_pL, U *_pR)
1542 {
1543     O* pOut = (O*)_pR->clone();
1544     return pOut;
1545 }
1546
1547 template<class T, class U, class O> types::InternalType* add_E_IC(T *_pL, U *_pR)
1548 {
1549     O* pOut = (O*)_pR->clone();
1550     return pOut;
1551 }
1552
1553 //specifiaction for String Matrix + String Matrix
1554 template<>
1555 InternalType* add_M_M<String, String, String>(String* _pL, String* _pR)
1556 {
1557     int iDimsL = _pL->getDims();
1558     int iDimsR = _pR->getDims();
1559
1560     if (iDimsL != iDimsR)
1561     {
1562         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1563     }
1564
1565     int* piDimsL = _pL->getDimsArray();
1566     int* piDimsR = _pR->getDimsArray();
1567
1568     for (int i = 0 ; i < iDimsL ; ++i)
1569     {
1570         if (piDimsL[i] != piDimsR[i])
1571         {
1572             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1573         }
1574     }
1575
1576     String* pOut = new String(iDimsL, piDimsL);
1577     int size = _pL->getSize();
1578     int* sizeOut = new int[size];
1579     for (int i = 0 ; i < size ; ++i)
1580     {
1581         wchar_t* pwstL = _pL->get(i);
1582         wchar_t* pwstR = _pR->get(i);
1583         int sizeL = (int)wcslen(pwstL);
1584         int sizeR = (int)wcslen(pwstR);
1585
1586         sizeOut[i] = sizeL + sizeR + 1;
1587         wchar_t* pwstOut = (wchar_t*) MALLOC(sizeOut[i] * sizeof(wchar_t));
1588         //assign ptr without strdup
1589         pOut->get()[i] = pwstOut;
1590     }
1591
1592     add(_pL->get(), size, _pR->get(), sizeOut, pOut->get());
1593     delete[] sizeOut;
1594     return pOut;
1595 }
1596
1597 //specifiaction for String Matrix + String Scalar
1598 template<>
1599 InternalType* add_S_M<String, String, String>(String* _pL, String* _pR)
1600 {
1601     String* pOut = new String(_pR->getDims(), _pR->getDimsArray());
1602     int size = _pR->getSize();
1603     int* sizeOut = new int[size];
1604     wchar_t* pwstL = _pL->get(0);
1605     int sizeL = (int)wcslen(pwstL);
1606
1607     for (int i = 0 ; i < size ; ++i)
1608     {
1609         wchar_t* pwstR = _pR->get(i);
1610         int sizeR = (int)wcslen(pwstR);
1611
1612         sizeOut[i] = sizeL + sizeR + 1;
1613         wchar_t* pwstOut = (wchar_t*) MALLOC(sizeOut[i] * sizeof(wchar_t));
1614         //assign ptr without strdup
1615         pOut->get()[i] = pwstOut;
1616     }
1617
1618     add(pwstL, size, _pR->get(), sizeOut, pOut->get());
1619     delete[] sizeOut;
1620     return pOut;
1621 }
1622
1623 //specifiaction for String Scalar + String MAtrix
1624 template<>
1625 InternalType* add_M_S<String, String, String>(String* _pL, String* _pR)
1626 {
1627     String* pOut = new String(_pL->getDims(), _pL->getDimsArray());
1628     int size = _pL->getSize();
1629     int* sizeOut = new int[size];
1630     wchar_t* pwstR = _pR->get(0);
1631     int sizeR = (int)wcslen(pwstR);
1632
1633     for (int i = 0 ; i < size ; ++i)
1634     {
1635         wchar_t* pwstL = _pL->get(i);
1636         int sizeL = (int)wcslen(pwstL);
1637
1638         sizeOut[i] = sizeL + sizeR + 1;
1639         wchar_t* pwstOut = (wchar_t*) MALLOC(sizeOut[i] * sizeof(wchar_t));
1640         //assign ptr without strdup
1641         pOut->get()[i] = pwstOut;
1642     }
1643
1644     add(_pL->get(), size, pwstR, sizeOut, pOut->get());
1645     delete[] sizeOut;
1646     return pOut;
1647 }
1648
1649 //specifiaction for String Scalar + String Scalar
1650 template<>
1651 InternalType* add_S_S<String, String, String>(String* _pL, String* _pR)
1652 {
1653     String* pOut = new String(1, 1);
1654     wchar_t* pwstL = _pL->get(0);
1655     wchar_t* pwstR = _pR->get(0);
1656     int sizeL = (int)wcslen(pwstL);
1657     int sizeR = (int)wcslen(pwstR);
1658
1659     int sizeOut = sizeL + sizeR + 1;
1660     wchar_t* pwstOut = (wchar_t*) MALLOC(sizeOut * sizeof(wchar_t));
1661     //assign ptr without strdup
1662     pOut->get()[0] = pwstOut;
1663     add(pwstL, pwstR, sizeOut, *pOut->get());
1664     return pOut;
1665 }
1666
1667 template<>
1668 InternalType* add_M_E<String, Double, String>(String* _pL, Double* _pR)
1669 {
1670     return _pL;
1671 }
1672
1673 template<>
1674 InternalType* add_S_E<String, Double, String>(String* _pL, Double* _pR)
1675 {
1676     return _pL;
1677 }
1678
1679 template<>
1680 InternalType* add_E_M<Double, String, String>(Double* _pL, String* _pR)
1681 {
1682     return _pR;
1683 }
1684
1685 template<>
1686 InternalType* add_E_S<Double, String, String>(Double* _pL, String* _pR)
1687 {
1688     return _pR;
1689 }
1690
1691 template<> InternalType* add_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1692 {
1693     Polynom* pOut = NULL;
1694     if (_pL->getVariableName() != _pR->getVariableName())
1695     {
1696         std::wostringstream os;
1697         os << _W("variables don't have the same formal variable");
1698         //os << ((Location)e.right_get().location_get()).location_getString() << std::endl;
1699         throw ast::ScilabError(os.str());
1700     }
1701
1702     if (_pL->isScalar())
1703     {
1704         int *pRank = new int[_pR->getSize()];
1705         int *pRank1 = new int[_pR->getSize()];
1706         int *pRank2 = new int[_pR->getSize()];
1707         bool bComplex1 = _pL->isComplex();
1708         bool bComplex2 = _pR->isComplex();
1709
1710         memset(pRank1, 0x00, _pR->getSize() * sizeof(int));
1711
1712         _pL->getRank(pRank1);
1713         _pR->getRank(pRank2);
1714         for (int i = 0 ; i < _pR->getSize() ; i++)
1715         {
1716             pRank[i] = std::max(pRank1[0], pRank2[i]);
1717         }
1718
1719         pOut = new Polynom(_pR->getVariableName(), _pR->getDims(), _pR->getDimsArray(), pRank);
1720         if (bComplex1 || bComplex2)
1721         {
1722             pOut->setComplex(true);
1723         }
1724
1725         //Result P1(0) + P2(i)
1726         Double *pCoef1 = _pL->get(0)->getCoef();
1727         double *p1R   = pCoef1->getReal();
1728         double *p1I   = pCoef1->getImg();
1729         for (int i = 0 ; i < _pR->getSize() ; i++)
1730         {
1731             Double *pCoef2 = _pR->get(i)->getCoef();
1732             double *p2R   = pCoef2->getReal();
1733             double *p2I   = pCoef2->getImg();
1734
1735             Double *pCoefR = pOut->get(i)->getCoef();
1736             double *pRR   = pCoefR->getReal();
1737             double *pRI   = pCoefR->getImg();
1738
1739             for (int j = 0 ; j < std::min(pRank1[0], pRank2[i]) ; j++)
1740             {
1741                 pRR[j] = p1R[j] + p2R[j];
1742             }
1743
1744             double *pTemp = (pRank1[0] > pRank2[i] ? p1R : p2R);
1745             for (int j = std::min(pRank1[0], pRank2[i]) ; j < std::max(pRank1[0], pRank2[i]) ; j++)
1746             {
1747                 pRR[j] = pTemp[j];
1748             }
1749
1750             if (pOut->isComplex())
1751             {
1752                 for (int j = 0 ; j < std::min(pRank1[0], pRank2[i]) ; j++)
1753                 {
1754                     pRI[j] = (p1I == NULL ? 0 : p1I[j]) + (p2I == NULL ? 0 : p2I[j]);
1755                 }
1756
1757                 double *pTemp = (pRank1[0] > pRank2[i] ? p1I : p2I);
1758                 for (int j = std::min(pRank1[0], pRank2[i]) ; j < std::max(pRank1[0], pRank2[i]); j++)
1759                 {
1760                     pRI[j] = pTemp == NULL ? 0 : pTemp[j];
1761                 }
1762             }
1763         }
1764
1765         delete[] pRank;
1766         delete[] pRank1;
1767         delete[] pRank2;
1768         return pOut;
1769     }
1770
1771     if (_pR->isScalar())
1772     {
1773         int *pRank = new int[_pL->getSize()];
1774         int *pRank1 = new int[_pL->getSize()];
1775         int *pRank2 = new int[_pL->getSize()];
1776         bool bComplex1 = _pL->isComplex();
1777         bool bComplex2 = _pR->isComplex();
1778
1779         memset(pRank2, 0x00, _pL->getSize() * sizeof(int));
1780
1781         _pL->getRank(pRank1);
1782         _pR->getRank(pRank2);
1783         for (int i = 0 ; i < _pL->getSize() ; i++)
1784         {
1785             pRank[i] = std::max(pRank1[i], pRank2[0]);
1786         }
1787
1788         pOut = new Polynom(_pL->getVariableName(), _pL->getDims(), _pL->getDimsArray(), pRank);
1789         if (bComplex1 || bComplex2)
1790         {
1791             pOut->setComplex(true);
1792         }
1793
1794         //Result P1(i) + P2(0)
1795         Double *pCoef2 = _pR->get(0)->getCoef();
1796         double *p2R   = pCoef2->getReal();
1797         double *p2I   = pCoef2->getImg();
1798
1799         for (int i = 0 ; i < _pL->getSize() ; i++)
1800         {
1801             Double *pCoef1 = _pL->get(i)->getCoef();
1802             double *p1R   = pCoef1->getReal();
1803             double *p1I   = pCoef1->getImg();
1804
1805             Double *pCoefR = pOut->get(i)->getCoef();
1806             double *pRR   = pCoefR->getReal();
1807             double *pRI   = pCoefR->getImg();
1808
1809             for (int j = 0 ; j < std::min(pRank1[i], pRank2[0]) ; j++)
1810             {
1811                 pRR[j] = p1R[j] + p2R[j];
1812             }
1813
1814             double *pTemp = (pRank1[i] > pRank2[0] ? p1R : p2R);
1815             for (int j = std::min(pRank1[i], pRank2[0]) ; j < std::max(pRank1[i], pRank2[0]) ; j++)
1816             {
1817                 pRR[j] = pTemp[j];
1818             }
1819
1820             if (pOut->isComplex())
1821             {
1822                 for (int j = 0 ; j < std::min(pRank1[i], pRank2[0]) ; j++)
1823                 {
1824                     pRI[j] = (p1I == NULL ? 0 : p1I[j]) + (p2I == NULL ? 0 : p2I[j]);
1825                 }
1826
1827                 double *pTemp = (pRank1[i] > pRank2[0] ? p1I : p2I);
1828                 for (int j = std::min(pRank1[i], pRank2[0]) ; j < std::max(pRank1[i], pRank2[0]); j++)
1829                 {
1830                     pRI[j] = pTemp == NULL ? 0 : pTemp[j];
1831                 }
1832             }
1833         }
1834
1835         delete[] pRank;
1836         delete[] pRank1;
1837         delete[] pRank2;
1838         return pOut;
1839     }
1840
1841     int iDims1 = _pL->getDims();
1842     int iDims2 = _pR->getDims();
1843
1844     if (iDims1 != iDims2)
1845     {
1846         wchar_t pMsg[bsiz];
1847         os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
1848         throw ast::ScilabError(pMsg);
1849     }
1850
1851     int* piDims1 = _pL->getDimsArray();
1852     int* piDims2 = _pR->getDimsArray();
1853
1854     for (int i = 0 ; i < iDims1 ; i++)
1855     {
1856         if (piDims1[i] != piDims2[i])
1857         {
1858             wchar_t pMsg[bsiz];
1859             os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
1860             throw ast::ScilabError(pMsg);
1861         }
1862     }
1863
1864     int *pRank = new int[_pL->getSize()];
1865     int *pRank1 = new int[_pL->getSize()];
1866     int *pRank2 = new int[_pR->getSize()];
1867     bool bComplex1 = _pL->isComplex();
1868     bool bComplex2 = _pR->isComplex();
1869
1870     _pL->getRank(pRank1);
1871     _pR->getRank(pRank2);
1872     for (int i = 0 ; i < _pL->getSize() ; i++)
1873     {
1874         pRank[i] = std::max(pRank1[i], pRank2[i]);
1875     }
1876
1877     pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray(), pRank);
1878     if (_pL->isComplex() || _pR->isComplex())
1879     {
1880         pOut->setComplex(true);
1881     }
1882
1883     if (bComplex1 == false && bComplex2 == false)
1884     {
1885         for (int i = 0 ; i < _pL->getSize() ; i++)
1886         {
1887             iAddScilabPolynomToScilabPolynom(
1888                 _pL->get(i)->getCoef()->getReal(), pRank1[i],
1889                 _pR->get(i)->getCoef()->getReal(), pRank2[i],
1890                 pOut->get(i)->getCoef()->getReal(), pRank[i]);
1891         }
1892     }
1893     else if (bComplex1 == false && bComplex2 == true)
1894     {
1895         for (int i = 0 ; i < _pL->getSize() ; i++)
1896         {
1897             iAddScilabPolynomToComplexPoly(
1898                 _pL->get(i)->getCoef()->getReal(), pRank1[i],
1899                 _pR->get(i)->getCoef()->getReal(), _pR->get(i)->getCoef()->getImg(), pRank2[i],
1900                 pOut->get(i)->getCoef()->getReal(), pOut->get(i)->getCoef()->getImg(), pRank[i]);
1901         }
1902     }
1903     else if (bComplex1 == true && bComplex2 == false)
1904     {
1905         for (int i = 0 ; i < _pL->getSize() ; i++)
1906         {
1907             iAddScilabPolynomToComplexPoly(
1908                 _pR->get(i)->getCoef()->getReal(), pRank2[i],
1909                 _pL->get(i)->getCoef()->getReal(), _pL->get(i)->getCoef()->getImg(), pRank1[i],
1910                 pOut->get(i)->getCoef()->getReal(), pOut->get(i)->getCoef()->getImg(), pRank[i]);
1911         }
1912     }
1913     else if (bComplex1 == true && bComplex2 == true)
1914     {
1915         for (int i = 0 ; i < _pL->getSize() ; i++)
1916         {
1917             iAddComplexPolyToComplexPoly(
1918                 _pL->get(i)->getCoef()->getReal(), _pL->get(i)->getCoef()->getImg(), pRank1[i],
1919                 _pR->get(i)->getCoef()->getReal(), _pR->get(i)->getCoef()->getImg(), pRank2[i],
1920                 pOut->get(i)->getCoef()->getReal(), pOut->get(i)->getCoef()->getImg(), pRank[i]);
1921         }
1922     }
1923
1924     delete[] pRank;
1925     delete[] pRank1;
1926     delete[] pRank2;
1927
1928     if (pOut != NULL)
1929     {
1930         pOut->updateRank();
1931     }
1932
1933     return pOut;
1934 }
1935
1936 template<> InternalType* add_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1937 {
1938     return add_M_M<Double, Polynom, Polynom>(_pR, _pL);
1939 }
1940
1941 template<> InternalType* add_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1942 {
1943     Polynom* pOut = NULL;
1944     bool bComplex1 = _pR->isComplex();
1945     bool bComplex2 = _pL->isComplex();
1946
1947     double *pInDblR = _pL->getReal();
1948     double *pInDblI = _pL->getImg();
1949
1950     if (_pL->isEmpty())
1951     {
1952         return _pR;
1953     }
1954
1955     if (_pR->isScalar())
1956     {
1957         int *piRank = new int[_pL->getSize()];
1958         for (int i = 0 ; i < _pL->getSize() ; i++)
1959         {
1960             piRank[i] = _pR->get(0)->getRank();
1961         }
1962
1963         pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray(), piRank);
1964         if (bComplex1 || bComplex2)
1965         {
1966             pOut->setComplex(true);
1967         }
1968
1969         for (int i = 0 ; i < pOut->getSize() ; i++)
1970         {
1971             SinglePoly *pInPoly  = _pR->get(0);
1972             SinglePoly *pOutPoly = pOut->get(i);
1973             double *pInPolyR     = pInPoly->getCoef()->getReal();
1974             double *pOutPolyR    = pOutPoly->getCoef()->getReal();
1975
1976             pOutPolyR[0] = pInDblR[i] + pInPolyR[0];
1977
1978             for (int j = 1 ; j < pInPoly->getRank() ; j++)
1979             {
1980                 pOutPolyR[j] = pInPolyR[j];
1981             }
1982         }
1983
1984         if (pOut->isComplex())
1985         {
1986             for (int i = 0 ; i < pOut->getSize() ; i++)
1987             {
1988                 SinglePoly *pInPoly  = _pR->get(0);
1989                 SinglePoly *pOutPoly = pOut->get(i);
1990                 double *pInPolyI     = pInPoly->getCoef()->getImg();
1991                 double *pOutPolyI    = pOutPoly->getCoef()->getImg();
1992
1993                 pOutPolyI[0] = (pInDblI != NULL ? pInDblI[i] : 0) + (pInPolyI != NULL ? pInPolyI[0] : 0);
1994
1995                 for (int j = 1 ; j < pInPoly->getRank() ; j++)
1996                 {
1997                     pOutPolyI[j] = (pInPolyI != NULL ? pInPolyI[j] : 0);
1998                 }
1999             }
2000         }
2001
2002         return pOut;
2003     }
2004
2005     if (_pL->isScalar())
2006     {
2007         pOut = (Polynom*)_pR->clone();
2008
2009         if (bComplex1 && bComplex2)
2010         {
2011             for (int i = 0 ; i < pOut->getSize() ; i++)
2012             {
2013                 SinglePoly *pSPOut   = pOut->get(i);
2014                 double *pOutPolyR    = pSPOut->getCoef()->getReal();
2015                 double *pOutPolyI    = pSPOut->getCoef()->getImg();
2016
2017                 pOutPolyR[0] += pInDblR[0];
2018                 pOutPolyI[0] += pInDblI[0];
2019             }
2020         }
2021         else if (bComplex2)
2022         {
2023             pOut->setComplex(true);
2024             for (int i = 0 ; i < pOut->getSize() ; i++)
2025             {
2026                 SinglePoly *pSPOut   = pOut->get(i);
2027                 double *pOutPolyR    = pSPOut->getCoef()->getReal();
2028                 double *pOutPolyI    = pSPOut->getCoef()->getImg();
2029
2030                 pOutPolyR[0] += pInDblR[0];
2031                 pOutPolyI[0] = pInDblI[0];
2032             }
2033         }
2034         else
2035         {
2036             for (int i = 0 ; i < pOut->getSize() ; i++)
2037             {
2038                 SinglePoly *pSPOut = pOut->get(i);
2039                 double *pOutPolyR  = pSPOut->getCoef()->getReal();
2040
2041                 pOutPolyR[0] += pInDblR[0];
2042             }
2043         }
2044
2045         return pOut;
2046     }
2047
2048     int iDims1 = _pR->getDims();
2049     int iDims2 = _pL->getDims();
2050
2051     if (iDims1 != iDims2)
2052     {
2053         wchar_t pMsg[bsiz];
2054         os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
2055         throw ast::ScilabError(pMsg);
2056     }
2057
2058     int* piDims1 = _pR->getDimsArray();
2059     int* piDims2 = _pL->getDimsArray();
2060
2061     for (int i = 0 ; i < iDims1 ; i++)
2062     {
2063         if (piDims1[i] != piDims2[i])
2064         {
2065             wchar_t pMsg[bsiz];
2066             os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
2067             throw ast::ScilabError(pMsg);
2068         }
2069     }
2070
2071     pOut = (Polynom*)_pR->clone();
2072     if (bComplex1 && bComplex2)
2073     {
2074         for (int i = 0 ; i < pOut->getSize() ; i++)
2075         {
2076             SinglePoly *pSPOut   = pOut->get(i);
2077             double *pOutPolyR    = pSPOut->getCoef()->getReal();
2078             double *pOutPolyI    = pSPOut->getCoef()->getImg();
2079
2080             pOutPolyR[0] += pInDblR[i];
2081             pOutPolyI[0] += pInDblI[i];
2082         }
2083     }
2084     else if (bComplex2)
2085     {
2086         pOut->setComplex(true);
2087         for (int i = 0 ; i < pOut->getSize() ; i++)
2088         {
2089             SinglePoly *pSPOut   = pOut->get(i);
2090             double *pOutPolyR    = pSPOut->getCoef()->getReal();
2091             double *pOutPolyI    = pSPOut->getCoef()->getImg();
2092
2093             pOutPolyR[0] += pInDblR[i];
2094             pOutPolyI[0] = pInDblI[i];
2095         }
2096     }
2097     else
2098     {
2099         for (int i = 0 ; i < pOut->getSize() ; i++)
2100         {
2101             SinglePoly *pSPOut = pOut->get(i);
2102             double *pOutPolyR  = pSPOut->getCoef()->getReal();
2103
2104             pOutPolyR[0] += pInDblR[i];
2105         }
2106     }
2107
2108     return pOut;
2109 }
2110
2111 //sp + sp
2112 template<> InternalType* add_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
2113 {
2114     Sparse* pOut = NULL;
2115     //check scalar hidden in a sparse ;)
2116     if (_pL->getRows() == 1 && _pL->getCols() == 1)
2117     {
2118         //do scalar + sp
2119         Double* pDbl = NULL;
2120         if (_pL->isComplex())
2121         {
2122             std::complex<double> dbl = _pL->getImg(0, 0);
2123             pDbl = new Double(dbl.real(), dbl.imag());
2124         }
2125         else
2126         {
2127             pDbl = new Double(_pL->get(0, 0));
2128         }
2129
2130         AddSparseToDouble(_pR, pDbl, (GenericType**)pOut);
2131         delete pDbl;
2132         return pOut;
2133     }
2134
2135     if (_pR->getRows() == 1 && _pR->getCols() == 1)
2136     {
2137         //do sp + scalar
2138         Double* pDbl = NULL;
2139         if (_pR->isComplex())
2140         {
2141             std::complex<double> dbl = _pR->getImg(0, 0);
2142             pDbl = new Double(dbl.real(), dbl.imag());
2143         }
2144         else
2145         {
2146             pDbl = new Double(_pR->get(0, 0));
2147         }
2148
2149         AddSparseToDouble(_pL, pDbl, (GenericType**)pOut);
2150         delete pDbl;
2151         return 0;
2152     }
2153
2154     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2155     {
2156         //dimensions not match
2157         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
2158     }
2159
2160     if (_pL->nonZeros() == 0)
2161     {
2162         //sp([]) + sp
2163         return _pR;
2164     }
2165
2166     if (_pR->nonZeros() == 0)
2167     {
2168         //sp + sp([])
2169         return _pL;
2170     }
2171
2172     return _pL->add(*_pR);
2173 }
2174
2175 //d + sp
2176 template<> InternalType* add_M_M<Double, Sparse, Double>(Double* _pL, Sparse* _pR)
2177 {
2178     return add_M_M<Sparse, Double, Double>(_pR, _pL);
2179 }
2180
2181 //sp + d
2182 template<> InternalType* add_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _pR)
2183 {
2184     Double* pOut = NULL;
2185     int iOne = 1; //fortran
2186     bool bComplex1 = _pL->isComplex();
2187     bool bComplex2 = _pR->isComplex();
2188
2189     if (_pL->isScalar() && _pR->isScalar())
2190     {
2191         //sp + d
2192         pOut = (Double*)_pR->clone();
2193         pOut->setComplex(bComplex1 | bComplex2);
2194         if (bComplex1)
2195         {
2196             std::complex<double> dbl = _pL->getImg(0, 0);
2197             pOut->set(0, pOut->get(0) + dbl.real());
2198             pOut->setImg(0, pOut->getImg(0) + dbl.imag());
2199         }
2200         else
2201         {
2202             pOut->set(0, pOut->get(0) + _pL->get(0, 0));
2203         }
2204
2205         return pOut;
2206     }
2207
2208     if (_pR->isScalar())
2209     {
2210         //SP + d
2211         pOut = new Double(_pL->getRows(), _pL->getCols(), bComplex1 | bComplex2);
2212         int iSize = _pL->getSize();
2213         double dblVal = _pR->get(0);
2214         C2F(dset)(&iSize, &dblVal, pOut->get(), &iOne);
2215         if (bComplex2)
2216         {
2217             double dblValI = _pR->getImg(0);
2218             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2219         }
2220         else if (bComplex1)
2221         {
2222             //initialize imag part at 0
2223             double dblValI = 0;
2224             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2225         }
2226
2227         int nonZeros = static_cast<int>(_pL->nonZeros());
2228         int* pRows = new int[nonZeros * 2];
2229         _pL->outputRowCol(pRows);
2230         int* pCols = pRows + nonZeros;
2231
2232         if (bComplex1)
2233         {
2234             for (int i = 0 ; i < nonZeros ; i++)
2235             {
2236                 int iRow = static_cast<int>(pRows[i]) - 1;
2237                 int iCol = static_cast<int>(pCols[i]) - 1;
2238                 std::complex<double> dbl = _pL->getImg(iRow, iCol);
2239                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) + dbl.real());
2240                 pOut->setImg(iRow, iCol, pOut->getImg(iRow, iCol) + dbl.imag());
2241             }
2242         }
2243         else
2244         {
2245             for (int i = 0 ; i < nonZeros ; i++)
2246             {
2247                 int iRow = static_cast<int>(pRows[i]) - 1;
2248                 int iCol = static_cast<int>(pCols[i]) - 1;
2249                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) + _pL->get(iRow, iCol));
2250             }
2251         }
2252
2253         //clear
2254         delete[] pRows;
2255
2256         return pOut;
2257     }
2258
2259     if (_pL->isScalar())
2260     {
2261         //sp + D
2262         pOut = (Double*)_pR->clone();
2263         pOut->setComplex(bComplex1 | bComplex2);
2264
2265         if (bComplex1)
2266         {
2267             double* pReal = pOut->get();
2268             double* pImg = pOut->getImg();
2269             int size = pOut->getSize();
2270             for (int i = 0 ; i < size ; i++)
2271             {
2272                 std::complex<double> dbl = _pL->getImg(0, 0);
2273                 pReal[i] += dbl.real();
2274                 pImg[i] += dbl.imag();
2275             }
2276         }
2277         else
2278         {
2279             double* pReal = pOut->get();
2280             int size = pOut->getSize();
2281             for (int i = 0 ; i < size ; i++)
2282             {
2283                 pReal[i] += _pL->get(0, 0);
2284             }
2285         }
2286
2287         return pOut;
2288     }
2289
2290
2291     if (_pL->getRows() == _pR->getRows() && _pL->getCols() == _pR->getCols())
2292     {
2293         //SP + D
2294         pOut = (Double*)_pR->clone();
2295         pOut->setComplex(bComplex1 | bComplex2);
2296
2297         int nonZeros = static_cast<int>(_pL->nonZeros());
2298         int* pRows = new int[nonZeros * 2];
2299         _pL->outputRowCol(pRows);
2300         int* pCols = pRows + nonZeros;
2301
2302         if (bComplex1)
2303         {
2304             for (int i = 0 ; i < nonZeros ; i++)
2305             {
2306                 int iRow = static_cast<int>(pRows[i]) - 1;
2307                 int iCol = static_cast<int>(pCols[i]) - 1;
2308                 std::complex<double> dbl = _pL->getImg(iRow, iCol);
2309                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) + dbl.real());
2310                 pOut->setImg(iRow, iCol, pOut->getImg(iRow, iCol) + dbl.imag());
2311             }
2312         }
2313         else
2314         {
2315             for (int i = 0 ; i < nonZeros ; i++)
2316             {
2317                 int iRow = static_cast<int>(pRows[i]) - 1;
2318                 int iCol = static_cast<int>(pCols[i]) - 1;
2319                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) + _pL->get(iRow, iCol));
2320             }
2321         }
2322
2323         //clear
2324         delete[] pRows;
2325         return pOut;
2326     }
2327     else
2328     {
2329         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
2330     }
2331 }
2332
2333 //[] + sp
2334 template<> InternalType* add_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
2335 {
2336     return add_M_M<Sparse, Double, Sparse>(_pR, _pL);
2337 }
2338
2339 //sp + []
2340 template<> InternalType* add_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
2341 {
2342     Sparse* pOut = NULL;
2343     if (_pR->isIdentity())
2344     {
2345         //convert to _pL
2346         Sparse* pS = new Sparse(_pL->getRows(), _pL->getCols(), _pR->isComplex());
2347         if (pS->isComplex())
2348         {
2349             int size = std::min(_pL->getRows(), _pL->getCols());
2350             for (int i = 0 ; i < size ; i++)
2351             {
2352                 pS->set(i, i, std::complex<double>(_pR->get(0), _pR->getImg(0)));
2353             }
2354         }
2355         else
2356         {
2357             int size = std::min(_pL->getRows(), _pL->getCols());
2358             for (int i = 0 ; i < size ; i++)
2359             {
2360                 pS->set(i, i, _pR->get(0));
2361             }
2362         }
2363
2364         AddSparseToSparse(_pL, pS, (Sparse**)pOut);
2365         delete pS;
2366         return pOut;
2367     }
2368     else
2369     {
2370         //is []
2371         return _pL;
2372     }
2373 }