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