dotDivide scalar complex by matrix fixed.
[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     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1087     dotdiv(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), pOut->get(), pOut->getImg());
1088     return pOut;
1089 }
1090
1091 template<class T, class U, class O>
1092 InternalType* dotdiv_SC_MC(T *_pL, U *_pR)
1093 {
1094     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1095     dotdiv(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1096     return pOut;
1097 }
1098
1099 template<class T, class U, class O>
1100 InternalType* dotdiv_SC_S(T *_pL, U *_pR)
1101 {
1102     O* pOut = new O(0.0, 0.0);
1103     dotdiv(_pL->get(0), _pL->getImg(0), 1 , _pR->get(0), pOut->get(), pOut->getImg());
1104     return pOut;
1105 }
1106
1107 template<class T, class U, class O>
1108 InternalType* dotdiv_SC_SC(T *_pL, U *_pR)
1109 {
1110     O* pOut = new O(0.0, 0.0);
1111     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1112     return pOut;
1113 }
1114
1115 template<class T, class U, class O>
1116 InternalType* dotdiv_SC_I(T *_pL, U *_pR)
1117 {
1118     O* pOut = (O*)_pR->clone();
1119     pOut->setComplex(true);
1120     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1121     return pOut;
1122 }
1123
1124 template<class T, class U, class O>
1125 InternalType* dotdiv_SC_IC(T *_pL, U *_pR)
1126 {
1127     O* pOut = (O*)_pR->clone();
1128     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1129     return pOut;
1130 }
1131
1132 //Identity ./ x
1133 template<class T, class U, class O>
1134 InternalType* dotdiv_I_M(T *_pL, U *_pR)
1135 {
1136     return NULL;
1137 }
1138
1139 template<class T, class U, class O>
1140 InternalType* dotdiv_I_MC(T *_pL, U *_pR)
1141 {
1142     return NULL;
1143 }
1144
1145 template<class T, class U, class O>
1146 InternalType* dotdiv_I_S(T *_pL, U *_pR)
1147 {
1148     O* pOut = (O*)_pL->clone();
1149     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1150     return pOut;
1151 }
1152
1153 template<class T, class U, class O>
1154 InternalType* dotdiv_I_SC(T *_pL, U *_pR)
1155 {
1156     return dotdiv_SC_I<U, T, O>(_pR, _pL);
1157 }
1158
1159 template<class T, class U, class O>
1160 InternalType* dotdiv_I_I(T *_pL, U *_pR)
1161 {
1162     O* pOut = (O*)_pL->clone();
1163     dotdiv(_pL->get(0), _pR->get(0), pOut->get());
1164     return pOut;
1165 }
1166
1167 template<class T, class U, class O>
1168 InternalType* dotdiv_I_IC(T *_pL, U *_pR)
1169 {
1170     O* pOut = (O*)_pR->clone();
1171     dotdiv(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1172     return pOut;
1173 }
1174
1175 //Identity complex ./ x
1176 template<class T, class U, class O>
1177 InternalType* dotdiv_IC_M(T *_pL, U *_pR)
1178 {
1179     return NULL;
1180 }
1181
1182 template<class T, class U, class O>
1183 InternalType* dotdiv_IC_MC(T *_pL, U *_pR)
1184 {
1185     return NULL;
1186 }
1187
1188 template<class T, class U, class O>
1189 InternalType* dotdiv_IC_S(T *_pL, U *_pR)
1190 {
1191     O* pOut = (O*)_pL->clone();
1192     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1193     return pOut;
1194 }
1195
1196 template<class T, class U, class O>
1197 InternalType* dotdiv_IC_SC(T *_pL, U *_pR)
1198 {
1199     O* pOut = (O*)_pL->clone();
1200     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1201     return pOut;
1202 }
1203
1204 template<class T, class U, class O>
1205 InternalType* dotdiv_IC_I(T *_pL, U *_pR)
1206 {
1207     O* pOut = (O*)_pL->clone();
1208     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1209     return pOut;
1210 }
1211
1212 template<class T, class U, class O>
1213 InternalType* dotdiv_IC_IC(T *_pL, U *_pR)
1214 {
1215     O* pOut = (O*)_pL->clone();
1216     dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1217     return pOut;
1218 }
1219
1220
1221 template<>
1222 InternalType* dotdiv_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
1223 {
1224     //check dims
1225     if (_pL->isScalar())
1226     {
1227         Sparse* pOut = NULL;
1228         std::complex<double> c(_pL->getImg(0, 0));
1229         Double* pL = NULL;
1230         if (c.imag())
1231         {
1232             pL = new Double(c.real(), c.imag());
1233         }
1234         else
1235         {
1236             pL = new Double(c.real());
1237         }
1238         pOut = (Sparse*)dotdiv_M_M<Double, Sparse, Sparse>(pL, _pR);
1239         delete pL;
1240         return pOut;
1241     }
1242
1243     if (_pR->isScalar())
1244     {
1245         Sparse* pOut = NULL;
1246         std::complex<double> c(_pR->getImg(0, 0));
1247         Double* pR = NULL;
1248         if (c.imag())
1249         {
1250             pR = new Double(c.real(), c.imag());
1251         }
1252         else
1253         {
1254             pR = new Double(c.real());
1255         }
1256         pOut = (Sparse*)dotdiv_M_M<Sparse, Double, Sparse>(_pL, pR);
1257         delete pR;
1258         return pOut;
1259     }
1260
1261     //check dimensions
1262     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1263     {
1264         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1265     }
1266
1267     Sparse* pSparseOut = _pL->dotDivide(*_pR);
1268     pSparseOut->finalize();
1269     return pSparseOut;
1270 }
1271
1272 //[] ./ SP
1273 template<>
1274 InternalType* dotdiv_M_M<Double, Sparse, Double>(Double* _pL, Sparse* _pR)
1275 {
1276     return _pL;
1277 }
1278
1279 //SP ./ []
1280 template<>
1281 InternalType* dotdiv_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _pR)
1282 {
1283     return _pR;
1284 }
1285 //
1286 template<>
1287 InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
1288 {
1289     //D -> SP / SP
1290     if (_pL->isScalar())
1291     {
1292         Sparse* pOut = NULL;
1293         int iSizeOut = _pR->getSize();
1294         if (_pL->isComplex())
1295         {
1296             pOut = new Sparse(_pR->getRows(), _pR->getCols(), true);
1297             std::complex<double> stComplex(_pL->get(0), _pL->getImg(0));
1298             for (int i = 0 ; i < iSizeOut ; i++)
1299             {
1300                 if (_pR->get(i) != 0)
1301                 {
1302                     pOut->set(i, stComplex);
1303                 }
1304             }
1305         }
1306         else
1307         {
1308             pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
1309             for (int i = 0 ; i < iSizeOut ; i++)
1310             {
1311                 if (_pR->get(i) != 0)
1312                 {
1313                     pOut->set(i, _pL->get(0));
1314                 }
1315             }
1316         }
1317         return pOut->dotDivide(*_pR);
1318     }
1319
1320     if (_pR->isScalar())
1321     {
1322         //D / sp -> D ./ d
1323         Double* pD = NULL;
1324
1325         if (_pR->isComplex())
1326         {
1327             std::complex<double> dbl(_pR->getImg(0, 0));
1328             pD = new Double(dbl.real(), dbl.imag());
1329         }
1330         else
1331         {
1332             pD = new Double(_pR->get(0, 0));
1333         }
1334
1335         InternalType* pIT = GenericDotRDivide(_pL, pD);
1336         delete pD;
1337         return pIT;
1338     }
1339
1340
1341     //check dimensions
1342     if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1343     {
1344         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1345     }
1346
1347     //get some information
1348     int iNonZeros = static_cast<int>(_pR->nonZeros());
1349     int* pRows = new int[iNonZeros * 2];
1350     _pR->outputRowCol(pRows);
1351     int* pCols = pRows + iNonZeros;
1352     double* pValR = new double[iNonZeros];
1353     double* pValI = new double[iNonZeros];
1354     _pR->outputValues(pValR, pValI);
1355     double* pdblR = _pL->get();
1356     int iRows = _pL->getRows();
1357
1358     Sparse* pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex() || _pR->isComplex());
1359
1360     if (_pL->isComplex() == false)
1361     {
1362         if (_pR->isComplex() == false)
1363         {
1364             for (int i = 0 ; i < iNonZeros ; i++)
1365             {
1366                 int iRow = static_cast<int>(pRows[i]) - 1;
1367                 int iCol = static_cast<int>(pCols[i]) - 1;
1368                 int index = iCol * iRows + iRow;
1369
1370                 pOut->set(iRow, iCol,  pdblR[index] / pValR[i]);
1371             }
1372         }
1373         else
1374         {
1375             double dDenum = 0;
1376             for (int i = 0 ; i < iNonZeros ; i++)
1377             {
1378                 int iRow = static_cast<int>(pRows[i]) - 1;
1379                 int iCol = static_cast<int>(pCols[i]) - 1;
1380                 int index = iCol * iRows + iRow;
1381
1382                 std::complex<double> c;
1383                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
1384                 c.real((pdblR[index] * pValR[i]) / dDenum);
1385                 c.imag(-(pdblR[index] * pValI[i]) / dDenum);
1386                 pOut->set(iRow, iCol,  c);
1387             }
1388         }
1389     }
1390     else
1391     {
1392         double* pdblI = _pL->getImg();
1393         if (_pR->isComplex() == false)
1394         {
1395             for (int i = 0 ; i < iNonZeros ; i++)
1396             {
1397                 int iRow = static_cast<int>(pRows[i]) - 1;
1398                 int iCol = static_cast<int>(pCols[i]) - 1;
1399                 int index = iCol * iRows + iRow;
1400
1401                 std::complex<double> c;
1402                 c.real(pdblR[index] / pValR[i]);
1403                 c.imag(pdblI[index] / pValR[i]);
1404                 pOut->set(iRow, iCol,  c);
1405             }
1406         }
1407         else
1408         {
1409             double dDenum = 0;
1410             for (int i = 0 ; i < iNonZeros ; i++)
1411             {
1412                 int iRow = static_cast<int>(pRows[i]) - 1;
1413                 int iCol = static_cast<int>(pCols[i]) - 1;
1414                 int index = iCol * iRows + iRow;
1415
1416                 std::complex<double> c;
1417                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
1418                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
1419                 c.imag((pdblI[index] * pValR[i] - pdblR[index] * pValI[i]) / dDenum);
1420                 pOut->set(iRow, iCol,  c);
1421             }
1422         }
1423     }
1424
1425     delete[] pRows;
1426     delete[] pValR;
1427     delete[] pValI;
1428
1429     return pOut;
1430 }
1431
1432 template<>
1433 InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
1434 {
1435
1436     if (_pR->isScalar())
1437     {
1438         // SP / d-> SP
1439         Sparse* pOut = NULL;
1440         int iSizeOut = _pL->getSize();
1441         if (_pR->isComplex())
1442         {
1443             pOut = new Sparse(_pL->getRows(), _pL->getCols(), true);
1444             std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
1445             for (int i = 0 ; i < iSizeOut ; i++)
1446             {
1447                 if (_pL->get(i) != 0)
1448                 {
1449                     pOut->set(i, stComplex);
1450                 }
1451             }
1452         }
1453         else
1454         {
1455             pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
1456             std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
1457             for (int i = 0 ; i < iSizeOut ; i++)
1458             {
1459                 if (_pL->get(i) != 0)
1460                 {
1461                     pOut->set(i, _pR->get(0));
1462                 }
1463             }
1464         }
1465         return _pL->dotDivide(*pOut);
1466     }
1467
1468     if (_pL->isScalar())
1469     {
1470         //D / sp -> D ./ d
1471         Double* pD = NULL;
1472
1473         if (_pL->isComplex())
1474         {
1475             std::complex<double> dbl(_pL->getImg(0, 0));
1476             pD = new Double(dbl.real(), dbl.imag());
1477         }
1478         else
1479         {
1480             pD = new Double(_pL->get(0, 0));
1481         }
1482
1483         InternalType* pIT = GenericDotLDivide(_pR, pD);
1484         delete pD;
1485         return pIT;
1486     }
1487
1488
1489     //check dimensions
1490     if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
1491     {
1492         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1493     }
1494
1495     //get some information
1496     int iNonZeros = static_cast<int>(_pL->nonZeros());
1497     int* pRows = new int[iNonZeros * 2];
1498     _pL->outputRowCol(pRows);
1499     int* pCols = pRows + iNonZeros;
1500     double* pValR = new double[iNonZeros];
1501     double* pValI = new double[iNonZeros];
1502     _pL->outputValues(pValR, pValI);
1503     double* pdblR = _pR->get();
1504     int iRows = _pR->getRows();
1505
1506     Sparse* pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex() || _pL->isComplex());
1507
1508     if (_pR->isComplex() == false)
1509     {
1510         if (_pL->isComplex() == false)
1511         {
1512             for (int i = 0 ; i < iNonZeros ; i++)
1513             {
1514                 int iRow = static_cast<int>(pRows[i]) - 1;
1515                 int iCol = static_cast<int>(pCols[i]) - 1;
1516                 int index = iCol * iRows + iRow;
1517
1518                 pOut->set(iRow, iCol, pValR[i] / pdblR[index]  );
1519             }
1520         }
1521         else
1522         {
1523             for (int i = 0 ; i < iNonZeros ; i++)
1524             {
1525                 int iRow = static_cast<int>(pRows[i]) - 1;
1526                 int iCol = static_cast<int>(pCols[i]) - 1;
1527                 int index = iCol * iRows + iRow;
1528
1529                 std::complex<double> c;
1530                 c.real(pValR[i] / pdblR[index]);
1531                 c.imag(pValR[i] / pdblR[index]);
1532                 pOut->set(iRow, iCol,  c);
1533             }
1534         }
1535     }
1536     else
1537     {
1538         double* pdblI = _pR->getImg();
1539         double dDenum = 0;
1540         if (_pL->isComplex() == false)
1541         {
1542             for (int i = 0 ; i < iNonZeros ; i++)
1543             {
1544                 int iRow = static_cast<int>(pRows[i]) - 1;
1545                 int iCol = static_cast<int>(pCols[i]) - 1;
1546                 int index = iCol * iRows + iRow;
1547
1548                 std::complex<double> c;
1549                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
1550                 c.real((pValR[i]*pdblR[index]) / dDenum );
1551                 c.imag(-(pdblI[index]*pValR[i]) / dDenum );
1552                 pOut->set(iRow, iCol,  c);
1553             }
1554         }
1555         else
1556         {
1557             for (int i = 0 ; i < iNonZeros ; i++)
1558             {
1559                 int iRow = static_cast<int>(pRows[i]) - 1;
1560                 int iCol = static_cast<int>(pCols[i]) - 1;
1561                 int index = iCol * iRows + iRow;
1562
1563                 std::complex<double> c;
1564                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
1565                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
1566                 c.imag((pdblR[index] * pValI[i] - pdblI[index] * pValR[i]) / dDenum);
1567                 pOut->set(iRow, iCol,  c);
1568             }
1569         }
1570     }
1571
1572     delete[] pRows;
1573     delete[] pValR;
1574     delete[] pValI;
1575
1576     return pOut;
1577 }
1578
1579 //Polynom
1580 template<>
1581 InternalType* dotdiv_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1582 {
1583     return NULL;
1584 }
1585
1586 template<>
1587 InternalType* dotdiv_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1588 {
1589     Polynom* pOut = NULL;
1590
1591     bool isComplexL = _pR->isComplex();
1592     bool isComplexR = _pL->isComplex();
1593     bool isComplexOut = isComplexL || isComplexR;
1594
1595     if (_pR->isScalar())
1596     {
1597         pOut = (Polynom*)_pL->clone();
1598         SinglePoly** pSPR = _pL->get();
1599         SinglePoly** pSP = pOut->get();
1600         int iSize = pOut->getSize();
1601
1602         double dblR = _pR->get(0);
1603         if (isComplexL)
1604         {
1605             double dblI = _pR->getImg(0);
1606             pOut->setComplex(true);
1607             if (isComplexR)
1608             {
1609                 for (int i = 0 ; i < iSize ; i++)
1610                 {
1611                     dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1612                 }
1613             }
1614             else
1615             {
1616                 for (int i = 0 ; i < iSize ; i++)
1617                 {
1618                     dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1619                 }
1620             }
1621         }
1622         else
1623         {
1624             if (isComplexR)
1625             {
1626                 for (int i = 0 ; i < iSize ; i++)
1627                 {
1628                     dotdiv(pSP[i]->get(), pSP[i]->getImg(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get(), pSP[i]->getImg());
1629                 }
1630             }
1631             else
1632             {
1633                 //r ./ P
1634                 for (int i = 0 ; i < iSize ; i++)
1635                 {
1636                     dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get());
1637                 }
1638             }
1639         }
1640
1641         return pOut;
1642     }
1643
1644     if (_pL->isScalar())
1645     {
1646         pOut = new Polynom(_pL->getVariableName(), _pR->getDims(), _pR->getDimsArray());
1647         SinglePoly* pSPL = _pL->get(0);
1648         SinglePoly** pSP = pOut->get();
1649         int iSize = pOut->getSize();
1650         double* pdblLR = _pR->get();
1651         double* pdblLI = NULL;
1652         if (isComplexL)
1653         {
1654             pdblLI  = _pR->getImg();
1655         }
1656
1657         double* pdblRR = pSPL->get();
1658         double* pdblRI = NULL;
1659         if (isComplexR)
1660         {
1661             pdblRI = pSPL->getImg();
1662         }
1663
1664         if (isComplexL)
1665         {
1666             if (isComplexR)
1667             {
1668                 for (int i = 0 ; i < iSize ; ++i)
1669                 {
1670                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1671                     int iSPSize = pSPOut->getSize();
1672                     pSPOut->setComplex(isComplexOut);
1673
1674                     double* pdblOutR = pSPOut->get();
1675                     double* pdblOutI = pSPOut->getImg();
1676
1677                     dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1678                     pSP[i] = pSPOut;
1679                 }
1680             }
1681             else
1682             {
1683                 for (int i = 0 ; i < iSize ; ++i)
1684                 {
1685                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1686                     int iSPSize = pSPOut->getSize();
1687                     pSPOut->setComplex(isComplexOut);
1688
1689                     double* pdblOutR = pSPOut->get();
1690                     double* pdblOutI = pSPOut->getImg();
1691                     dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1692                     pSP[i] = pSPOut;
1693                 }
1694             }
1695         }
1696         else
1697         {
1698             if (isComplexR)
1699             {
1700                 for (int i = 0 ; i < iSize ; ++i)
1701                 {
1702                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1703                     int iSPSize = pSPOut->getSize();
1704                     pSPOut->setComplex(isComplexOut);
1705
1706                     double* pdblOutR = pSPOut->get();
1707                     double* pdblOutI = pSPOut->getImg();
1708                     dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblOutR, pdblOutI);
1709                     pSP[i] = pSPOut;
1710                 }
1711             }
1712             else
1713             {
1714                 for (int i = 0 ; i < iSize ; ++i)
1715                 {
1716                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1717                     int iSPSize = pSPOut->getSize();
1718                     pSPOut->setComplex(isComplexOut);
1719
1720                     double* pdblOutR = pSPOut->get();
1721                     dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblOutR);
1722                     pSP[i] = pSPOut;
1723                 }
1724             }
1725         }
1726
1727         return pOut;
1728
1729     }
1730
1731     //check dims
1732     int iDimsL = _pR->getDims();
1733     int iDimsR = _pL->getDims();
1734
1735     if (iDimsL != iDimsR)
1736     {
1737         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1738     }
1739
1740     int* piDimsL = _pR->getDimsArray();
1741     int* piDimsR = _pL->getDimsArray();
1742
1743     for (int i = 0 ; i < iDimsL ; ++i)
1744     {
1745         if (piDimsL[i] != piDimsR[i])
1746         {
1747             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1748         }
1749     }
1750
1751
1752     pOut = (Polynom*)_pL->clone();
1753     pOut->setComplex(isComplexOut);
1754     SinglePoly** pSPR = _pL->get();
1755     SinglePoly** pSP = pOut->get();
1756     int iSize = pOut->getSize();
1757
1758     double* pdblR = _pR->get();
1759     double* pdblI = NULL;
1760     if (isComplexL)
1761     {
1762         pdblI = _pR->getImg();
1763     }
1764
1765     if (isComplexL)
1766     {
1767         if (isComplexR)
1768         {
1769             for (int i = 0 ; i < iSize ; i++)
1770             {
1771                 dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1772             }
1773         }
1774         else
1775         {
1776             for (int i = 0 ; i < iSize ; i++)
1777             {
1778                 dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1779             }
1780         }
1781     }
1782     else
1783     {
1784         if (isComplexR)
1785         {
1786             for (int i = 0 ; i < iSize ; i++)
1787             {
1788                 dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get(), pSP[i]->getImg());
1789             }
1790         }
1791         else
1792         {
1793             //r ./ P
1794             for (int i = 0 ; i < iSize ; i++)
1795             {
1796                 dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get());
1797             }
1798         }
1799     }
1800
1801     return pOut;
1802 }
1803
1804 template<>
1805 InternalType* dotdiv_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1806 {
1807     return NULL;
1808 }