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