Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_dotmultiplication.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 #include "types_dotmultiplication.hxx"
17 #include "double.hxx"
18 #include "int.hxx"
19 #include "sparse.hxx"
20 #include "polynom.hxx"
21
22
23 extern "C"
24 {
25 #include "localization.h"
26 }
27
28
29 using namespace types;
30 //define arrays on operation functions
31 static dotmul_function pDotMulfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
32
33 void fillDotMulFunction()
34 {
35 #define scilab_fill_dotmul(id1, id2, func, typeIn1, typeIn2, typeOut) \
36     pDotMulfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (dotmul_function)&dotmul_##func<typeIn1, typeIn2, typeOut>
37
38     //Double
39     //Matrix .* Matrix
40     scilab_fill_dotmul(Double, Double, M_M, Double, Double, Double);
41     scilab_fill_dotmul(Double, Int8, M_M, Double, Int8, Int8);
42     scilab_fill_dotmul(Double, UInt8, M_M, Double, UInt8, UInt8);
43     scilab_fill_dotmul(Double, Int16, M_M, Double, Int16, Int16);
44     scilab_fill_dotmul(Double, UInt16, M_M, Double, UInt16, UInt16);
45     scilab_fill_dotmul(Double, Int32, M_M, Double, Int32, Int32);
46     scilab_fill_dotmul(Double, UInt32, M_M, Double, UInt32, UInt32);
47     scilab_fill_dotmul(Double, Int64, M_M, Double, Int64, Int64);
48     scilab_fill_dotmul(Double, UInt64, M_M, Double, UInt64, UInt64);
49     scilab_fill_dotmul(Double, Bool, M_M, Double, Bool, Double);
50     scilab_fill_dotmul(Double, Polynom, M_M, Double, Polynom, Polynom);
51     scilab_fill_dotmul(Double, Sparse, M_M, Double, Sparse, Sparse);
52
53     //Matrix .* Matrix Complex
54     scilab_fill_dotmul(Double, DoubleComplex, M_MC, Double, Double, Double);
55     scilab_fill_dotmul(Double, PolynomComplex, M_M, Double, Polynom, Polynom);
56     scilab_fill_dotmul(Double, SparseComplex, M_M, Double, Sparse, Sparse);
57
58     //Matrix .* Scalar
59     scilab_fill_dotmul(Double, ScalarDouble, M_S, Double, Double, Double);
60     scilab_fill_dotmul(Double, ScalarInt8, M_S, Double, Int8, Int8);
61     scilab_fill_dotmul(Double, ScalarUInt8, M_S, Double, UInt8, UInt8);
62     scilab_fill_dotmul(Double, ScalarInt16, M_S, Double, Int16, Int16);
63     scilab_fill_dotmul(Double, ScalarUInt16, M_S, Double, UInt16, UInt16);
64     scilab_fill_dotmul(Double, ScalarInt32, M_S, Double, Int32, Int32);
65     scilab_fill_dotmul(Double, ScalarUInt32, M_S, Double, UInt32, UInt32);
66     scilab_fill_dotmul(Double, ScalarInt64, M_S, Double, Int64, Int64);
67     scilab_fill_dotmul(Double, ScalarUInt64, M_S, Double, UInt64, UInt64);
68     scilab_fill_dotmul(Double, ScalarBool, M_S, Double, Bool, Double);
69     scilab_fill_dotmul(Double, ScalarPolynom, M_M, Double, Polynom, Polynom);
70
71     //Matrix .* Scalar Complex
72     scilab_fill_dotmul(Double, ScalarDoubleComplex, M_SC, Double, Double, Double);
73     scilab_fill_dotmul(Double, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
74     //Matrix .* Empty
75     scilab_fill_dotmul(Double, Empty, M_E, Double, Double, Double);
76
77
78     //Matrix Complex .* Matrix
79     scilab_fill_dotmul(DoubleComplex, Double, MC_M, Double, Double, Double);
80     scilab_fill_dotmul(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Double);
81     scilab_fill_dotmul(DoubleComplex, ScalarDouble, MC_S, Double, Double, Double);
82     scilab_fill_dotmul(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Double);
83     scilab_fill_dotmul(DoubleComplex, Empty, M_E, Double, Double, Double);
84     scilab_fill_dotmul(DoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
85     scilab_fill_dotmul(DoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
86     scilab_fill_dotmul(DoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
87     scilab_fill_dotmul(DoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
88     scilab_fill_dotmul(DoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
89     scilab_fill_dotmul(DoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
90
91     //Scalar .* Matrix
92     scilab_fill_dotmul(ScalarDouble, Double, S_M, Double, Double, Double);
93     scilab_fill_dotmul(ScalarDouble, Int8, S_M, Double, Int8, Int8);
94     scilab_fill_dotmul(ScalarDouble, UInt8, S_M, Double, UInt8, UInt8);
95     scilab_fill_dotmul(ScalarDouble, Int16, S_M, Double, Int16, Int16);
96     scilab_fill_dotmul(ScalarDouble, UInt16, S_M, Double, UInt16, UInt16);
97     scilab_fill_dotmul(ScalarDouble, Int32, S_M, Double, Int32, Int32);
98     scilab_fill_dotmul(ScalarDouble, UInt32, S_M, Double, UInt32, UInt32);
99     scilab_fill_dotmul(ScalarDouble, Int64, S_M, Double, Int64, Int64);
100     scilab_fill_dotmul(ScalarDouble, UInt64, S_M, Double, UInt64, UInt64);
101     scilab_fill_dotmul(ScalarDouble, Bool, S_M, Double, Bool, Double);
102     scilab_fill_dotmul(ScalarDouble, Polynom, M_M, Double, Polynom, Polynom);
103     scilab_fill_dotmul(ScalarDouble, Sparse, M_M, Double, Sparse, Sparse);
104
105     //Scalar .* Matrix Complex
106     scilab_fill_dotmul(ScalarDouble, DoubleComplex, S_MC, Double, Double, Double);
107     scilab_fill_dotmul(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
108     scilab_fill_dotmul(ScalarDouble, SparseComplex, M_M, Double, Sparse, Sparse);
109
110     //Scalar .* Scalar
111     scilab_fill_dotmul(ScalarDouble, ScalarDouble, S_S, Double, Double, Double);
112     scilab_fill_dotmul(ScalarDouble, ScalarInt8, S_S, Double, Int8, Int8);
113     scilab_fill_dotmul(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, UInt8);
114     scilab_fill_dotmul(ScalarDouble, ScalarInt16, S_S, Double, Int16, Int16);
115     scilab_fill_dotmul(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, UInt16);
116     scilab_fill_dotmul(ScalarDouble, ScalarInt32, S_S, Double, Int32, Int32);
117     scilab_fill_dotmul(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, UInt32);
118     scilab_fill_dotmul(ScalarDouble, ScalarInt64, S_S, Double, Int64, Int64);
119     scilab_fill_dotmul(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, UInt64);
120     scilab_fill_dotmul(ScalarDouble, ScalarBool, S_S, Double, Bool, Double);
121     scilab_fill_dotmul(ScalarDouble, ScalarPolynom, M_M, Double, Polynom, Polynom);
122
123     //Scalar .* Scalar Complex
124     scilab_fill_dotmul(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Double);
125     scilab_fill_dotmul(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
126     scilab_fill_dotmul(ScalarDouble, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
127
128     //Scalar .* Empty
129     scilab_fill_dotmul(ScalarDouble, Empty, M_E, Double, Double, Double);
130
131     //Scalar Complex .* Matrix
132     scilab_fill_dotmul(ScalarDoubleComplex, Double, SC_M, Double, Double, Double);
133     scilab_fill_dotmul(ScalarDoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
134     scilab_fill_dotmul(ScalarDoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
135     //Scalar Complex .* Matrix Complex
136     scilab_fill_dotmul(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Double);
137     scilab_fill_dotmul(ScalarDoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
138     scilab_fill_dotmul(ScalarDoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
139     //Scalar Complex .* Scalar
140     scilab_fill_dotmul(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Double);
141     scilab_fill_dotmul(ScalarDoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
142     //Scalar Complex .* Scalar Complex
143     scilab_fill_dotmul(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Double);
144     scilab_fill_dotmul(ScalarDoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
145     //Scalar Complex .* Empty
146     scilab_fill_dotmul(ScalarDoubleComplex, Empty, M_E, Double, Double, Double);
147
148     //Empty .* Matrix
149     scilab_fill_dotmul(Empty, Double, E_M, Double, Double, Double);
150     scilab_fill_dotmul(Empty, Int8, E_M, Double, Int8, Double);
151     scilab_fill_dotmul(Empty, UInt8, E_M, Double, UInt8, Double);
152     scilab_fill_dotmul(Empty, Int16, E_M, Double, Int16, Double);
153     scilab_fill_dotmul(Empty, UInt16, E_M, Double, UInt16, Double);
154     scilab_fill_dotmul(Empty, Int32, E_M, Double, Int32, Double);
155     scilab_fill_dotmul(Empty, UInt32, E_M, Double, UInt32, Double);
156     scilab_fill_dotmul(Empty, Int64, E_M, Double, Int64, Double);
157     scilab_fill_dotmul(Empty, UInt64, E_M, Double, UInt64, Double);
158     scilab_fill_dotmul(Empty, Polynom, E_M, Double, Polynom, Double);
159     scilab_fill_dotmul(Empty, PolynomComplex, E_M, Double, Polynom, Double);
160     scilab_fill_dotmul(Empty, Sparse, E_M, Double, Sparse, Double);
161     scilab_fill_dotmul(Empty, SparseComplex, E_M, Double, Sparse, Double);
162
163     //Empty .* Matrix Complex
164     scilab_fill_dotmul(Empty, DoubleComplex, E_M, Double, Double, Double);
165     //Empty .* Scalar
166     scilab_fill_dotmul(Empty, ScalarDouble, E_M, Double, Double, Double);
167     scilab_fill_dotmul(Empty, ScalarInt8, E_M, Double, Int8, Double);
168     scilab_fill_dotmul(Empty, ScalarUInt8, E_M, Double, UInt8, Double);
169     scilab_fill_dotmul(Empty, ScalarInt16, E_M, Double, Int16, Double);
170     scilab_fill_dotmul(Empty, ScalarUInt16, E_M, Double, UInt16, Double);
171     scilab_fill_dotmul(Empty, ScalarInt32, E_M, Double, Int32, Double);
172     scilab_fill_dotmul(Empty, ScalarUInt32, E_M, Double, UInt32, Double);
173     scilab_fill_dotmul(Empty, ScalarInt64, E_M, Double, Int64, Double);
174     scilab_fill_dotmul(Empty, ScalarUInt64, E_M, Double, UInt64, Double);
175     scilab_fill_dotmul(Empty, ScalarBool, E_M, Double, Bool, Double);
176     scilab_fill_dotmul(Empty, ScalarPolynom, E_M, Double, Polynom, Double);
177
178     //Empty .* Scalar Complex
179     scilab_fill_dotmul(Empty, ScalarDoubleComplex, E_M, Double, Double, Double);
180     scilab_fill_dotmul(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Double);
181     //Empty .* Empty
182     scilab_fill_dotmul(Empty, Empty, E_M, Double, Double, Double);
183     //Empty .* eye
184     scilab_fill_dotmul(Empty, Identity, E_M, Double, Double, Double);
185     scilab_fill_dotmul(Empty, IdentityComplex, E_M, Double, Double, Double);
186
187     //Matrix .* Identity
188     scilab_fill_dotmul(Double, Identity, M_I, Double, Double, Double);
189     scilab_fill_dotmul(Double, IdentityComplex, M_IC, Double, Double, Double);
190     scilab_fill_dotmul(DoubleComplex, Identity, MC_I, Double, Double, Double);
191     scilab_fill_dotmul(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Double);
192     scilab_fill_dotmul(ScalarDouble, Identity, S_I, Double, Double, Double);
193     scilab_fill_dotmul(ScalarDouble, IdentityComplex, S_IC, Double, Double, Double);
194     scilab_fill_dotmul(ScalarDoubleComplex, Identity, SC_I, Double, Double, Double);
195     scilab_fill_dotmul(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Double);
196
197     //Int8
198     //Matrix .* Matrix
199     scilab_fill_dotmul(Int8, Double, M_M, Int8, Double, Int8);
200     scilab_fill_dotmul(Int8, Int8, M_M, Int8, Int8, Int8);
201     scilab_fill_dotmul(Int8, UInt8, M_M, Int8, UInt8, UInt8);
202     scilab_fill_dotmul(Int8, Int16, M_M, Int8, Int16, Int16);
203     scilab_fill_dotmul(Int8, UInt16, M_M, Int8, UInt16, UInt16);
204     scilab_fill_dotmul(Int8, Int32, M_M, Int8, Int32, Int32);
205     scilab_fill_dotmul(Int8, UInt32, M_M, Int8, UInt32, UInt32);
206     scilab_fill_dotmul(Int8, Int64, M_M, Int8, Int64, Int64);
207     scilab_fill_dotmul(Int8, UInt64, M_M, Int8, UInt64, UInt64);
208     scilab_fill_dotmul(Int8, Bool, M_M, Int8, Bool, Int8);
209     scilab_fill_dotmul(Int8, Empty, M_E, Int8, Double, Double);
210
211     //Matrix .* Scalar
212     scilab_fill_dotmul(Int8, ScalarDouble, M_S, Int8, Double, Int8);
213     scilab_fill_dotmul(Int8, ScalarInt8, M_S, Int8, Int8, Int8);
214     scilab_fill_dotmul(Int8, ScalarUInt8, M_S, Int8, UInt8, UInt8);
215     scilab_fill_dotmul(Int8, ScalarInt16, M_S, Int8, Int16, Int16);
216     scilab_fill_dotmul(Int8, ScalarUInt16, M_S, Int8, UInt16, UInt16);
217     scilab_fill_dotmul(Int8, ScalarInt32, M_S, Int8, Int32, Int32);
218     scilab_fill_dotmul(Int8, ScalarUInt32, M_S, Int8, UInt32, UInt32);
219     scilab_fill_dotmul(Int8, ScalarInt64, M_S, Int8, Int64, Int64);
220     scilab_fill_dotmul(Int8, ScalarUInt64, M_S, Int8, UInt64, UInt64);
221     scilab_fill_dotmul(Int8, ScalarBool, M_S, Int8, Bool, Int8);
222
223     //Scalar .* Matrix
224     scilab_fill_dotmul(ScalarInt8, Double, S_M, Int8, Double, Int8);
225     scilab_fill_dotmul(ScalarInt8, Int8, S_M, Int8, Int8, Int8);
226     scilab_fill_dotmul(ScalarInt8, UInt8, S_M, Int8, UInt8, UInt8);
227     scilab_fill_dotmul(ScalarInt8, Int16, S_M, Int8, Int16, Int16);
228     scilab_fill_dotmul(ScalarInt8, UInt16, S_M, Int8, UInt16, UInt16);
229     scilab_fill_dotmul(ScalarInt8, Int32, S_M, Int8, Int32, Int32);
230     scilab_fill_dotmul(ScalarInt8, UInt32, S_M, Int8, UInt32, UInt32);
231     scilab_fill_dotmul(ScalarInt8, Int64, S_M, Int8, Int64, Int64);
232     scilab_fill_dotmul(ScalarInt8, UInt64, S_M, Int8, UInt64, UInt64);
233     scilab_fill_dotmul(ScalarInt8, Bool, S_M, Int8, Bool, Int8);
234     scilab_fill_dotmul(ScalarInt8, Empty, M_E, Int8, Double, Double);
235
236     //Scalar .* Scalar
237     scilab_fill_dotmul(ScalarInt8, ScalarDouble, S_S, Int8, Double, Int8);
238     scilab_fill_dotmul(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Int8);
239     scilab_fill_dotmul(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, UInt8);
240     scilab_fill_dotmul(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Int16);
241     scilab_fill_dotmul(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, UInt16);
242     scilab_fill_dotmul(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Int32);
243     scilab_fill_dotmul(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, UInt32);
244     scilab_fill_dotmul(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Int64);
245     scilab_fill_dotmul(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, UInt64);
246     scilab_fill_dotmul(ScalarInt8, ScalarBool, S_S, Int8, Bool, Int8);
247
248     //UInt8
249     //Matrix .* Matrix
250     scilab_fill_dotmul(UInt8, Double, M_M, UInt8, Double, UInt8);
251     scilab_fill_dotmul(UInt8, Int8, M_M, UInt8, Int8, UInt8);
252     scilab_fill_dotmul(UInt8, UInt8, M_M, UInt8, UInt8, UInt8);
253     scilab_fill_dotmul(UInt8, Int16, M_M, UInt8, Int16, UInt16);
254     scilab_fill_dotmul(UInt8, UInt16, M_M, UInt8, UInt16, UInt16);
255     scilab_fill_dotmul(UInt8, Int32, M_M, UInt8, Int32, UInt32);
256     scilab_fill_dotmul(UInt8, UInt32, M_M, UInt8, UInt32, UInt32);
257     scilab_fill_dotmul(UInt8, Int64, M_M, UInt8, Int64, UInt64);
258     scilab_fill_dotmul(UInt8, UInt64, M_M, UInt8, UInt64, UInt64);
259     scilab_fill_dotmul(UInt8, Bool, M_M, UInt8, Bool, UInt8);
260     scilab_fill_dotmul(UInt8, Empty, M_E, UInt8, Double, Double);
261
262     //Matrix .* Scalar
263     scilab_fill_dotmul(UInt8, ScalarDouble, M_S, UInt8, Double, UInt8);
264     scilab_fill_dotmul(UInt8, ScalarInt8, M_S, UInt8, Int8, UInt8);
265     scilab_fill_dotmul(UInt8, ScalarUInt8, M_S, UInt8, UInt8, UInt8);
266     scilab_fill_dotmul(UInt8, ScalarInt16, M_S, UInt8, Int16, UInt16);
267     scilab_fill_dotmul(UInt8, ScalarUInt16, M_S, UInt8, UInt16, UInt16);
268     scilab_fill_dotmul(UInt8, ScalarInt32, M_S, UInt8, Int32, UInt32);
269     scilab_fill_dotmul(UInt8, ScalarUInt32, M_S, UInt8, UInt32, UInt32);
270     scilab_fill_dotmul(UInt8, ScalarInt64, M_S, UInt8, Int64, UInt64);
271     scilab_fill_dotmul(UInt8, ScalarUInt64, M_S, UInt8, UInt64, UInt64);
272     scilab_fill_dotmul(UInt8, ScalarBool, M_S, UInt8, Bool, UInt8);
273
274     //Scalar .* Matrix
275     scilab_fill_dotmul(ScalarUInt8, Double, S_M, UInt8, Double, UInt8);
276     scilab_fill_dotmul(ScalarUInt8, Int8, S_M, UInt8, Int8, UInt8);
277     scilab_fill_dotmul(ScalarUInt8, UInt8, S_M, UInt8, UInt8, UInt8);
278     scilab_fill_dotmul(ScalarUInt8, Int16, S_M, UInt8, Int16, UInt16);
279     scilab_fill_dotmul(ScalarUInt8, UInt16, S_M, UInt8, UInt16, UInt16);
280     scilab_fill_dotmul(ScalarUInt8, Int32, S_M, UInt8, Int32, UInt32);
281     scilab_fill_dotmul(ScalarUInt8, UInt32, S_M, UInt8, UInt32, UInt32);
282     scilab_fill_dotmul(ScalarUInt8, Int64, S_M, UInt8, Int64, UInt64);
283     scilab_fill_dotmul(ScalarUInt8, UInt64, S_M, UInt8, UInt64, UInt64);
284     scilab_fill_dotmul(ScalarUInt8, Bool, S_M, UInt8, Bool, UInt8);
285     scilab_fill_dotmul(ScalarUInt8, Empty, M_E, UInt8, Double, Double);
286
287     //Scalar .* Scalar
288     scilab_fill_dotmul(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, UInt8);
289     scilab_fill_dotmul(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, UInt8);
290     scilab_fill_dotmul(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, UInt8);
291     scilab_fill_dotmul(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, UInt16);
292     scilab_fill_dotmul(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, UInt16);
293     scilab_fill_dotmul(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, UInt32);
294     scilab_fill_dotmul(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, UInt32);
295     scilab_fill_dotmul(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, UInt64);
296     scilab_fill_dotmul(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, UInt64);
297     scilab_fill_dotmul(ScalarUInt8, ScalarBool, S_S, UInt8, Bool, UInt8);
298
299     //Int16
300     //Matrix .* Matrix
301     scilab_fill_dotmul(Int16, Double, M_M, Int16, Double, Int16);
302     scilab_fill_dotmul(Int16, Int8, M_M, Int16, Int8, Int16);
303     scilab_fill_dotmul(Int16, UInt8, M_M, Int16, UInt8, UInt16);
304     scilab_fill_dotmul(Int16, Int16, M_M, Int16, Int16, Int16);
305     scilab_fill_dotmul(Int16, UInt16, M_M, Int16, UInt16, UInt16);
306     scilab_fill_dotmul(Int16, Int32, M_M, Int16, Int32, Int32);
307     scilab_fill_dotmul(Int16, UInt32, M_M, Int16, UInt32, UInt32);
308     scilab_fill_dotmul(Int16, Int64, M_M, Int16, Int64, Int64);
309     scilab_fill_dotmul(Int16, UInt64, M_M, Int16, UInt64, UInt64);
310     scilab_fill_dotmul(Int16, Bool, M_M, Int16, Bool, Int16);
311     scilab_fill_dotmul(Int16, Empty, M_E, Int16, Double, Double);
312
313     //Matrix .* Scalar
314     scilab_fill_dotmul(Int16, ScalarDouble, M_S, Int16, Double, Int16);
315     scilab_fill_dotmul(Int16, ScalarInt8, M_S, Int16, Int8, Int16);
316     scilab_fill_dotmul(Int16, ScalarUInt8, M_S, Int16, UInt8, UInt16);
317     scilab_fill_dotmul(Int16, ScalarInt16, M_S, Int16, Int16, Int16);
318     scilab_fill_dotmul(Int16, ScalarUInt16, M_S, Int16, UInt16, UInt16);
319     scilab_fill_dotmul(Int16, ScalarInt32, M_S, Int16, Int32, Int32);
320     scilab_fill_dotmul(Int16, ScalarUInt32, M_S, Int16, UInt32, UInt32);
321     scilab_fill_dotmul(Int16, ScalarInt64, M_S, Int16, Int64, Int64);
322     scilab_fill_dotmul(Int16, ScalarUInt64, M_S, Int16, UInt64, UInt64);
323     scilab_fill_dotmul(Int16, ScalarBool, M_E, Int16, Bool, Int16);
324
325     //Scalar .* Matrix
326     scilab_fill_dotmul(ScalarInt16, Double, S_M, Int16, Double, Int16);
327     scilab_fill_dotmul(ScalarInt16, Int8, S_M, Int16, Int8, Int16);
328     scilab_fill_dotmul(ScalarInt16, UInt8, S_M, Int16, UInt8, UInt16);
329     scilab_fill_dotmul(ScalarInt16, Int16, S_M, Int16, Int16, Int16);
330     scilab_fill_dotmul(ScalarInt16, UInt16, S_M, Int16, UInt16, UInt16);
331     scilab_fill_dotmul(ScalarInt16, Int32, S_M, Int16, Int32, Int32);
332     scilab_fill_dotmul(ScalarInt16, UInt32, S_M, Int16, UInt32, UInt32);
333     scilab_fill_dotmul(ScalarInt16, Int64, S_M, Int16, Int64, Int64);
334     scilab_fill_dotmul(ScalarInt16, UInt64, S_M, Int16, UInt64, UInt64);
335     scilab_fill_dotmul(ScalarInt16, Bool, S_M, Int16, Bool, Int16);
336     scilab_fill_dotmul(ScalarInt16, Empty, M_E, Int16, Double, Double);
337
338     //Scalar .* Scalar
339     scilab_fill_dotmul(ScalarInt16, ScalarDouble, S_S, Int16, Double, Int16);
340     scilab_fill_dotmul(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Int16);
341     scilab_fill_dotmul(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, UInt16);
342     scilab_fill_dotmul(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Int16);
343     scilab_fill_dotmul(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, UInt16);
344     scilab_fill_dotmul(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Int32);
345     scilab_fill_dotmul(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, UInt32);
346     scilab_fill_dotmul(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Int64);
347     scilab_fill_dotmul(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, UInt64);
348     scilab_fill_dotmul(ScalarInt16, ScalarBool, S_S, Int16, Bool, Int16);
349
350     //UInt16
351     //Matrix .* Matrix
352     scilab_fill_dotmul(UInt16, Double, M_M, UInt16, Double, UInt16);
353     scilab_fill_dotmul(UInt16, Int8, M_M, UInt16, Int8, UInt16);
354     scilab_fill_dotmul(UInt16, UInt8, M_M, UInt16, UInt8, UInt16);
355     scilab_fill_dotmul(UInt16, Int16, M_M, UInt16, Int16, UInt16);
356     scilab_fill_dotmul(UInt16, UInt16, M_M, UInt16, UInt16, UInt16);
357     scilab_fill_dotmul(UInt16, Int32, M_M, UInt16, Int32, UInt32);
358     scilab_fill_dotmul(UInt16, UInt32, M_M, UInt16, UInt32, UInt32);
359     scilab_fill_dotmul(UInt16, Int64, M_M, UInt16, Int64, UInt64);
360     scilab_fill_dotmul(UInt16, UInt64, M_M, UInt16, UInt64, UInt64);
361     scilab_fill_dotmul(UInt16, Bool, M_M, UInt16, Bool, UInt16);
362     scilab_fill_dotmul(UInt16, Empty, M_E, UInt16, Double, Double);
363
364     //Matrix .* Scalar
365     scilab_fill_dotmul(UInt16, ScalarDouble, M_S, UInt16, Double, UInt16);
366     scilab_fill_dotmul(UInt16, ScalarInt8, M_S, UInt16, Int8, UInt16);
367     scilab_fill_dotmul(UInt16, ScalarUInt8, M_S, UInt16, UInt8, UInt16);
368     scilab_fill_dotmul(UInt16, ScalarInt16, M_S, UInt16, Int16, UInt16);
369     scilab_fill_dotmul(UInt16, ScalarUInt16, M_S, UInt16, UInt16, UInt16);
370     scilab_fill_dotmul(UInt16, ScalarInt32, M_S, UInt16, Int32, UInt32);
371     scilab_fill_dotmul(UInt16, ScalarUInt32, M_S, UInt16, UInt32, UInt32);
372     scilab_fill_dotmul(UInt16, ScalarInt64, M_S, UInt16, Int64, UInt64);
373     scilab_fill_dotmul(UInt16, ScalarUInt64, M_S, UInt16, UInt64, UInt64);
374     scilab_fill_dotmul(UInt16, ScalarBool, M_S, UInt16, Bool, UInt16);
375
376     //Scalar .* Matrix
377     scilab_fill_dotmul(ScalarUInt16, Double, S_M, UInt16, Double, UInt16);
378     scilab_fill_dotmul(ScalarUInt16, Int8, S_M, UInt16, Int8, UInt16);
379     scilab_fill_dotmul(ScalarUInt16, UInt8, S_M, UInt16, UInt8, UInt16);
380     scilab_fill_dotmul(ScalarUInt16, Int16, S_M, UInt16, Int16, UInt16);
381     scilab_fill_dotmul(ScalarUInt16, UInt16, S_M, UInt16, UInt16, UInt16);
382     scilab_fill_dotmul(ScalarUInt16, Int32, S_M, UInt16, Int32, UInt32);
383     scilab_fill_dotmul(ScalarUInt16, UInt32, S_M, UInt16, UInt32, UInt32);
384     scilab_fill_dotmul(ScalarUInt16, Int64, S_M, UInt16, Int64, UInt64);
385     scilab_fill_dotmul(ScalarUInt16, UInt64, S_M, UInt16, UInt64, UInt64);
386     scilab_fill_dotmul(ScalarUInt16, Bool, S_M, UInt16, Bool, UInt16);
387     scilab_fill_dotmul(ScalarUInt16, Empty, S_M, UInt16, Double, UInt16);
388
389     //Scalar .* Scalar
390     scilab_fill_dotmul(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, UInt16);
391     scilab_fill_dotmul(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, UInt16);
392     scilab_fill_dotmul(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, UInt16);
393     scilab_fill_dotmul(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, UInt16);
394     scilab_fill_dotmul(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, UInt16);
395     scilab_fill_dotmul(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, UInt32);
396     scilab_fill_dotmul(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, UInt32);
397     scilab_fill_dotmul(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, UInt64);
398     scilab_fill_dotmul(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, UInt64);
399     scilab_fill_dotmul(ScalarUInt16, ScalarBool, S_S, UInt16, Bool, UInt16);
400
401     //Int32
402     //Matrix .* Matrix
403     scilab_fill_dotmul(Int32, Double, M_M, Int32, Double, Int32);
404     scilab_fill_dotmul(Int32, Int8, M_M, Int32, Int8, Int32);
405     scilab_fill_dotmul(Int32, UInt8, M_M, Int32, UInt8, UInt32);
406     scilab_fill_dotmul(Int32, Int16, M_M, Int32, Int16, Int32);
407     scilab_fill_dotmul(Int32, UInt16, M_M, Int32, UInt16, UInt32);
408     scilab_fill_dotmul(Int32, Int32, M_M, Int32, Int32, Int32);
409     scilab_fill_dotmul(Int32, UInt32, M_M, Int32, UInt32, UInt32);
410     scilab_fill_dotmul(Int32, Int64, M_M, Int32, Int64, Int64);
411     scilab_fill_dotmul(Int32, UInt64, M_M, Int32, UInt64, UInt64);
412     scilab_fill_dotmul(Int32, Bool, M_M, Int32, Bool, Int32);
413     scilab_fill_dotmul(Int32, Empty, M_E, Int32, Double, Double);
414
415     //Matrix .* Scalar
416     scilab_fill_dotmul(Int32, ScalarDouble, M_S, Int32, Double, Int32);
417     scilab_fill_dotmul(Int32, ScalarInt8, M_S, Int32, Int8, Int32);
418     scilab_fill_dotmul(Int32, ScalarUInt8, M_S, Int32, UInt8, UInt32);
419     scilab_fill_dotmul(Int32, ScalarInt16, M_S, Int32, Int16, Int32);
420     scilab_fill_dotmul(Int32, ScalarUInt16, M_S, Int32, UInt16, UInt32);
421     scilab_fill_dotmul(Int32, ScalarInt32, M_S, Int32, Int32, Int32);
422     scilab_fill_dotmul(Int32, ScalarUInt32, M_S, Int32, UInt32, UInt32);
423     scilab_fill_dotmul(Int32, ScalarInt64, M_S, Int32, Int64, Int64);
424     scilab_fill_dotmul(Int32, ScalarUInt64, M_S, Int32, UInt64, UInt64);
425     scilab_fill_dotmul(Int32, ScalarBool, M_S, Int32, Bool, Int32);
426
427     //Scalar .* Matrix
428     scilab_fill_dotmul(ScalarInt32, Double, S_M, Int32, Double, Int32);
429     scilab_fill_dotmul(ScalarInt32, Int8, S_M, Int32, Int8, Int32);
430     scilab_fill_dotmul(ScalarInt32, UInt8, S_M, Int32, UInt8, UInt32);
431     scilab_fill_dotmul(ScalarInt32, Int16, S_M, Int32, Int16, Int32);
432     scilab_fill_dotmul(ScalarInt32, UInt16, S_M, Int32, UInt16, UInt32);
433     scilab_fill_dotmul(ScalarInt32, Int32, S_M, Int32, Int32, Int32);
434     scilab_fill_dotmul(ScalarInt32, UInt32, S_M, Int32, UInt32, UInt32);
435     scilab_fill_dotmul(ScalarInt32, Int64, S_M, Int32, Int64, Int64);
436     scilab_fill_dotmul(ScalarInt32, UInt64, S_M, Int32, UInt64, UInt64);
437     scilab_fill_dotmul(ScalarInt32, Bool, S_M, Int32, Bool, Int32);
438     scilab_fill_dotmul(ScalarInt32, Empty, M_E, Int32, Double, Double);
439
440     //Scalar .* Scalar
441     scilab_fill_dotmul(ScalarInt32, ScalarDouble, S_S, Int32, Double, Int32);
442     scilab_fill_dotmul(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Int32);
443     scilab_fill_dotmul(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, UInt32);
444     scilab_fill_dotmul(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Int32);
445     scilab_fill_dotmul(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, UInt32);
446     scilab_fill_dotmul(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Int32);
447     scilab_fill_dotmul(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, UInt32);
448     scilab_fill_dotmul(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Int64);
449     scilab_fill_dotmul(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, UInt64);
450     scilab_fill_dotmul(ScalarInt32, ScalarBool, S_S, Int32, Bool, Int32);
451
452     //UInt32
453     //Matrix .* Matrix
454     scilab_fill_dotmul(UInt32, Double, M_M, UInt32, Double, UInt32);
455     scilab_fill_dotmul(UInt32, Int8, M_M, UInt32, Int8, UInt32);
456     scilab_fill_dotmul(UInt32, UInt8, M_M, UInt32, UInt8, UInt32);
457     scilab_fill_dotmul(UInt32, Int16, M_M, UInt32, Int16, UInt32);
458     scilab_fill_dotmul(UInt32, UInt16, M_M, UInt32, UInt16, UInt32);
459     scilab_fill_dotmul(UInt32, Int32, M_M, UInt32, Int32, UInt32);
460     scilab_fill_dotmul(UInt32, UInt32, M_M, UInt32, UInt32, UInt32);
461     scilab_fill_dotmul(UInt32, Int64, M_M, UInt32, Int64, UInt64);
462     scilab_fill_dotmul(UInt32, UInt64, M_M, UInt32, UInt64, UInt64);
463     scilab_fill_dotmul(UInt32, Bool, M_M, UInt32, Bool, UInt32);
464     scilab_fill_dotmul(UInt32, Empty, M_E, UInt32, Double, Double);
465
466     //Matrix .* Scalar
467     scilab_fill_dotmul(UInt32, ScalarDouble, M_S, UInt32, Double, UInt32);
468     scilab_fill_dotmul(UInt32, ScalarInt8, M_S, UInt32, Int8, UInt32);
469     scilab_fill_dotmul(UInt32, ScalarUInt8, M_S, UInt32, UInt8, UInt32);
470     scilab_fill_dotmul(UInt32, ScalarInt16, M_S, UInt32, Int16, UInt32);
471     scilab_fill_dotmul(UInt32, ScalarUInt16, M_S, UInt32, UInt16, UInt32);
472     scilab_fill_dotmul(UInt32, ScalarInt32, M_S, UInt32, Int32, UInt32);
473     scilab_fill_dotmul(UInt32, ScalarUInt32, M_S, UInt32, UInt32, UInt32);
474     scilab_fill_dotmul(UInt32, ScalarInt64, M_S, UInt32, Int64, UInt64);
475     scilab_fill_dotmul(UInt32, ScalarUInt64, M_S, UInt32, UInt64, UInt64);
476     scilab_fill_dotmul(UInt32, ScalarBool, M_S, UInt32, Bool, UInt32);
477
478     //Scalar .* Matrix
479     scilab_fill_dotmul(ScalarUInt32, Double, S_M, UInt32, Double, UInt32);
480     scilab_fill_dotmul(ScalarUInt32, Int8, S_M, UInt32, Int8, UInt32);
481     scilab_fill_dotmul(ScalarUInt32, UInt8, S_M, UInt32, UInt8, UInt32);
482     scilab_fill_dotmul(ScalarUInt32, Int16, S_M, UInt32, Int16, UInt32);
483     scilab_fill_dotmul(ScalarUInt32, UInt16, S_M, UInt32, UInt16, UInt32);
484     scilab_fill_dotmul(ScalarUInt32, Int32, S_M, UInt32, Int32, UInt32);
485     scilab_fill_dotmul(ScalarUInt32, UInt32, S_M, UInt32, UInt32, UInt32);
486     scilab_fill_dotmul(ScalarUInt32, Int64, S_M, UInt32, Int64, UInt64);
487     scilab_fill_dotmul(ScalarUInt32, UInt64, S_M, UInt32, UInt64, UInt64);
488     scilab_fill_dotmul(ScalarUInt32, Bool, S_M, UInt32, Bool, UInt32);
489     scilab_fill_dotmul(ScalarUInt32, Empty, S_M, UInt32, Double, UInt32);
490
491     //Scalar .* Scalar
492     scilab_fill_dotmul(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, UInt32);
493     scilab_fill_dotmul(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, UInt32);
494     scilab_fill_dotmul(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, UInt32);
495     scilab_fill_dotmul(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, UInt32);
496     scilab_fill_dotmul(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, UInt32);
497     scilab_fill_dotmul(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, UInt32);
498     scilab_fill_dotmul(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, UInt32);
499     scilab_fill_dotmul(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, UInt64);
500     scilab_fill_dotmul(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, UInt64);
501     scilab_fill_dotmul(ScalarUInt32, ScalarBool, S_S, UInt32, Bool, UInt32);
502
503     //Int64
504     //Matrix .* Matrix
505     scilab_fill_dotmul(Int64, Double, M_M, Int64, Double, Int64);
506     scilab_fill_dotmul(Int64, Int8, M_M, Int64, Int8, Int64);
507     scilab_fill_dotmul(Int64, UInt8, M_M, Int64, UInt8, UInt64);
508     scilab_fill_dotmul(Int64, Int16, M_M, Int64, Int16, Int64);
509     scilab_fill_dotmul(Int64, UInt16, M_M, Int64, UInt16, UInt64);
510     scilab_fill_dotmul(Int64, Int32, M_M, Int64, Int32, Int64);
511     scilab_fill_dotmul(Int64, UInt32, M_M, Int64, UInt32, UInt64);
512     scilab_fill_dotmul(Int64, Int64, M_M, Int64, Int64, Int64);
513     scilab_fill_dotmul(Int64, UInt64, M_M, Int64, UInt64, UInt64);
514     scilab_fill_dotmul(Int64, Bool, M_M, Int64, Bool, Int64);
515     scilab_fill_dotmul(Int64, Empty, M_E, Int64, Double, Double);
516
517     //Matrix .* Scalar
518     scilab_fill_dotmul(Int64, ScalarDouble, M_S, Int64, Double, Int64);
519     scilab_fill_dotmul(Int64, ScalarInt8, M_S, Int64, Int8, Int64);
520     scilab_fill_dotmul(Int64, ScalarUInt8, M_S, Int64, UInt8, UInt64);
521     scilab_fill_dotmul(Int64, ScalarInt16, M_S, Int64, Int16, Int64);
522     scilab_fill_dotmul(Int64, ScalarUInt16, M_S, Int64, UInt16, UInt64);
523     scilab_fill_dotmul(Int64, ScalarInt32, M_S, Int64, Int32, Int64);
524     scilab_fill_dotmul(Int64, ScalarUInt32, M_S, Int64, UInt32, UInt64);
525     scilab_fill_dotmul(Int64, ScalarInt64, M_S, Int64, Int64, Int64);
526     scilab_fill_dotmul(Int64, ScalarUInt64, M_S, Int64, UInt64, UInt64);
527     scilab_fill_dotmul(Int64, ScalarBool, M_S, Int64, Bool, Int64);
528
529     //Scalar .* Matrix
530     scilab_fill_dotmul(ScalarInt64, Double, S_M, Int64, Double, Int64);
531     scilab_fill_dotmul(ScalarInt64, Int8, S_M, Int64, Int8, Int64);
532     scilab_fill_dotmul(ScalarInt64, UInt8, S_M, Int64, UInt8, UInt64);
533     scilab_fill_dotmul(ScalarInt64, Int16, S_M, Int64, Int16, Int64);
534     scilab_fill_dotmul(ScalarInt64, UInt16, S_M, Int64, UInt16, UInt64);
535     scilab_fill_dotmul(ScalarInt64, Int32, S_M, Int64, Int32, Int64);
536     scilab_fill_dotmul(ScalarInt64, UInt32, S_M, Int64, UInt32, UInt64);
537     scilab_fill_dotmul(ScalarInt64, Int64, S_M, Int64, Int64, Int64);
538     scilab_fill_dotmul(ScalarInt64, UInt64, S_M, Int64, UInt64, UInt64);
539     scilab_fill_dotmul(ScalarInt64, Bool, S_M, Int64, Bool, Int64);
540     scilab_fill_dotmul(ScalarInt64, Empty, M_E, Int64, Double, Double);
541
542     //Scalar .* Scalar
543     scilab_fill_dotmul(ScalarInt64, ScalarDouble, S_S, Int64, Double, Int64);
544     scilab_fill_dotmul(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Int64);
545     scilab_fill_dotmul(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, UInt64);
546     scilab_fill_dotmul(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Int64);
547     scilab_fill_dotmul(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, UInt64);
548     scilab_fill_dotmul(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Int64);
549     scilab_fill_dotmul(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, UInt64);
550     scilab_fill_dotmul(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Int64);
551     scilab_fill_dotmul(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, UInt64);
552     scilab_fill_dotmul(ScalarInt64, ScalarBool, S_S, Int64, Bool, Int64);
553
554     //UInt64
555     //Matrix .* Matrix
556     scilab_fill_dotmul(UInt64, Double, M_M, UInt64, Double, UInt64);
557     scilab_fill_dotmul(UInt64, Int8, M_M, UInt64, Int8, UInt64);
558     scilab_fill_dotmul(UInt64, UInt8, M_M, UInt64, UInt8, UInt64);
559     scilab_fill_dotmul(UInt64, Int16, M_M, UInt64, Int16, UInt64);
560     scilab_fill_dotmul(UInt64, UInt16, M_M, UInt64, UInt16, UInt64);
561     scilab_fill_dotmul(UInt64, Int32, M_M, UInt64, Int32, UInt64);
562     scilab_fill_dotmul(UInt64, UInt32, M_M, UInt64, UInt32, UInt64);
563     scilab_fill_dotmul(UInt64, Int64, M_M, UInt64, Int64, UInt64);
564     scilab_fill_dotmul(UInt64, UInt64, M_M, UInt64, UInt64, UInt64);
565     scilab_fill_dotmul(UInt64, Bool, M_M, UInt64, Bool, UInt64);
566     scilab_fill_dotmul(UInt64, Empty, M_E, UInt64, Double, Double);
567
568     //Matrix .* Scalar
569     scilab_fill_dotmul(UInt64, ScalarDouble, M_S, UInt64, Double, UInt64);
570     scilab_fill_dotmul(UInt64, ScalarInt8, M_S, UInt64, Int8, UInt64);
571     scilab_fill_dotmul(UInt64, ScalarUInt8, M_S, UInt64, UInt8, UInt64);
572     scilab_fill_dotmul(UInt64, ScalarInt16, M_S, UInt64, Int16, UInt64);
573     scilab_fill_dotmul(UInt64, ScalarUInt16, M_S, UInt64, UInt16, UInt64);
574     scilab_fill_dotmul(UInt64, ScalarInt32, M_S, UInt64, Int32, UInt64);
575     scilab_fill_dotmul(UInt64, ScalarUInt32, M_S, UInt64, UInt32, UInt64);
576     scilab_fill_dotmul(UInt64, ScalarInt64, M_S, UInt64, Int64, UInt64);
577     scilab_fill_dotmul(UInt64, ScalarUInt64, M_S, UInt64, UInt64, UInt64);
578     scilab_fill_dotmul(UInt64, ScalarBool, M_S, UInt64, Bool, UInt64);
579
580     //Scalar .* Matrix
581     scilab_fill_dotmul(ScalarUInt64, Double, S_M, UInt64, Double, UInt64);
582     scilab_fill_dotmul(ScalarUInt64, Int8, S_M, UInt64, Int8, UInt64);
583     scilab_fill_dotmul(ScalarUInt64, UInt8, S_M, UInt64, UInt8, UInt64);
584     scilab_fill_dotmul(ScalarUInt64, Int16, S_M, UInt64, Int16, UInt64);
585     scilab_fill_dotmul(ScalarUInt64, UInt16, S_M, UInt64, UInt16, UInt64);
586     scilab_fill_dotmul(ScalarUInt64, Int32, S_M, UInt64, Int32, UInt64);
587     scilab_fill_dotmul(ScalarUInt64, UInt32, S_M, UInt64, UInt32, UInt64);
588     scilab_fill_dotmul(ScalarUInt64, Int64, S_M, UInt64, Int64, UInt64);
589     scilab_fill_dotmul(ScalarUInt64, UInt64, S_M, UInt64, UInt64, UInt64);
590     scilab_fill_dotmul(ScalarUInt64, Bool, S_M, UInt64, Bool, UInt64);
591     scilab_fill_dotmul(ScalarUInt64, Empty, S_M, UInt64, Double, UInt64);
592
593     //Scalar .* Scalar
594     scilab_fill_dotmul(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, UInt64);
595     scilab_fill_dotmul(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, UInt64);
596     scilab_fill_dotmul(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, UInt64);
597     scilab_fill_dotmul(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, UInt64);
598     scilab_fill_dotmul(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, UInt64);
599     scilab_fill_dotmul(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, UInt64);
600     scilab_fill_dotmul(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, UInt64);
601     scilab_fill_dotmul(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, UInt64);
602     scilab_fill_dotmul(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, UInt64);
603     scilab_fill_dotmul(ScalarUInt64, ScalarBool, S_S, UInt64, Bool, UInt64);
604
605     //Bool
606     //Matrix + Matrix
607     scilab_fill_dotmul(Bool, Double, M_M, Bool, Double, Double);
608     scilab_fill_dotmul(Bool, Int8, M_M, Bool, Int8, Int8);
609     scilab_fill_dotmul(Bool, UInt8, M_M, Bool, UInt8, UInt8);
610     scilab_fill_dotmul(Bool, Int16, M_M, Bool, Int16, Int16);
611     scilab_fill_dotmul(Bool, UInt16, M_M, Bool, UInt16, UInt16);
612     scilab_fill_dotmul(Bool, Int32, M_M, Bool, Int32, Int32);
613     scilab_fill_dotmul(Bool, UInt32, M_M, Bool, UInt32, UInt32);
614     scilab_fill_dotmul(Bool, Int64, M_M, Bool, Int64, Int64);
615     scilab_fill_dotmul(Bool, UInt64, M_M, Bool, UInt64, UInt64);
616     scilab_fill_dotmul(Bool, Bool, M_M, Bool, Bool, Double);
617     scilab_fill_dotmul(Bool, Empty, M_E, Bool, Double, Double);
618
619     //Matrix + Scalar
620     scilab_fill_dotmul(Bool, ScalarDouble, M_S, Bool, Double, Double);
621     scilab_fill_dotmul(Bool, ScalarInt8, M_S, Bool, Int8, Int8);
622     scilab_fill_dotmul(Bool, ScalarUInt8, M_S, Bool, UInt8, UInt8);
623     scilab_fill_dotmul(Bool, ScalarInt16, M_S, Bool, Int16, Int16);
624     scilab_fill_dotmul(Bool, ScalarUInt16, M_S, Bool, UInt16, UInt16);
625     scilab_fill_dotmul(Bool, ScalarInt32, M_S, Bool, Int32, Int32);
626     scilab_fill_dotmul(Bool, ScalarUInt32, M_S, Bool, UInt32, UInt32);
627     scilab_fill_dotmul(Bool, ScalarInt64, M_S, Bool, Int64, Int64);
628     scilab_fill_dotmul(Bool, ScalarUInt64, M_S, Bool, UInt64, UInt64);
629     scilab_fill_dotmul(Bool, ScalarBool, M_S, Bool, Bool, Double);
630
631     //Scalar + Matrix
632     scilab_fill_dotmul(ScalarBool, Double, S_M, Bool, Double, Double);
633     scilab_fill_dotmul(ScalarBool, Int8, S_M, Bool, Int8, Int8);
634     scilab_fill_dotmul(ScalarBool, UInt8, S_M, Bool, UInt8, UInt8);
635     scilab_fill_dotmul(ScalarBool, Int16, S_M, Bool, Int16, Int16);
636     scilab_fill_dotmul(ScalarBool, UInt16, S_M, Bool, UInt16, UInt16);
637     scilab_fill_dotmul(ScalarBool, Int32, S_M, Bool, Int32, Int32);
638     scilab_fill_dotmul(ScalarBool, UInt32, S_M, Bool, UInt32, UInt32);
639     scilab_fill_dotmul(ScalarBool, Int64, S_M, Bool, Int64, Int64);
640     scilab_fill_dotmul(ScalarBool, UInt64, S_M, Bool, UInt64, UInt64);
641     scilab_fill_dotmul(ScalarBool, Bool, S_M, Bool, Bool, Double);
642     scilab_fill_dotmul(ScalarBool, Empty, M_E, Bool, Double, Double);
643
644     //Scalar + Scalar
645     scilab_fill_dotmul(ScalarBool, ScalarDouble, S_S, Bool, Double, Double);
646     scilab_fill_dotmul(ScalarBool, ScalarInt8, S_S, Bool, Int8, Int8);
647     scilab_fill_dotmul(ScalarBool, ScalarUInt8, S_S, Bool, UInt8, UInt8);
648     scilab_fill_dotmul(ScalarBool, ScalarInt16, S_S, Bool, Int16, Int16);
649     scilab_fill_dotmul(ScalarBool, ScalarUInt16, S_S, Bool, UInt16, UInt16);
650     scilab_fill_dotmul(ScalarBool, ScalarInt32, S_S, Bool, Int32, Int32);
651     scilab_fill_dotmul(ScalarBool, ScalarUInt32, S_S, Bool, UInt32, UInt32);
652     scilab_fill_dotmul(ScalarBool, ScalarInt64, S_S, Bool, Int64, Int64);
653     scilab_fill_dotmul(ScalarBool, ScalarUInt64, S_S, Bool, UInt64, UInt64);
654     scilab_fill_dotmul(ScalarBool, ScalarBool, S_S, Bool, Bool, Double);
655
656     //Identity
657     scilab_fill_dotmul(Identity, Double, I_M, Double, Double, Double);
658     scilab_fill_dotmul(Identity, DoubleComplex, I_MC, Double, Double, Double);
659     scilab_fill_dotmul(Identity, ScalarDouble, I_S, Double, Double, Double);
660     scilab_fill_dotmul(Identity, ScalarDoubleComplex, I_SC, Double, Double, Double);
661     scilab_fill_dotmul(Identity, Identity, I_I, Double, Double, Double);
662     scilab_fill_dotmul(Identity, IdentityComplex, I_IC, Double, Double, Double);
663     scilab_fill_dotmul(Identity, Empty, M_E, Double, Double, Double);
664
665     scilab_fill_dotmul(Identity, Polynom, M_M, Double, Polynom, Polynom);
666     scilab_fill_dotmul(Identity, PolynomComplex, M_M, Double, Polynom, Polynom);
667     scilab_fill_dotmul(Identity, ScalarPolynom, M_M, Double, Polynom, Polynom);
668     scilab_fill_dotmul(Identity, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
669     //scilab_fill_dotmul(Identity, Sparse, M_M, Double, Sparse, Sparse);
670     //scilab_fill_dotmul(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
671
672     scilab_fill_dotmul(IdentityComplex, Double, IC_M, Double, Double, Double);
673     scilab_fill_dotmul(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
674     scilab_fill_dotmul(IdentityComplex, ScalarDouble, IC_S, Double, Double, Double);
675     scilab_fill_dotmul(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Double);
676     scilab_fill_dotmul(IdentityComplex, Identity, IC_I, Double, Double, Double);
677     scilab_fill_dotmul(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Double);
678     scilab_fill_dotmul(IdentityComplex, Empty, M_E, Double, Double, Double);
679
680     scilab_fill_dotmul(IdentityComplex, Polynom, M_M, Double, Polynom, Polynom);
681     scilab_fill_dotmul(IdentityComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
682     scilab_fill_dotmul(IdentityComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
683     scilab_fill_dotmul(IdentityComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
684     //scilab_fill_dotmul(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
685     //scilab_fill_dotmul(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
686
687     //Polynom
688
689     //poly + poly
690     scilab_fill_dotmul(Polynom, Polynom, M_M, Polynom, Polynom, Polynom);
691     scilab_fill_dotmul(Polynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
692     scilab_fill_dotmul(PolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
693     scilab_fill_dotmul(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
694
695     //poly + scalar poly
696     scilab_fill_dotmul(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
697     scilab_fill_dotmul(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
698     scilab_fill_dotmul(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
699     scilab_fill_dotmul(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
700
701     //poly + double
702     scilab_fill_dotmul(Polynom, Double, M_M, Polynom, Double, Polynom);
703     scilab_fill_dotmul(Polynom, DoubleComplex, M_M, Polynom, Double, Polynom);
704     scilab_fill_dotmul(PolynomComplex, Double, M_M, Polynom, Double, Polynom);
705     scilab_fill_dotmul(PolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
706
707     //poly + scalar double
708     scilab_fill_dotmul(Polynom, ScalarDouble, M_M, Polynom, Double, Polynom);
709     scilab_fill_dotmul(Polynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
710     scilab_fill_dotmul(PolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
711     scilab_fill_dotmul(PolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
712
713     //poly + []
714     scilab_fill_dotmul(Polynom, Empty, M_E, Polynom, Double, Double);
715     scilab_fill_dotmul(PolynomComplex, Empty, M_E, Polynom, Double, Double);
716
717     //poly + eye
718     scilab_fill_dotmul(Polynom, Identity, M_M, Polynom, Double, Polynom);
719     scilab_fill_dotmul(Polynom, IdentityComplex, M_M, Polynom, Double, Polynom);
720     scilab_fill_dotmul(PolynomComplex, Identity, M_M, Polynom, Double, Polynom);
721     scilab_fill_dotmul(PolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
722
723     //scalar poly + poly
724     scilab_fill_dotmul(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Polynom);
725     scilab_fill_dotmul(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
726     scilab_fill_dotmul(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
727     scilab_fill_dotmul(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
728
729     //scalar poly + scalar poly
730     scilab_fill_dotmul(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
731     scilab_fill_dotmul(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
732     scilab_fill_dotmul(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
733     scilab_fill_dotmul(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
734
735     //scalar poly + double
736     scilab_fill_dotmul(ScalarPolynom, Double, M_M, Polynom, Double, Polynom);
737     scilab_fill_dotmul(ScalarPolynom, DoubleComplex, M_M, Polynom, Double, Polynom);
738     scilab_fill_dotmul(ScalarPolynomComplex, Double, M_M, Polynom, Double, Polynom);
739     scilab_fill_dotmul(ScalarPolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
740
741     //scalar poly + scalar double
742     scilab_fill_dotmul(ScalarPolynom, ScalarDouble, M_M, Polynom, Double, Polynom);
743     scilab_fill_dotmul(ScalarPolynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
744     scilab_fill_dotmul(ScalarPolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
745     scilab_fill_dotmul(ScalarPolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
746
747     //scalar poly + []
748     scilab_fill_dotmul(ScalarPolynom, Empty, M_E, Polynom, Double, Double);
749     scilab_fill_dotmul(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Double);
750
751     //scalar poly + eye
752     scilab_fill_dotmul(ScalarPolynom, Identity, M_M, Polynom, Double, Polynom);
753     scilab_fill_dotmul(ScalarPolynom, IdentityComplex, M_M, Polynom, Double, Polynom);
754     scilab_fill_dotmul(ScalarPolynomComplex, Identity, M_M, Polynom, Double, Polynom);
755     scilab_fill_dotmul(ScalarPolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
756
757     //Sparse
758     scilab_fill_dotmul(Sparse, Sparse, M_M, Sparse, Sparse, Sparse);
759     scilab_fill_dotmul(Sparse, SparseComplex, M_M, Sparse, Sparse, Sparse);
760     scilab_fill_dotmul(Sparse, Double, M_M, Sparse, Double, Sparse);
761     scilab_fill_dotmul(Sparse, DoubleComplex, M_M, Sparse, Double, Sparse);
762     scilab_fill_dotmul(Sparse, ScalarDouble, M_M, Sparse, Double, Sparse);
763     scilab_fill_dotmul(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
764
765     scilab_fill_dotmul(Sparse, Empty, M_E, Sparse, Double, Double);
766     //scilab_fill_dotmul(Sparse, Identity, M_M, Sparse, Double, Sparse);
767     //scilab_fill_dotmul(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
768
769     scilab_fill_dotmul(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
770     scilab_fill_dotmul(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
771     scilab_fill_dotmul(SparseComplex, Double, M_M, Sparse, Double, Sparse);
772     scilab_fill_dotmul(SparseComplex, DoubleComplex, M_M, Sparse, Double, Sparse);
773     scilab_fill_dotmul(SparseComplex, ScalarDouble, M_M, Sparse, Double, Sparse);
774     scilab_fill_dotmul(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
775
776     scilab_fill_dotmul(SparseComplex, Empty, M_E, Sparse, Double, Double);
777     //scilab_fill_dotmul(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
778     //scilab_fill_dotmul(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
779
780 #undef scilab_fill_dotmul
781 }
782
783 InternalType *GenericDotTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
784 {
785     InternalType *pResult = NULL;
786
787     dotmul_function dotmul = pDotMulfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
788     if (dotmul)
789     {
790         pResult = dotmul(_pLeftOperand, _pRightOperand);
791         if (pResult)
792         {
793             return pResult;
794         }
795     }
796
797     /*
798     ** Default case : Return NULL will Call Overloading.
799     */
800     return NULL;
801 }
802
803 //Matrix .* x
804 template<class T, class U, class O>
805 InternalType* dotmul_M_M(T *_pL, U *_pR)
806 {
807     //check dims
808     int iDimsL = _pL->getDims();
809     int iDimsR = _pR->getDims();
810
811     if (iDimsL != iDimsR)
812     {
813         return nullptr;
814     }
815
816     int* piDimsL = _pL->getDimsArray();
817     int* piDimsR = _pR->getDimsArray();
818
819     for (int i = 0 ; i < iDimsL ; ++i)
820     {
821         if (piDimsL[i] != piDimsR[i])
822         {
823             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
824         }
825     }
826
827     O* pOut = new O(iDimsL, piDimsL);
828     int iSize = pOut->getSize();
829
830     dotmul(_pL->get(), iSize, _pR->get(), pOut->get());
831     return pOut;
832 }
833
834 template<class T, class U, class O>
835 InternalType* dotmul_M_MC(T *_pL, U *_pR)
836 {
837     //check dims
838     int iDimsL = _pL->getDims();
839     int iDimsR = _pR->getDims();
840
841     if (iDimsL != iDimsR)
842     {
843         return nullptr;
844     }
845
846     int* piDimsL = _pL->getDimsArray();
847     int* piDimsR = _pR->getDimsArray();
848
849     for (int i = 0 ; i < iDimsL ; ++i)
850     {
851         if (piDimsL[i] != piDimsR[i])
852         {
853             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
854         }
855     }
856
857     O* pOut = new O(iDimsL, piDimsL, true);
858     int iSize = pOut->getSize();
859
860     dotmul(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
861     return pOut;
862 }
863
864 template<class T, class U, class O>
865 InternalType* dotmul_M_S(T *_pL, U *_pR)
866 {
867     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
868     dotmul(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
869     return pOut;
870 }
871
872 template<class T, class U, class O>
873 InternalType* dotmul_M_SC(T *_pL, U *_pR)
874 {
875     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
876     dotmul(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
877     return pOut;
878 }
879
880 template<class T, class U, class O>
881 InternalType* dotmul_M_I(T * /*_pL*/, U * /*_pR*/)
882 {
883     return NULL;
884 }
885
886 template<class T, class U, class O>
887 InternalType* dotmul_M_IC(T * /*_pL*/, U * /*_pR*/)
888 {
889     return NULL;
890 }
891
892 template<class T, class U, class O>
893 InternalType* dotmul_M_E(T * /*_pL*/, U *_pR)
894 {
895     return _pR;
896 }
897
898 //Matrix complex .* x
899 template<class T, class U, class O>
900 InternalType* dotmul_MC_M(T *_pL, U *_pR)
901 {
902     //check dims
903     int iDimsL = _pL->getDims();
904     int iDimsR = _pR->getDims();
905
906     if (iDimsL != iDimsR)
907     {
908         return nullptr;
909     }
910
911     int* piDimsL = _pL->getDimsArray();
912     int* piDimsR = _pR->getDimsArray();
913
914     for (int i = 0 ; i < iDimsL ; ++i)
915     {
916         if (piDimsL[i] != piDimsR[i])
917         {
918             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
919         }
920     }
921
922     O* pOut = new O(iDimsL, piDimsL, true);
923     int iSize = pOut->getSize();
924
925     dotmul(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get(), pOut->getImg());
926     return pOut;
927 }
928
929 template<class T, class U, class O>
930 InternalType* dotmul_MC_MC(T *_pL, U *_pR)
931 {
932     //check dims
933     int iDimsL = _pL->getDims();
934     int iDimsR = _pR->getDims();
935
936     if (iDimsL != iDimsR)
937     {
938         return nullptr;
939     }
940
941     int* piDimsL = _pL->getDimsArray();
942     int* piDimsR = _pR->getDimsArray();
943
944     for (int i = 0 ; i < iDimsL ; ++i)
945     {
946         if (piDimsL[i] != piDimsR[i])
947         {
948             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
949         }
950     }
951
952     O* pOut = new O(iDimsL, piDimsL, true);
953     int iSize = pOut->getSize();
954
955     dotmul(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
956     return pOut;
957 }
958
959 template<class T, class U, class O>
960 InternalType* dotmul_MC_S(T *_pL, U *_pR)
961 {
962     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
963     dotmul(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
964     return pOut;
965 }
966
967 template<class T, class U, class O>
968 InternalType* dotmul_MC_SC(T *_pL, U *_pR)
969 {
970     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
971     dotmul(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
972     return pOut;
973 }
974
975 template<class T, class U, class O>
976 InternalType* dotmul_MC_I(T * /*_pL*/, U * /*_pR*/)
977 {
978     return NULL;
979 }
980
981 template<class T, class U, class O>
982 InternalType* dotmul_MC_IC(T * /*_pL*/, U * /*_pR*/)
983 {
984     return NULL;
985 }
986
987 //Scalar .* x
988 template<class T, class U, class O>
989 InternalType* dotmul_S_M(T *_pL, U *_pR)
990 {
991     return dotmul_M_S<U, T, O>(_pR, _pL);
992 }
993
994 template<class T, class U, class O>
995 InternalType* dotmul_S_MC(T *_pL, U *_pR)
996 {
997     return dotmul_MC_S<U, T, O>(_pR, _pL);
998 }
999
1000 template<class T, class U, class O>
1001 InternalType* dotmul_S_S(T *_pL, U *_pR)
1002 {
1003     O* pOut = new O(0);
1004     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1005     return pOut;
1006 }
1007
1008 template<class T, class U, class O>
1009 InternalType* dotmul_S_SC(T *_pL, U *_pR)
1010 {
1011     O* pOut = new O(0.0, 0.0);
1012     dotmul(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1013     return pOut;
1014 }
1015
1016 template<class T, class U, class O>
1017 InternalType* dotmul_S_I(T *_pL, U *_pR)
1018 {
1019     O* pOut = (O*)_pR->clone();
1020     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1021     return pOut;
1022 }
1023
1024 template<class T, class U, class O>
1025 InternalType* dotmul_S_IC(T *_pL, U *_pR)
1026 {
1027     O* pOut = (O*)_pR->clone();
1028     dotmul(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1029     return pOut;
1030 }
1031
1032 //Scalar complex .* x
1033 template<class T, class U, class O>
1034 InternalType* dotmul_SC_M(T *_pL, U *_pR)
1035 {
1036     return dotmul_M_SC<U, T, O>(_pR, _pL);
1037 }
1038
1039 template<class T, class U, class O>
1040 InternalType* dotmul_SC_MC(T *_pL, U *_pR)
1041 {
1042     return dotmul_MC_SC<U, T, O>(_pR, _pL);
1043 }
1044
1045 template<class T, class U, class O>
1046 InternalType* dotmul_SC_S(T *_pL, U *_pR)
1047 {
1048     return dotmul_S_SC<U, T, O>(_pR, _pL);
1049 }
1050
1051 template<class T, class U, class O>
1052 InternalType* dotmul_SC_SC(T *_pL, U *_pR)
1053 {
1054     O* pOut = new O(0.0, 0.0);
1055     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1056     return pOut;
1057 }
1058
1059 template<class T, class U, class O>
1060 InternalType* dotmul_SC_I(T *_pL, U *_pR)
1061 {
1062     O* pOut = (O*)_pR->clone();
1063     pOut->setComplex(true);
1064     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1065     return pOut;
1066 }
1067
1068 template<class T, class U, class O>
1069 InternalType* dotmul_SC_IC(T *_pL, U *_pR)
1070 {
1071     O* pOut = (O*)_pR->clone();
1072     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1073     return pOut;
1074 }
1075
1076 //Identity .* x
1077 template<class T, class U, class O>
1078 InternalType* dotmul_I_M(T * /*_pL*/, U * /*_pR*/)
1079 {
1080     return NULL;
1081 }
1082
1083 template<class T, class U, class O>
1084 InternalType* dotmul_I_MC(T * /*_pL*/, U * /*_pR*/)
1085 {
1086     return NULL;
1087 }
1088
1089 template<class T, class U, class O>
1090 InternalType* dotmul_I_S(T *_pL, U *_pR)
1091 {
1092     return dotmul_S_I<U, T, O>(_pR, _pL);
1093 }
1094
1095 template<class T, class U, class O>
1096 InternalType* dotmul_I_SC(T *_pL, U *_pR)
1097 {
1098     return dotmul_SC_I<U, T, O>(_pR, _pL);
1099 }
1100
1101 template<class T, class U, class O>
1102 InternalType* dotmul_I_I(T *_pL, U *_pR)
1103 {
1104     O* pOut = (O*)_pL->clone();
1105     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1106     return pOut;
1107 }
1108
1109 template<class T, class U, class O>
1110 InternalType* dotmul_I_IC(T *_pL, U *_pR)
1111 {
1112     O* pOut = (O*)_pR->clone();
1113     dotmul(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1114     return pOut;
1115 }
1116
1117 //Identity complex .* x
1118 template<class T, class U, class O>
1119 InternalType* dotmul_IC_M(T * /*_pL*/, U * /*_pR*/)
1120 {
1121     return NULL;
1122 }
1123
1124 template<class T, class U, class O>
1125 InternalType* dotmul_IC_MC(T * /*_pL*/, U * /*_pR*/)
1126 {
1127     return NULL;
1128 }
1129
1130 template<class T, class U, class O>
1131 InternalType* dotmul_IC_S(T *_pL, U *_pR)
1132 {
1133     return dotmul_S_IC<U, T, O>(_pR, _pL);
1134 }
1135
1136 template<class T, class U, class O>
1137 InternalType* dotmul_IC_SC(T *_pL, U *_pR)
1138 {
1139     return dotmul_SC_IC<U, T, O>(_pR, _pL);
1140 }
1141
1142 template<class T, class U, class O>
1143 InternalType* dotmul_IC_I(T *_pL, U *_pR)
1144 {
1145     O* pOut = (O*)_pL->clone();
1146     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1147     return pOut;
1148 }
1149
1150 template<class T, class U, class O>
1151 InternalType* dotmul_IC_IC(T *_pL, U *_pR)
1152 {
1153     O* pOut = (O*)_pL->clone();
1154     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1155     return pOut;
1156 }
1157
1158 //Empty .* x
1159 template<class T, class U, class O>
1160 InternalType* dotmul_E_M(T *_pL, U * /*_pR*/)
1161 {
1162     return _pL;
1163 }
1164
1165 template<>
1166 InternalType* dotmul_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
1167 {
1168     //check dims
1169     if (_pL->isScalar())
1170     {
1171         Sparse* pOut = NULL;
1172         std::complex<double> c(_pL->getImg(0, 0));
1173         Double* pL = NULL;
1174         if (c.imag())
1175         {
1176             pL = new Double(c.real(), c.imag());
1177         }
1178         else
1179         {
1180             pL = new Double(c.real());
1181         }
1182         pOut = (Sparse*)dotmul_M_M<Double, Sparse, Sparse>(pL, _pR);
1183         delete pL;
1184         return pOut;
1185     }
1186
1187     if (_pR->isScalar())
1188     {
1189         Sparse* pOut = NULL;
1190         std::complex<double> c(_pR->getImg(0, 0));
1191         Double* pR = NULL;
1192         if (c.imag())
1193         {
1194             pR = new Double(c.real(), c.imag());
1195         }
1196         else
1197         {
1198             pR = new Double(c.real());
1199         }
1200         pOut = (Sparse*)dotmul_M_M<Sparse, Double, Sparse>(_pL, pR);
1201         delete pR;
1202         return pOut;
1203     }
1204
1205     //check dimensions
1206     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1207     {
1208         throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
1209     }
1210
1211     return _pL->dotMultiply(*_pR);
1212 }
1213
1214 //[] .* SP
1215 template<>
1216 InternalType* dotmul_M_M<Double, Sparse, Double>(Double* _pL, Sparse* /*_pR*/)
1217 {
1218     return _pL;
1219 }
1220
1221 //SP .* []
1222 template<>
1223 InternalType* dotmul_M_M<Sparse, Double, Double>(Sparse* /*_pL*/, Double* _pR)
1224 {
1225     return _pR;
1226 }
1227
1228 template<>
1229 InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
1230 {
1231     //D * SP
1232     if (_pL->isScalar())
1233     {
1234         //d * SP -> SP
1235         if (_pL->isComplex())
1236         {
1237             std::complex<double> dbl(_pL->get(0), _pL->getImg(0));
1238             return _pR->multiply(dbl);
1239         }
1240         else
1241         {
1242             return _pR->multiply(_pL->get(0));
1243         }
1244     }
1245
1246     if (_pR->isScalar())
1247     {
1248         //D * sp -> D .* d
1249         Double* pD = NULL;
1250
1251         if (_pR->isComplex())
1252         {
1253             std::complex<double> dbl(_pR->getImg(0, 0));
1254             pD = new Double(dbl.real(), dbl.imag());
1255         }
1256         else
1257         {
1258             pD = new Double(_pR->get(0, 0));
1259         }
1260
1261         InternalType* pIT = GenericDotTimes(_pL, pD);
1262         delete pD;
1263         return pIT;
1264     }
1265
1266
1267     //check dimensions
1268     if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1269     {
1270         return nullptr;
1271     }
1272
1273     //get some information
1274     int iNonZeros = static_cast<int>(_pR->nonZeros());
1275     int* pRows = new int[iNonZeros * 2];
1276     _pR->outputRowCol(pRows);
1277     int* pCols = pRows + iNonZeros;
1278     double* pValR = new double[iNonZeros];
1279     double* pValI = new double[iNonZeros];
1280     _pR->outputValues(pValR, pValI);
1281     double* pdblR = _pL->get();
1282     int iRows = _pL->getRows();
1283
1284     Sparse* pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex() || _pR->isComplex());
1285
1286     if (_pL->isComplex() == false)
1287     {
1288         if (_pR->isComplex() == false)
1289         {
1290             for (int i = 0 ; i < iNonZeros ; i++)
1291             {
1292                 int iRow = static_cast<int>(pRows[i]) - 1;
1293                 int iCol = static_cast<int>(pCols[i]) - 1;
1294                 int index = iCol * iRows + iRow;
1295
1296                 pOut->set(iRow, iCol,  pdblR[index] * pValR[i], false);
1297             }
1298         }
1299         else
1300         {
1301             for (int i = 0 ; i < iNonZeros ; i++)
1302             {
1303                 int iRow = static_cast<int>(pRows[i]) - 1;
1304                 int iCol = static_cast<int>(pCols[i]) - 1;
1305                 int index = iCol * iRows + iRow;
1306
1307                 std::complex<double> c;
1308                 c.real(pdblR[index] * pValR[i]);
1309                 c.imag(pdblR[index] * pValI[i]);
1310                 pOut->set(iRow, iCol,  c, false);
1311             }
1312         }
1313     }
1314     else
1315     {
1316         double* pdblI = _pL->getImg();
1317         if (_pR->isComplex() == false)
1318         {
1319             for (int i = 0 ; i < iNonZeros ; i++)
1320             {
1321                 int iRow = static_cast<int>(pRows[i]) - 1;
1322                 int iCol = static_cast<int>(pCols[i]) - 1;
1323                 int index = iCol * iRows + iRow;
1324
1325                 std::complex<double> c;
1326                 c.real(pdblR[index] * pValR[i]);
1327                 c.imag(pdblI[index] * pValR[i]);
1328                 pOut->set(iRow, iCol,  c, false);
1329             }
1330         }
1331         else
1332         {
1333             for (int i = 0 ; i < iNonZeros ; i++)
1334             {
1335                 int iRow = static_cast<int>(pRows[i]) - 1;
1336                 int iCol = static_cast<int>(pCols[i]) - 1;
1337                 int index = iCol * iRows + iRow;
1338
1339                 std::complex<double> c;
1340                 c.real(pdblR[index] * pValR[i] - pdblI[index] * pValI[i]);
1341                 c.imag(pdblR[index] * pValI[i] + pdblI[index] * pValR[i]);
1342                 pOut->set(iRow, iCol,  c, false);
1343             }
1344         }
1345     }
1346
1347     delete[] pRows;
1348     delete[] pValR;
1349     delete[] pValI;
1350
1351     pOut->finalize();
1352     return pOut;
1353 }
1354
1355 template<>
1356 InternalType* dotmul_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
1357 {
1358     return dotmul_M_M<Double, Sparse, Sparse>(_pR, _pL);
1359 }
1360
1361 //Polynom
1362 template<>
1363 InternalType* dotmul_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1364 {
1365     //check varname
1366     if (_pL->getVariableName() != _pR->getVariableName())
1367     {
1368         //call overload
1369         return NULL;
1370     }
1371
1372     int iDimsL = _pL->getDims();
1373     int iDimsR = _pR->getDims();
1374     int* piDimsL = _pL->getDimsArray();
1375     int* piDimsR = _pR->getDimsArray();
1376
1377     if (_pL->isScalar())
1378     {
1379         Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsR, piDimsR);
1380         int iSize = pOut->getSize();
1381         SinglePoly** pSPOut = pOut->get();
1382         SinglePoly* pSPL = _pL->get(0);
1383         SinglePoly** pSPR = _pR->get();
1384
1385         for (int i = 0 ; i < iSize ; ++i)
1386         {
1387             pSPOut[i] = *pSPL **pSPR[i];
1388         }
1389
1390         return pOut;
1391     }
1392
1393     if (_pR->isScalar())
1394     {
1395         Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsL, piDimsL);
1396         int iSize = pOut->getSize();
1397         SinglePoly** pSPOut = pOut->get();
1398         SinglePoly** pSPL = _pL->get();
1399         SinglePoly* pSPR = _pR->get(0);
1400
1401         for (int i = 0 ; i < iSize ; ++i)
1402         {
1403             pSPOut[i] = *pSPL[i] **pSPR;
1404         }
1405
1406         return pOut;
1407     }
1408
1409     //check dims
1410     if (iDimsL != iDimsR)
1411     {
1412         return nullptr;
1413     }
1414
1415     for (int i = 0 ; i < iDimsL ; ++i)
1416     {
1417         if (piDimsL[i] != piDimsR[i])
1418         {
1419             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
1420         }
1421     }
1422
1423     Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsL, piDimsR);
1424     int iSize = pOut->getSize();
1425     SinglePoly** pSPOut = pOut->get();
1426     SinglePoly** pSPL = _pL->get();
1427     SinglePoly** pSPR = _pR->get();
1428
1429     for (int i = 0 ; i < iSize ; ++i)
1430     {
1431         pSPOut[i] = *pSPL[i] **pSPR[i];
1432     }
1433
1434     return pOut;
1435 }
1436
1437 template<>
1438 InternalType* dotmul_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1439 {
1440     return dotmul_M_M<Double, Polynom, Polynom>(_pR, _pL);
1441 }
1442
1443 template<>
1444 InternalType* dotmul_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1445 {
1446     Polynom* pOut = NULL;
1447
1448     bool isComplexL = _pL->isComplex();
1449     bool isComplexR = _pR->isComplex();
1450     bool isComplexOut = isComplexL || isComplexR;
1451
1452     if (_pL->isScalar())
1453     {
1454         pOut = (Polynom*)_pR->clone();
1455         SinglePoly** pSPR = _pR->get();
1456         SinglePoly** pSP = pOut->get();
1457         int iSize = pOut->getSize();
1458
1459         double dblR = _pL->get(0);
1460         if (isComplexL)
1461         {
1462             double dblI = _pL->getImg(0);
1463             pOut->setComplex(true);
1464             if (isComplexR)
1465             {
1466                 for (int i = 0 ; i < iSize ; i++)
1467                 {
1468                     dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1469                 }
1470             }
1471             else
1472             {
1473                 for (int i = 0 ; i < iSize ; i++)
1474                 {
1475                     dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1476                 }
1477             }
1478         }
1479         else
1480         {
1481             if (isComplexR)
1482             {
1483                 for (int i = 0 ; i < iSize ; i++)
1484                 {
1485                     dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, pSP[i]->get(), pSP[i]->getImg());
1486                 }
1487             }
1488             else
1489             {
1490                 //r .* P
1491                 for (int i = 0 ; i < iSize ; i++)
1492                 {
1493                     dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), dblR, pSP[i]->get());
1494                 }
1495             }
1496         }
1497
1498         return pOut;
1499     }
1500
1501     if (_pR->isScalar())
1502     {
1503         pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray());
1504         SinglePoly* pSPL = _pR->get(0);
1505         SinglePoly** pSP = pOut->get();
1506         int iSize = pOut->getSize();
1507         double* pdblLR = _pL->get();
1508         double* pdblLI = NULL;
1509         if (isComplexL)
1510         {
1511             pdblLI  = _pL->getImg();
1512         }
1513
1514         double* pdblRR = pSPL->get();
1515         double* pdblRI = NULL;
1516         if (isComplexR)
1517         {
1518             pdblRI = pSPL->getImg();
1519         }
1520
1521         if (isComplexL)
1522         {
1523             if (isComplexR)
1524             {
1525                 for (int i = 0 ; i < iSize ; ++i)
1526                 {
1527                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1528                     int iSPSize = pSPOut->getSize();
1529                     pSPOut->setComplex(isComplexOut);
1530
1531                     double* pdblOutR = pSPOut->get();
1532                     double* pdblOutI = pSPOut->getImg();
1533
1534                     dotmul(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1535                     pSP[i] = pSPOut;
1536                 }
1537             }
1538             else
1539             {
1540                 for (int i = 0 ; i < iSize ; ++i)
1541                 {
1542                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1543                     int iSPSize = pSPOut->getSize();
1544                     pSPOut->setComplex(isComplexOut);
1545
1546                     double* pdblOutR = pSPOut->get();
1547                     double* pdblOutI = pSPOut->getImg();
1548                     dotmul(pdblRR, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1549                     pSP[i] = pSPOut;
1550                 }
1551             }
1552         }
1553         else
1554         {
1555             if (isComplexR)
1556             {
1557                 for (int i = 0 ; i < iSize ; ++i)
1558                 {
1559                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1560                     int iSPSize = pSPOut->getSize();
1561                     pSPOut->setComplex(isComplexOut);
1562
1563                     double* pdblOutR = pSPOut->get();
1564                     double* pdblOutI = pSPOut->getImg();
1565                     dotmul(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblOutR, pdblOutI);
1566                     pSP[i] = pSPOut;
1567                 }
1568             }
1569             else
1570             {
1571                 for (int i = 0 ; i < iSize ; ++i)
1572                 {
1573                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1574                     int iSPSize = pSPOut->getSize();
1575                     pSPOut->setComplex(isComplexOut);
1576
1577                     double* pdblOutR = pSPOut->get();
1578                     dotmul(pdblRR, (size_t)iSPSize, pdblLR[i], pdblOutR);
1579                     pSP[i] = pSPOut;
1580                 }
1581             }
1582         }
1583
1584         return pOut;
1585
1586     }
1587
1588     //check dims
1589     int iDimsL = _pL->getDims();
1590     int iDimsR = _pR->getDims();
1591
1592     if (iDimsL != iDimsR)
1593     {
1594         return nullptr;
1595     }
1596
1597     int* piDimsL = _pL->getDimsArray();
1598     int* piDimsR = _pR->getDimsArray();
1599
1600     for (int i = 0 ; i < iDimsL ; ++i)
1601     {
1602         if (piDimsL[i] != piDimsR[i])
1603         {
1604             throw ast::InternalError(_("Inconsistent row/column dimensions.\n"));
1605         }
1606     }
1607
1608
1609     pOut = (Polynom*)_pR->clone();
1610     pOut->setComplex(isComplexOut);
1611     SinglePoly** pSPR = _pR->get();
1612     SinglePoly** pSP = pOut->get();
1613     int iSize = pOut->getSize();
1614
1615     double* pdblR = _pL->get();
1616     double* pdblI = NULL;
1617     if (isComplexL)
1618     {
1619         pdblI = _pL->getImg();
1620     }
1621
1622     if (isComplexL)
1623     {
1624         if (isComplexR)
1625         {
1626             for (int i = 0 ; i < iSize ; i++)
1627             {
1628                 dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1629             }
1630         }
1631         else
1632         {
1633             for (int i = 0 ; i < iSize ; i++)
1634             {
1635                 dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1636             }
1637         }
1638     }
1639     else
1640     {
1641         if (isComplexR)
1642         {
1643             for (int i = 0 ; i < iSize ; i++)
1644             {
1645                 dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get(), pSP[i]->getImg());
1646             }
1647         }
1648         else
1649         {
1650             //r .* P
1651             for (int i = 0 ; i < iSize ; i++)
1652             {
1653                 dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get());
1654             }
1655         }
1656     }
1657
1658     return pOut;
1659 }