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