dot divide
[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 "scilabexception.hxx"
16 #include "double.hxx"
17 #include "int.hxx"
18 #include "sparse.hxx"
19 #include "polynom.hxx"
20
21
22 extern "C"
23 {
24 #include "localization.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         pResult = dotdiv(_pLeftOperand, _pRightOperand);
810         if (pResult)
811         {
812             return pResult;
813         }
814     }
815
816     /*
817     ** Default case : Return NULL will Call Overloading.
818     */
819     return NULL;
820 }
821
822
823
824
825 //Matrix ./ x
826 template<class T, class U, class O>
827 InternalType* dotdiv_M_M(T *_pL, U *_pR)
828 {
829     //check dims
830     int iDimsL = _pL->getDims();
831     int iDimsR = _pR->getDims();
832
833     if (iDimsL != iDimsR)
834     {
835         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
836     }
837
838     int* piDimsL = _pL->getDimsArray();
839     int* piDimsR = _pR->getDimsArray();
840
841     for (int i = 0 ; i < iDimsL ; ++i)
842     {
843         if (piDimsL[i] != piDimsR[i])
844         {
845             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
846         }
847     }
848
849     O* pOut = new O(iDimsL, piDimsL);
850     int iSize = pOut->getSize();
851
852     dotdiv(_pL->get(), iSize, _pR->get(), pOut->get());
853     return pOut;
854 }
855
856 template<class T, class U, class O>
857 InternalType* dotdiv_M_MC(T *_pL, U *_pR)
858 {
859     //check dims
860     int iDimsL = _pL->getDims();
861     int iDimsR = _pR->getDims();
862
863     if (iDimsL != iDimsR)
864     {
865         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
866     }
867
868     int* piDimsL = _pL->getDimsArray();
869     int* piDimsR = _pR->getDimsArray();
870
871     for (int i = 0 ; i < iDimsL ; ++i)
872     {
873         if (piDimsL[i] != piDimsR[i])
874         {
875             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
876         }
877     }
878
879     O* pOut = new O(iDimsL, piDimsL, true);
880     int iSize = pOut->getSize();
881
882     dotdiv(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
883     return pOut;
884 }
885
886 template<class T, class U, class O>
887 InternalType* dotdiv_M_S(T *_pL, U *_pR)
888 {
889     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
890     dotdiv(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
891     return pOut;
892 }
893
894 template<class T, class U, class O>
895 InternalType* dotdiv_M_SC(T *_pL, U *_pR)
896 {
897     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
898     dotdiv(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
899     return pOut;
900 }
901
902 template<class T, class U, class O>
903 InternalType* dotdiv_M_I(T *_pL, U *_pR)
904 {
905     return NULL;
906 }
907
908 template<class T, class U, class O>
909 InternalType* dotdiv_M_IC(T *_pL, U *_pR)
910 {
911     return NULL;
912 }
913
914 template<class T, class U, class O>
915 InternalType* dotdiv_M_E(T *_pL, U *_pR)
916 {
917     return _pR;
918 }
919
920 template<class T, class U, class O>
921 InternalType* dotdiv_E_M(T *_pL, U *_pR)
922 {
923     return _pL;
924 }
925
926 //Matrix complex ./ x
927 template<class T, class U, class O>
928 InternalType* dotdiv_MC_M(T *_pL, U *_pR)
929 {
930     //check dims
931     int iDimsL = _pL->getDims();
932     int iDimsR = _pR->getDims();
933
934     if (iDimsL != iDimsR)
935     {
936         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
937     }
938
939     int* piDimsL = _pL->getDimsArray();
940     int* piDimsR = _pR->getDimsArray();
941
942     for (int i = 0 ; i < iDimsL ; ++i)
943     {
944         if (piDimsL[i] != piDimsR[i])
945         {
946             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
947         }
948     }
949
950     O* pOut = new O(iDimsL, piDimsL, true);
951     int iSize = pOut->getSize();
952
953     dotdiv(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get(), pOut->getImg());
954     return pOut;
955 }
956
957 template<class T, class U, class O>
958 InternalType* dotdiv_MC_MC(T *_pL, U *_pR)
959 {
960     //check dims
961     int iDimsL = _pL->getDims();
962     int iDimsR = _pR->getDims();
963
964     if (iDimsL != iDimsR)
965     {
966         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
967     }
968
969     int* piDimsL = _pL->getDimsArray();
970     int* piDimsR = _pR->getDimsArray();
971
972     for (int i = 0 ; i < iDimsL ; ++i)
973     {
974         if (piDimsL[i] != piDimsR[i])
975         {
976             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
977         }
978     }
979
980     O* pOut = new O(iDimsL, piDimsL, true);
981     int iSize = pOut->getSize();
982
983     dotdiv(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
984     return pOut;
985 }
986
987 template<class T, class U, class O>
988 InternalType* dotdiv_MC_S(T *_pL, U *_pR)
989 {
990     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
991     dotdiv(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
992     return pOut;
993 }
994
995 template<class T, class U, class O>
996 InternalType* dotdiv_MC_SC(T *_pL, U *_pR)
997 {
998     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
999     dotdiv(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1000     return pOut;
1001 }
1002
1003 template<class T, class U, class O>
1004 InternalType* dotdiv_MC_I(T *_pL, U *_pR)
1005 {
1006     return NULL;
1007 }
1008
1009 template<class T, class U, class O>
1010 InternalType* dotdiv_MC_IC(T *_pL, U *_pR)
1011 {
1012     return NULL;
1013 }
1014
1015 //Scalar ./ x
1016 template<class T, class U, class O>
1017 InternalType* dotdiv_S_M(T *_pL, U *_pR)
1018 {
1019     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1020     dotdiv(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
1021     return pOut;
1022 }
1023
1024 template<class T, class U, class O>
1025 InternalType* dotdiv_S_MC(T *_pL, U *_pR)
1026 {
1027     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1028     dotdiv(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1029     return pOut;
1030 }
1031
1032 template<class T, class U, class O>
1033 InternalType* dotdiv_S_S(T *_pL, U *_pR)
1034 {
1035     O* pOut = new O(0);
1036     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1037     return pOut;
1038 }
1039
1040 template<class T, class U, class O>
1041 InternalType* dotdiv_S_SC(T *_pL, U *_pR)
1042 {
1043     O* pOut = new O(0.0, 0.0);
1044     dotdiv(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1045     return pOut;
1046 }
1047
1048 template<class T, class U, class O>
1049 InternalType* dotdiv_S_I(T *_pL, U *_pR)
1050 {
1051     O* pOut = (O*)_pR->clone();
1052     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1053     return pOut;
1054 }
1055
1056 template<class T, class U, class O>
1057 InternalType* dotdiv_S_IC(T *_pL, U *_pR)
1058 {
1059     O* pOut = (O*)_pR->clone();
1060     dotdiv(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1061     return pOut;
1062 }
1063 //Scalar complex ./ x
1064 template<class T, class U, class O>
1065 InternalType* dotdiv_SC_M(T *_pL, U *_pR)
1066 {
1067     return dotdiv_SC_MC<U, T, O>(_pR, _pL);
1068 }
1069
1070 template<class T, class U, class O>
1071 InternalType* dotdiv_SC_MC(T *_pL, U *_pR)
1072 {
1073     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1074     dotdiv(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1075     return pOut;
1076 }
1077
1078 template<class T, class U, class O>
1079 InternalType* dotdiv_SC_S(T *_pL, U *_pR)
1080 {
1081     O* pOut = new O(0.0, 0.0);
1082     dotdiv(_pL->get(0), _pL->getImg(0), 1 , _pR->get(0), pOut->get(), pOut->getImg());
1083     return pOut;
1084 }
1085
1086 template<class T, class U, class O>
1087 InternalType* dotdiv_SC_SC(T *_pL, U *_pR)
1088 {
1089     O* pOut = new O(0.0, 0.0);
1090     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1091     return pOut;
1092 }
1093
1094 template<class T, class U, class O>
1095 InternalType* dotdiv_SC_I(T *_pL, U *_pR)
1096 {
1097     O* pOut = (O*)_pR->clone();
1098     pOut->setComplex(true);
1099     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1100     return pOut;
1101 }
1102
1103 template<class T, class U, class O>
1104 InternalType* dotdiv_SC_IC(T *_pL, U *_pR)
1105 {
1106     O* pOut = (O*)_pR->clone();
1107     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1108     return pOut;
1109 }
1110
1111 //Identity ./ x
1112 template<class T, class U, class O>
1113 InternalType* dotdiv_I_M(T *_pL, U *_pR)
1114 {
1115     return NULL;
1116 }
1117
1118 template<class T, class U, class O>
1119 InternalType* dotdiv_I_MC(T *_pL, U *_pR)
1120 {
1121     return NULL;
1122 }
1123
1124 template<class T, class U, class O>
1125 InternalType* dotdiv_I_S(T *_pL, U *_pR)
1126 {
1127     O* pOut = (O*)_pL->clone();
1128     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1129     return pOut;
1130 }
1131
1132 template<class T, class U, class O>
1133 InternalType* dotdiv_I_SC(T *_pL, U *_pR)
1134 {
1135     return dotdiv_SC_I<U, T, O>(_pR, _pL);
1136 }
1137
1138 template<class T, class U, class O>
1139 InternalType* dotdiv_I_I(T *_pL, U *_pR)
1140 {
1141     O* pOut = (O*)_pL->clone();
1142     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1143     return pOut;
1144 }
1145
1146 template<class T, class U, class O>
1147 InternalType* dotdiv_I_IC(T *_pL, U *_pR)
1148 {
1149     O* pOut = (O*)_pR->clone();
1150     dotdiv(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1151     return pOut;
1152 }
1153
1154 //Identity complex ./ x
1155 template<class T, class U, class O>
1156 InternalType* dotdiv_IC_M(T *_pL, U *_pR)
1157 {
1158     return NULL;
1159 }
1160
1161 template<class T, class U, class O>
1162 InternalType* dotdiv_IC_MC(T *_pL, U *_pR)
1163 {
1164     return NULL;
1165 }
1166
1167 template<class T, class U, class O>
1168 InternalType* dotdiv_IC_S(T *_pL, U *_pR)
1169 {
1170     O* pOut = (O*)_pL->clone();
1171     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1172     return pOut;
1173 }
1174
1175 template<class T, class U, class O>
1176 InternalType* dotdiv_IC_SC(T *_pL, U *_pR)
1177 {
1178     O* pOut = (O*)_pL->clone();
1179     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1180     return pOut;
1181 }
1182
1183 template<class T, class U, class O>
1184 InternalType* dotdiv_IC_I(T *_pL, U *_pR)
1185 {
1186     O* pOut = (O*)_pL->clone();
1187     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1188     return pOut;
1189 }
1190
1191 template<class T, class U, class O>
1192 InternalType* dotdiv_IC_IC(T *_pL, U *_pR)
1193 {
1194     O* pOut = (O*)_pL->clone();
1195     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1196     return pOut;
1197 }
1198
1199
1200 template<>
1201 InternalType* dotdiv_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
1202 {
1203     //check dims
1204     if (_pL->isScalar())
1205     {
1206         Sparse* pOut = NULL;
1207         std::complex<double> c(_pL->getImg(0, 0));
1208         Double* pL = NULL;
1209         if (c.imag())
1210         {
1211             pL = new Double(c.real(), c.imag());
1212         }
1213         else
1214         {
1215             pL = new Double(c.real());
1216         }
1217         pOut = (Sparse*)dotdiv_M_M<Double, Sparse, Sparse>(pL, _pR);
1218         delete pL;
1219         return pOut;
1220     }
1221
1222     if (_pR->isScalar())
1223     {
1224         Sparse* pOut = NULL;
1225         std::complex<double> c(_pR->getImg(0, 0));
1226         Double* pR = NULL;
1227         if (c.imag())
1228         {
1229             pR = new Double(c.real(), c.imag());
1230         }
1231         else
1232         {
1233             pR = new Double(c.real());
1234         }
1235         pOut = (Sparse*)dotdiv_M_M<Sparse, Double, Sparse>(_pL, pR);
1236         delete pR;
1237         return pOut;
1238     }
1239
1240     //check dimensions
1241     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1242     {
1243         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1244     }
1245
1246     Sparse* pSparseOut = _pL->dotDivide(*_pR);
1247     pSparseOut->finalize();
1248     return pSparseOut;
1249 }
1250
1251 //[] ./ SP
1252 template<>
1253 InternalType* dotdiv_M_M<Double, Sparse, Double>(Double* _pL, Sparse* _pR)
1254 {
1255     return _pL;
1256 }
1257
1258 //SP ./ []
1259 template<>
1260 InternalType* dotdiv_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _pR)
1261 {
1262     return _pR;
1263 }
1264 //
1265 template<>
1266 InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
1267 {
1268     //D -> SP / SP
1269     if (_pL->isScalar())
1270     {
1271         Sparse* pOut = NULL;
1272         int iSizeOut = _pR->getSize();
1273         if (_pL->isComplex())
1274         {
1275             pOut = new Sparse(_pR->getRows(), _pR->getCols(), true);
1276             std::complex<double> stComplex(_pL->get(0), _pL->getImg(0));
1277             for (int i = 0 ; i < iSizeOut ; i++)
1278             {
1279                 if (_pR->get(i) != 0)
1280                 {
1281                     pOut->set(i, stComplex);
1282                 }
1283             }
1284         }
1285         else
1286         {
1287             pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
1288             for (int i = 0 ; i < iSizeOut ; i++)
1289             {
1290                 if (_pR->get(i) != 0)
1291                 {
1292                     pOut->set(i, _pL->get(0));
1293                 }
1294             }
1295         }
1296         return pOut->dotDivide(*_pR);
1297     }
1298
1299     if (_pR->isScalar())
1300     {
1301         //D / sp -> D ./ d
1302         Double* pD = NULL;
1303
1304         if (_pR->isComplex())
1305         {
1306             std::complex<double> dbl(_pR->getImg(0, 0));
1307             pD = new Double(dbl.real(), dbl.imag());
1308         }
1309         else
1310         {
1311             pD = new Double(_pR->get(0, 0));
1312         }
1313
1314         InternalType* pIT = GenericDotRDivide(_pL, pD);
1315         delete pD;
1316         return pIT;
1317     }
1318
1319
1320     //check dimensions
1321     if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1322     {
1323         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1324     }
1325
1326     //get some information
1327     int iNonZeros = static_cast<int>(_pR->nonZeros());
1328     int* pRows = new int[iNonZeros * 2];
1329     _pR->outputRowCol(pRows);
1330     int* pCols = pRows + iNonZeros;
1331     double* pValR = new double[iNonZeros];
1332     double* pValI = new double[iNonZeros];
1333     _pR->outputValues(pValR, pValI);
1334     double* pdblR = _pL->get();
1335     int iRows = _pL->getRows();
1336
1337     Sparse* pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex() || _pR->isComplex());
1338
1339     if (_pL->isComplex() == false)
1340     {
1341         if (_pR->isComplex() == false)
1342         {
1343             for (int i = 0 ; i < iNonZeros ; i++)
1344             {
1345                 int iRow = static_cast<int>(pRows[i]) - 1;
1346                 int iCol = static_cast<int>(pCols[i]) - 1;
1347                 int index = iCol * iRows + iRow;
1348
1349                 pOut->set(iRow, iCol,  pdblR[index] / pValR[i]);
1350             }
1351         }
1352         else
1353         {
1354             double dDenum = 0;
1355             for (int i = 0 ; i < iNonZeros ; i++)
1356             {
1357                 int iRow = static_cast<int>(pRows[i]) - 1;
1358                 int iCol = static_cast<int>(pCols[i]) - 1;
1359                 int index = iCol * iRows + iRow;
1360
1361                 std::complex<double> c;
1362                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
1363                 c.real((pdblR[index] * pValR[i]) / dDenum);
1364                 c.imag(-(pdblR[index] * pValI[i]) / dDenum);
1365                 pOut->set(iRow, iCol,  c);
1366             }
1367         }
1368     }
1369     else
1370     {
1371         double* pdblI = _pL->getImg();
1372         if (_pR->isComplex() == false)
1373         {
1374             for (int i = 0 ; i < iNonZeros ; i++)
1375             {
1376                 int iRow = static_cast<int>(pRows[i]) - 1;
1377                 int iCol = static_cast<int>(pCols[i]) - 1;
1378                 int index = iCol * iRows + iRow;
1379
1380                 std::complex<double> c;
1381                 c.real(pdblR[index] / pValR[i]);
1382                 c.imag(pdblI[index] / pValR[i]);
1383                 pOut->set(iRow, iCol,  c);
1384             }
1385         }
1386         else
1387         {
1388             double dDenum = 0;
1389             for (int i = 0 ; i < iNonZeros ; i++)
1390             {
1391                 int iRow = static_cast<int>(pRows[i]) - 1;
1392                 int iCol = static_cast<int>(pCols[i]) - 1;
1393                 int index = iCol * iRows + iRow;
1394
1395                 std::complex<double> c;
1396                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
1397                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
1398                 c.imag((pdblI[index] * pValR[i] - pdblR[index] * pValI[i]) / dDenum);
1399                 pOut->set(iRow, iCol,  c);
1400             }
1401         }
1402     }
1403
1404     delete[] pRows;
1405     delete[] pValR;
1406     delete[] pValI;
1407
1408     return pOut;
1409 }
1410
1411 template<>
1412 InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
1413 {
1414
1415     if (_pR->isScalar())
1416     {
1417         // SP / d-> SP
1418         Sparse* pOut = NULL;
1419         int iSizeOut = _pL->getSize();
1420         if (_pR->isComplex())
1421         {
1422             pOut = new Sparse(_pL->getRows(), _pL->getCols(), true);
1423             std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
1424             for (int i = 0 ; i < iSizeOut ; i++)
1425             {
1426                 if (_pL->get(i) != 0)
1427                 {
1428                     pOut->set(i, stComplex);
1429                 }
1430             }
1431         }
1432         else
1433         {
1434             pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
1435             std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
1436             for (int i = 0 ; i < iSizeOut ; i++)
1437             {
1438                 if (_pL->get(i) != 0)
1439                 {
1440                     pOut->set(i, _pR->get(0));
1441                 }
1442             }
1443         }
1444         return _pL->dotDivide(*pOut);
1445     }
1446
1447     if (_pL->isScalar())
1448     {
1449         //D / sp -> D ./ d
1450         Double* pD = NULL;
1451
1452         if (_pL->isComplex())
1453         {
1454             std::complex<double> dbl(_pL->getImg(0, 0));
1455             pD = new Double(dbl.real(), dbl.imag());
1456         }
1457         else
1458         {
1459             pD = new Double(_pL->get(0, 0));
1460         }
1461
1462         InternalType* pIT = GenericDotLDivide(_pR, pD);
1463         delete pD;
1464         return pIT;
1465     }
1466
1467
1468     //check dimensions
1469     if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
1470     {
1471         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1472     }
1473
1474     //get some information
1475     int iNonZeros = static_cast<int>(_pL->nonZeros());
1476     int* pRows = new int[iNonZeros * 2];
1477     _pL->outputRowCol(pRows);
1478     int* pCols = pRows + iNonZeros;
1479     double* pValR = new double[iNonZeros];
1480     double* pValI = new double[iNonZeros];
1481     _pL->outputValues(pValR, pValI);
1482     double* pdblR = _pR->get();
1483     int iRows = _pR->getRows();
1484
1485     Sparse* pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex() || _pL->isComplex());
1486
1487     if (_pR->isComplex() == false)
1488     {
1489         if (_pL->isComplex() == false)
1490         {
1491             for (int i = 0 ; i < iNonZeros ; i++)
1492             {
1493                 int iRow = static_cast<int>(pRows[i]) - 1;
1494                 int iCol = static_cast<int>(pCols[i]) - 1;
1495                 int index = iCol * iRows + iRow;
1496
1497                 pOut->set(iRow, iCol, pValR[i] / pdblR[index]  );
1498             }
1499         }
1500         else
1501         {
1502             for (int i = 0 ; i < iNonZeros ; i++)
1503             {
1504                 int iRow = static_cast<int>(pRows[i]) - 1;
1505                 int iCol = static_cast<int>(pCols[i]) - 1;
1506                 int index = iCol * iRows + iRow;
1507
1508                 std::complex<double> c;
1509                 c.real(pValR[i] / pdblR[index]);
1510                 c.imag(pValR[i] / pdblR[index]);
1511                 pOut->set(iRow, iCol,  c);
1512             }
1513         }
1514     }
1515     else
1516     {
1517         double* pdblI = _pR->getImg();
1518         double dDenum = 0;
1519         if (_pL->isComplex() == false)
1520         {
1521             for (int i = 0 ; i < iNonZeros ; i++)
1522             {
1523                 int iRow = static_cast<int>(pRows[i]) - 1;
1524                 int iCol = static_cast<int>(pCols[i]) - 1;
1525                 int index = iCol * iRows + iRow;
1526
1527                 std::complex<double> c;
1528                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
1529                 c.real((pValR[i]*pdblR[index]) / dDenum );
1530                 c.imag(-(pdblI[index]*pValR[i]) / dDenum );
1531                 pOut->set(iRow, iCol,  c);
1532             }
1533         }
1534         else
1535         {
1536             for (int i = 0 ; i < iNonZeros ; i++)
1537             {
1538                 int iRow = static_cast<int>(pRows[i]) - 1;
1539                 int iCol = static_cast<int>(pCols[i]) - 1;
1540                 int index = iCol * iRows + iRow;
1541
1542                 std::complex<double> c;
1543                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
1544                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
1545                 c.imag((pdblR[index] * pValI[i] - pdblI[index] * pValR[i]) / dDenum);
1546                 pOut->set(iRow, iCol,  c);
1547             }
1548         }
1549     }
1550
1551     delete[] pRows;
1552     delete[] pValR;
1553     delete[] pValI;
1554
1555     return pOut;
1556 }
1557
1558 //Polynom
1559 template<>
1560 InternalType* dotdiv_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1561 {
1562     return NULL;
1563 }
1564
1565 template<>
1566 InternalType* dotdiv_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1567 {
1568     Polynom* pOut = NULL;
1569
1570     bool isComplexL = _pR->isComplex();
1571     bool isComplexR = _pL->isComplex();
1572     bool isComplexOut = isComplexL || isComplexR;
1573
1574     if (_pR->isScalar())
1575     {
1576         pOut = (Polynom*)_pL->clone();
1577         SinglePoly** pSPR = _pL->get();
1578         SinglePoly** pSP = pOut->get();
1579         int iSize = pOut->getSize();
1580
1581         double dblR = _pR->get(0);
1582         if (isComplexL)
1583         {
1584             double dblI = _pR->getImg(0);
1585             pOut->setComplex(true);
1586             if (isComplexR)
1587             {
1588                 for (int i = 0 ; i < iSize ; i++)
1589                 {
1590                     dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1591                 }
1592             }
1593             else
1594             {
1595                 for (int i = 0 ; i < iSize ; i++)
1596                 {
1597                     dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1598                 }
1599             }
1600         }
1601         else
1602         {
1603             if (isComplexR)
1604             {
1605                 for (int i = 0 ; i < iSize ; i++)
1606                 {
1607                     dotdiv(pSP[i]->get(), pSP[i]->getImg(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get(), pSP[i]->getImg());
1608                 }
1609             }
1610             else
1611             {
1612                 //r ./ P
1613                 for (int i = 0 ; i < iSize ; i++)
1614                 {
1615                     dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get());
1616                 }
1617             }
1618         }
1619
1620         return pOut;
1621     }
1622
1623     if (_pL->isScalar())
1624     {
1625         pOut = new Polynom(_pL->getVariableName(), _pR->getDims(), _pR->getDimsArray());
1626         SinglePoly* pSPL = _pL->get(0);
1627         SinglePoly** pSP = pOut->get();
1628         int iSize = pOut->getSize();
1629         double* pdblLR = _pR->get();
1630         double* pdblLI = NULL;
1631         if (isComplexL)
1632         {
1633             pdblLI  = _pR->getImg();
1634         }
1635
1636         double* pdblRR = pSPL->get();
1637         double* pdblRI = NULL;
1638         if (isComplexR)
1639         {
1640             pdblRI = pSPL->getImg();
1641         }
1642
1643         if (isComplexL)
1644         {
1645             if (isComplexR)
1646             {
1647                 for (int i = 0 ; i < iSize ; ++i)
1648                 {
1649                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1650                     int iSPSize = pSPOut->getSize();
1651                     pSPOut->setComplex(isComplexOut);
1652
1653                     double* pdblOutR = pSPOut->get();
1654                     double* pdblOutI = pSPOut->getImg();
1655
1656                     dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1657                     pSP[i] = pSPOut;
1658                 }
1659             }
1660             else
1661             {
1662                 for (int i = 0 ; i < iSize ; ++i)
1663                 {
1664                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1665                     int iSPSize = pSPOut->getSize();
1666                     pSPOut->setComplex(isComplexOut);
1667
1668                     double* pdblOutR = pSPOut->get();
1669                     double* pdblOutI = pSPOut->getImg();
1670                     dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1671                     pSP[i] = pSPOut;
1672                 }
1673             }
1674         }
1675         else
1676         {
1677             if (isComplexR)
1678             {
1679                 for (int i = 0 ; i < iSize ; ++i)
1680                 {
1681                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1682                     int iSPSize = pSPOut->getSize();
1683                     pSPOut->setComplex(isComplexOut);
1684
1685                     double* pdblOutR = pSPOut->get();
1686                     double* pdblOutI = pSPOut->getImg();
1687                     dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblOutR, pdblOutI);
1688                     pSP[i] = pSPOut;
1689                 }
1690             }
1691             else
1692             {
1693                 for (int i = 0 ; i < iSize ; ++i)
1694                 {
1695                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1696                     int iSPSize = pSPOut->getSize();
1697                     pSPOut->setComplex(isComplexOut);
1698
1699                     double* pdblOutR = pSPOut->get();
1700                     dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblOutR);
1701                     pSP[i] = pSPOut;
1702                 }
1703             }
1704         }
1705
1706         return pOut;
1707
1708     }
1709
1710     //check dims
1711     int iDimsL = _pR->getDims();
1712     int iDimsR = _pL->getDims();
1713
1714     if (iDimsL != iDimsR)
1715     {
1716         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1717     }
1718
1719     int* piDimsL = _pR->getDimsArray();
1720     int* piDimsR = _pL->getDimsArray();
1721
1722     for (int i = 0 ; i < iDimsL ; ++i)
1723     {
1724         if (piDimsL[i] != piDimsR[i])
1725         {
1726             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1727         }
1728     }
1729
1730
1731     pOut = (Polynom*)_pL->clone();
1732     pOut->setComplex(isComplexOut);
1733     SinglePoly** pSPR = _pL->get();
1734     SinglePoly** pSP = pOut->get();
1735     int iSize = pOut->getSize();
1736
1737     double* pdblR = _pR->get();
1738     double* pdblI = NULL;
1739     if (isComplexL)
1740     {
1741         pdblI = _pR->getImg();
1742     }
1743
1744     if (isComplexL)
1745     {
1746         if (isComplexR)
1747         {
1748             for (int i = 0 ; i < iSize ; i++)
1749             {
1750                 dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1751             }
1752         }
1753         else
1754         {
1755             for (int i = 0 ; i < iSize ; i++)
1756             {
1757                 dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1758             }
1759         }
1760     }
1761     else
1762     {
1763         if (isComplexR)
1764         {
1765             for (int i = 0 ; i < iSize ; i++)
1766             {
1767                 dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get(), pSP[i]->getImg());
1768             }
1769         }
1770         else
1771         {
1772             //r ./ P
1773             for (int i = 0 ; i < iSize ; i++)
1774             {
1775                 dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get());
1776             }
1777         }
1778     }
1779
1780     return pOut;
1781 }
1782
1783 template<>
1784 InternalType* dotdiv_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1785 {
1786     return NULL;
1787 }