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