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