comparison equal and no equal
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_comparison_eq.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2012 - Scilab Enterprises - Antoine ELIAS
4  *  Copyright (C) 2015 - 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_comparison_eq.hxx"
15 #include "bool.hxx"
16 #include "double.hxx"
17 #include "string.hxx"
18 #include "polynom.hxx"
19 #include "cell.hxx"
20 #include "struct.hxx"
21 #include "sparse.hxx"
22 #include "int.hxx"
23 #include "graphichandle.hxx"
24 #include "mlist.hxx"
25 #include "macro.hxx"
26 #include "macrofile.hxx"
27
28 using namespace types;
29
30 //define arrays on operation functions
31 static compequal_function pComparisonEqualfunction[types::InternalType::IdLast][types::InternalType::IdLast] = { NULL };
32
33
34 void fillComparisonEqualFunction()
35 {
36 #define scilab_fill_comparisonequal(id1, id2, func, typeIn1, typeIn2, typeOut) \
37     pComparisonEqualfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (compequal_function)&compequal_##func<typeIn1, typeIn2, typeOut>
38
39     //String == String
40     scilab_fill_comparisonequal(String, String, M_M, String, String, Bool);
41     scilab_fill_comparisonequal(String, ScalarString, M_M, String, String, Bool);
42     scilab_fill_comparisonequal(ScalarString, ScalarString, M_M, String, String, Bool);
43     scilab_fill_comparisonequal(ScalarString, String, M_M, String, String, Bool);
44     //String == Empty
45     scilab_fill_comparisonequal(Empty, ScalarString, E_M, String, String, Bool);
46     scilab_fill_comparisonequal(ScalarString, Empty, M_E, String, String, Bool);
47     scilab_fill_comparisonequal(String, Empty, M_E, String, String, Bool);
48     scilab_fill_comparisonequal(Empty, String, E_M, String, String, Bool);
49     //String == Double
50     scilab_fill_comparisonequal(Double, ScalarString, M_E, Double, String, Bool);
51     scilab_fill_comparisonequal(ScalarString, Double, M_E, String, Double, Bool);
52     scilab_fill_comparisonequal(String, Double, M_E, String, Double, Bool);
53     scilab_fill_comparisonequal(Double, String, M_E, Double, String, Bool);
54     //String == ScalarDouble
55     scilab_fill_comparisonequal(ScalarDouble, ScalarString, M_E, Double, String, Bool);
56     scilab_fill_comparisonequal(ScalarString, ScalarDouble, M_E, String, Double, Bool);
57     scilab_fill_comparisonequal(String, ScalarDouble, M_E, String, Double, Bool);
58     scilab_fill_comparisonequal(ScalarDouble, String, M_E, Double, String, Bool);
59     //String == Int8
60     scilab_fill_comparisonequal(Int8, ScalarString, M_E, Int8, String, Bool);
61     scilab_fill_comparisonequal(ScalarString, Int8, M_E, String, Int8, Bool);
62     scilab_fill_comparisonequal(String, Int8, M_E, String, Int8, Bool);
63     scilab_fill_comparisonequal(Int8, String, M_E, Int8, String, Bool);
64     //String == UInt8
65     scilab_fill_comparisonequal(UInt8, ScalarString, M_E, UInt8, String, Bool);
66     scilab_fill_comparisonequal(ScalarString, UInt8, M_E, String, UInt8, Bool);
67     scilab_fill_comparisonequal(String, UInt8, M_E, String, UInt8, Bool);
68     scilab_fill_comparisonequal(UInt8, String, M_E, UInt8, String, Bool);
69     //String == Int16
70     scilab_fill_comparisonequal(Int16, ScalarString, M_E, Int16, String, Bool);
71     scilab_fill_comparisonequal(ScalarString, Int16, M_E, String, Int16, Bool);
72     scilab_fill_comparisonequal(String, Int16, M_E, String, Int16, Bool);
73     scilab_fill_comparisonequal(Int16, String, M_E, Int16, String, Bool);
74     //String == UInt16
75     scilab_fill_comparisonequal(UInt16, ScalarString, M_E, UInt16, String, Bool);
76     scilab_fill_comparisonequal(ScalarString, UInt16, M_E, String, UInt16, Bool);
77     scilab_fill_comparisonequal(String, UInt16, M_E, String, UInt16, Bool);
78     scilab_fill_comparisonequal(UInt16, String, M_E, UInt16, String, Bool);
79     //String == Int32
80     scilab_fill_comparisonequal(Int32, ScalarString, M_E, Int32, String, Bool);
81     scilab_fill_comparisonequal(ScalarString, Int32, M_E, String, Int32, Bool);
82     scilab_fill_comparisonequal(String, Int32, M_E, String, Int32, Bool);
83     scilab_fill_comparisonequal(Int32, String, M_E, Int32, String, Bool);
84     //String == UInt32
85     scilab_fill_comparisonequal(UInt32, ScalarString, M_E, UInt32, String, Bool);
86     scilab_fill_comparisonequal(ScalarString, UInt32, M_E, String, UInt32, Bool);
87     scilab_fill_comparisonequal(String, UInt32, M_E, String, UInt32, Bool);
88     scilab_fill_comparisonequal(UInt32, String, M_E, UInt32, String, Bool);
89     //String == Int64
90     scilab_fill_comparisonequal(Int64, ScalarString, M_E, Int64, String, Bool);
91     scilab_fill_comparisonequal(ScalarString, Int64, M_E, String, Int64, Bool);
92     scilab_fill_comparisonequal(String, Int64, M_E, String, Int64, Bool);
93     scilab_fill_comparisonequal(Int64, String, M_E, Int64, String, Bool);
94     //String == UInt64
95     scilab_fill_comparisonequal(UInt64, ScalarString, M_E, UInt64, String, Bool);
96     scilab_fill_comparisonequal(ScalarString, UInt64, M_E, String, UInt64, Bool);
97     scilab_fill_comparisonequal(String, UInt64, M_E, String, UInt64, Bool);
98     scilab_fill_comparisonequal(UInt64, String, M_E, UInt64, String, Bool);
99     //String == Bool
100     scilab_fill_comparisonequal(Bool, ScalarString, M_E, Bool, String, Bool);
101     scilab_fill_comparisonequal(ScalarString, Bool, M_E, String, Bool, Bool);
102     scilab_fill_comparisonequal(String, Bool, M_E, String, Bool, Bool);
103     scilab_fill_comparisonequal(Bool, String, M_E, Bool, String, Bool);
104     //String == Polynom
105     scilab_fill_comparisonequal(Polynom, ScalarString, M_E, Polynom, String, Bool);
106     scilab_fill_comparisonequal(ScalarString, Polynom, M_E, String, Polynom, Bool);
107     scilab_fill_comparisonequal(String, Polynom, M_E, String, Polynom, Bool);
108     scilab_fill_comparisonequal(Polynom, String, M_E, Polynom, String, Bool);
109     //String == PolynomComplex
110     scilab_fill_comparisonequal(PolynomComplex, ScalarString, M_E, Polynom, String, Bool);
111     scilab_fill_comparisonequal(ScalarString, PolynomComplex, M_E, String, Polynom, Bool);
112     scilab_fill_comparisonequal(String, PolynomComplex, M_E, String, Polynom, Bool);
113     scilab_fill_comparisonequal(PolynomComplex, String, M_E, Polynom, String, Bool);
114     //String == ScalarPolynom
115     scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
116     scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
117     scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
118     scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
119     //String == ScalarPolynomComplex
120     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
121     scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
122     scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
123     scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
124     //String == Sparse
125     scilab_fill_comparisonequal(Sparse, ScalarString, M_E, Sparse, String, Bool);
126     scilab_fill_comparisonequal(ScalarString, Sparse, M_E, String, Sparse, Bool);
127     scilab_fill_comparisonequal(String, Sparse, M_E, String, Sparse, Bool);
128     scilab_fill_comparisonequal(Sparse, String, M_E, Sparse, String, Bool);
129     //String == SparseBool
130     scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
131     scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
132     scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
133     scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
134     //String == ScalarInt8
135     scilab_fill_comparisonequal(ScalarInt8, ScalarString, M_E, Int8, String, Bool);
136     scilab_fill_comparisonequal(ScalarString, ScalarInt8, M_E, String, Int8, Bool);
137     scilab_fill_comparisonequal(String, ScalarInt8, M_E, String, Int8, Bool);
138     scilab_fill_comparisonequal(ScalarInt8, String, M_E, Int8, String, Bool);
139     //String == ScalarUInt8
140     scilab_fill_comparisonequal(ScalarUInt8, ScalarString, M_E, UInt8, String, Bool);
141     scilab_fill_comparisonequal(ScalarString, ScalarUInt8, M_E, String, UInt8, Bool);
142     scilab_fill_comparisonequal(String, ScalarUInt8, M_E, String, UInt8, Bool);
143     scilab_fill_comparisonequal(ScalarUInt8, String, M_E, UInt8, String, Bool);
144     //String == ScalarInt16
145     scilab_fill_comparisonequal(ScalarInt16, ScalarString, M_E, Int16, String, Bool);
146     scilab_fill_comparisonequal(ScalarString, ScalarInt16, M_E, String, Int16, Bool);
147     scilab_fill_comparisonequal(String, ScalarInt16, M_E, String, Int16, Bool);
148     scilab_fill_comparisonequal(ScalarInt16, String, M_E, Int16, String, Bool);
149     //String == ScalarUInt16
150     scilab_fill_comparisonequal(ScalarUInt16, ScalarString, M_E, UInt16, String, Bool);
151     scilab_fill_comparisonequal(ScalarString, ScalarUInt16, M_E, String, UInt16, Bool);
152     scilab_fill_comparisonequal(String, ScalarUInt16, M_E, String, UInt16, Bool);
153     scilab_fill_comparisonequal(ScalarUInt16, String, M_E, UInt16, String, Bool);
154     //String == ScalarInt32
155     scilab_fill_comparisonequal(ScalarInt32, ScalarString, M_E, Int32, String, Bool);
156     scilab_fill_comparisonequal(ScalarString, ScalarInt32, M_E, String, Int32, Bool);
157     scilab_fill_comparisonequal(String, ScalarInt32, M_E, String, Int32, Bool);
158     scilab_fill_comparisonequal(ScalarInt32, String, M_E, Int32, String, Bool);
159     //String == ScalarUInt32
160     scilab_fill_comparisonequal(ScalarUInt32, ScalarString, M_E, UInt32, String, Bool);
161     scilab_fill_comparisonequal(ScalarString, ScalarUInt32, M_E, String, UInt32, Bool);
162     scilab_fill_comparisonequal(String, ScalarUInt32, M_E, String, UInt32, Bool);
163     scilab_fill_comparisonequal(ScalarUInt32, String, M_E, UInt32, String, Bool);
164     //String == ScalarInt64
165     scilab_fill_comparisonequal(ScalarInt64, ScalarString, M_E, Int64, String, Bool);
166     scilab_fill_comparisonequal(ScalarString, ScalarInt64, M_E, String, Int64, Bool);
167     scilab_fill_comparisonequal(String, ScalarInt64, M_E, String, Int64, Bool);
168     scilab_fill_comparisonequal(ScalarInt64, String, M_E, Int64, String, Bool);
169     //String == ScalarUInt64
170     scilab_fill_comparisonequal(ScalarUInt64, ScalarString, M_E, UInt64, String, Bool);
171     scilab_fill_comparisonequal(ScalarString, ScalarUInt64, M_E, String, UInt64, Bool);
172     scilab_fill_comparisonequal(String, ScalarUInt64, M_E, String, UInt64, Bool);
173     scilab_fill_comparisonequal(ScalarUInt64, String, M_E, UInt64, String, Bool);
174     //String == ScalarBool
175     scilab_fill_comparisonequal(ScalarBool, ScalarString, M_E, Bool, String, Bool);
176     scilab_fill_comparisonequal(ScalarString, ScalarBool, M_E, String, Bool, Bool);
177     scilab_fill_comparisonequal(String, ScalarBool, M_E, String, Bool, Bool);
178     scilab_fill_comparisonequal(ScalarBool, String, M_E, Bool, String, Bool);
179     //String == ScalarPolynom
180     scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
181     scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
182     scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
183     scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
184     //String == ScalarDoubleComplex
185     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarString, M_E, Double, String, Bool);
186     scilab_fill_comparisonequal(ScalarString, ScalarDoubleComplex, M_E, String, Double, Bool);
187     scilab_fill_comparisonequal(String, ScalarDoubleComplex, M_E, String, Double, Bool);
188     scilab_fill_comparisonequal(ScalarDoubleComplex, String, M_E, Double, String, Bool);
189     //String == DoubleComplex
190     scilab_fill_comparisonequal(DoubleComplex, ScalarString, M_E, Double, String, Bool);
191     scilab_fill_comparisonequal(ScalarString, DoubleComplex, M_E, String, Double, Bool);
192     scilab_fill_comparisonequal(String, DoubleComplex, M_E, String, Double, Bool);
193     scilab_fill_comparisonequal(DoubleComplex, String, M_E, Double, String, Bool);
194     //String == ScalarPolynomComplex
195     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
196     scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
197     scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
198     scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
199     //String == SparseComplex
200     scilab_fill_comparisonequal(SparseComplex, ScalarString, M_E, Sparse, String, Bool);
201     scilab_fill_comparisonequal(ScalarString, SparseComplex, M_E, String, Sparse, Bool);
202     scilab_fill_comparisonequal(String, SparseComplex, M_E, String, Sparse, Bool);
203     scilab_fill_comparisonequal(SparseComplex, String, M_E, Sparse, String, Bool);
204     //String == Identity
205     scilab_fill_comparisonequal(Identity, ScalarString, M_E, Double, String, Bool);
206     scilab_fill_comparisonequal(ScalarString, Identity, M_E, String, Double, Bool);
207     scilab_fill_comparisonequal(String, Identity, M_E, String, Double, Bool);
208     scilab_fill_comparisonequal(Identity, String, M_E, Double, String, Bool);
209     //String == IdentityComplex
210     scilab_fill_comparisonequal(IdentityComplex, ScalarString, M_E, Double, String, Bool);
211     scilab_fill_comparisonequal(ScalarString, IdentityComplex, M_E, String, Double, Bool);
212     scilab_fill_comparisonequal(String, IdentityComplex, M_E, String, Double, Bool);
213     scilab_fill_comparisonequal(IdentityComplex, String, M_E, Double, String, Bool);
214
215     //Double
216     //Matrix == Matrix
217     scilab_fill_comparisonequal(Double, Double, M_M, Double, Double, Bool);
218     scilab_fill_comparisonequal(Double, Int8, M_M, Double, Int8, Bool);
219     scilab_fill_comparisonequal(Double, UInt8, M_M, Double, UInt8, Bool);
220     scilab_fill_comparisonequal(Double, Int16, M_M, Double, Int16, Bool);
221     scilab_fill_comparisonequal(Double, UInt16, M_M, Double, UInt16, Bool);
222     scilab_fill_comparisonequal(Double, Int32, M_M, Double, Int32, Bool);
223     scilab_fill_comparisonequal(Double, UInt32, M_M, Double, UInt32, Bool);
224     scilab_fill_comparisonequal(Double, Int64, M_M, Double, Int64, Bool);
225     scilab_fill_comparisonequal(Double, UInt64, M_M, Double, UInt64, Bool);
226     scilab_fill_comparisonequal(Double, Bool, M_E, Double, Bool, Bool);
227     scilab_fill_comparisonequal(Double, Polynom, M_P, Double, Polynom, Bool);
228     scilab_fill_comparisonequal(Double, Sparse, M_SP, Double, Sparse, SparseBool);
229
230     //Matrix == Matrix Complex
231     scilab_fill_comparisonequal(Double, DoubleComplex, M_MC, Double, Double, Bool);
232     scilab_fill_comparisonequal(Double, PolynomComplex, M_P, Double, Polynom, Bool);
233     scilab_fill_comparisonequal(Double, SparseComplex, M_SP, Double, Sparse, SparseBool);
234
235     //Matrix == Scalar
236     scilab_fill_comparisonequal(Double, ScalarDouble, M_S, Double, Double, Bool);
237     scilab_fill_comparisonequal(Double, ScalarInt8, M_S, Double, Int8, Bool);
238     scilab_fill_comparisonequal(Double, ScalarUInt8, M_S, Double, UInt8, Bool);
239     scilab_fill_comparisonequal(Double, ScalarInt16, M_S, Double, Int16, Bool);
240     scilab_fill_comparisonequal(Double, ScalarUInt16, M_S, Double, UInt16, Bool);
241     scilab_fill_comparisonequal(Double, ScalarInt32, M_S, Double, Int32, Bool);
242     scilab_fill_comparisonequal(Double, ScalarUInt32, M_S, Double, UInt32, Bool);
243     scilab_fill_comparisonequal(Double, ScalarInt64, M_S, Double, Int64, Bool);
244     scilab_fill_comparisonequal(Double, ScalarUInt64, M_S, Double, UInt64, Bool);
245     scilab_fill_comparisonequal(Double, ScalarBool, M_E, Double, Bool, Bool);
246     scilab_fill_comparisonequal(Double, ScalarPolynom, M_P, Double, Polynom, Bool);
247
248     //Matrix == Scalar Complex
249     scilab_fill_comparisonequal(Double, ScalarDoubleComplex, M_SC, Double, Double, Bool);
250     scilab_fill_comparisonequal(Double, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
251
252     //Matrix == Empty
253     scilab_fill_comparisonequal(Double, Empty, M_E, Double, Double, Bool);
254
255
256     //Matrix Complex == Matrix
257     scilab_fill_comparisonequal(DoubleComplex, Double, MC_M, Double, Double, Bool);
258     scilab_fill_comparisonequal(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Bool);
259     scilab_fill_comparisonequal(DoubleComplex, ScalarDouble, MC_S, Double, Double, Bool);
260     scilab_fill_comparisonequal(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Bool);
261     scilab_fill_comparisonequal(DoubleComplex, Empty, M_E, Double, Double, Bool);
262     scilab_fill_comparisonequal(DoubleComplex, Polynom, M_P, Double, Polynom, Bool);
263     scilab_fill_comparisonequal(DoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
264     scilab_fill_comparisonequal(DoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
265     scilab_fill_comparisonequal(DoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
266     scilab_fill_comparisonequal(DoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
267     scilab_fill_comparisonequal(DoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
268
269     //Scalar == Matrix
270     scilab_fill_comparisonequal(ScalarDouble, Double, S_M, Double, Double, Bool);
271     scilab_fill_comparisonequal(ScalarDouble, Int8, S_M, Double, Int8, Bool);
272     scilab_fill_comparisonequal(ScalarDouble, UInt8, S_M, Double, UInt8, Bool);
273     scilab_fill_comparisonequal(ScalarDouble, Int16, S_M, Double, Int16, Bool);
274     scilab_fill_comparisonequal(ScalarDouble, UInt16, S_M, Double, UInt16, Bool);
275     scilab_fill_comparisonequal(ScalarDouble, Int32, S_M, Double, Int32, Bool);
276     scilab_fill_comparisonequal(ScalarDouble, UInt32, S_M, Double, UInt32, Bool);
277     scilab_fill_comparisonequal(ScalarDouble, Int64, S_M, Double, Int64, Bool);
278     scilab_fill_comparisonequal(ScalarDouble, UInt64, S_M, Double, UInt64, Bool);
279     scilab_fill_comparisonequal(ScalarDouble, Bool, M_E, Double, Bool, Bool);
280     scilab_fill_comparisonequal(ScalarDouble, Polynom, M_P, Double, Polynom, Bool);
281     scilab_fill_comparisonequal(ScalarDouble, Sparse, M_SP, Double, Sparse, SparseBool);
282
283     //Scalar == Matrix Complex
284     scilab_fill_comparisonequal(ScalarDouble, DoubleComplex, S_MC, Double, Double, Bool);
285     scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
286     scilab_fill_comparisonequal(ScalarDouble, SparseComplex, M_SP, Double, Sparse, SparseBool);
287
288     //Scalar == Scalar
289     scilab_fill_comparisonequal(ScalarDouble, ScalarDouble, S_S, Double, Double, Bool);
290     scilab_fill_comparisonequal(ScalarDouble, ScalarInt8, S_S, Double, Int8, Bool);
291     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, Bool);
292     scilab_fill_comparisonequal(ScalarDouble, ScalarInt16, S_S, Double, Int16, Bool);
293     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, Bool);
294     scilab_fill_comparisonequal(ScalarDouble, ScalarInt32, S_S, Double, Int32, Bool);
295     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, Bool);
296     scilab_fill_comparisonequal(ScalarDouble, ScalarInt64, S_S, Double, Int64, Bool);
297     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, Bool);
298     scilab_fill_comparisonequal(ScalarDouble, ScalarBool, M_E, Double, Bool, Bool);
299     scilab_fill_comparisonequal(ScalarDouble, ScalarPolynom, M_P, Double, Polynom, Bool);
300
301     //Scalar == Scalar Complex
302     scilab_fill_comparisonequal(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Bool);
303     scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
304     scilab_fill_comparisonequal(ScalarDouble, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
305
306     //Scalar == Empty
307     scilab_fill_comparisonequal(ScalarDouble, Empty, M_E, Double, Double, Bool);
308
309     //Scalar Complex == Matrix
310     scilab_fill_comparisonequal(ScalarDoubleComplex, Double, SC_M, Double, Double, Bool);
311     scilab_fill_comparisonequal(ScalarDoubleComplex, Polynom, M_P, Double, Polynom, Bool);
312     scilab_fill_comparisonequal(ScalarDoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
313     //Scalar Complex == Matrix Complex
314     scilab_fill_comparisonequal(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Bool);
315     scilab_fill_comparisonequal(ScalarDoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
316     scilab_fill_comparisonequal(ScalarDoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
317     //Scalar Complex == Scalar
318     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Bool);
319     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
320     //Scalar Complex == Scalar Complex
321     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Bool);
322     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
323     //Scalar Complex == Empty
324     scilab_fill_comparisonequal(ScalarDoubleComplex, Empty, M_E, Double, Double, Bool);
325
326     //Empty == Matrix
327     scilab_fill_comparisonequal(Empty, Double, E_M, Double, Double, Bool);
328     scilab_fill_comparisonequal(Empty, Int8, E_M, Double, Int8, Bool);
329     scilab_fill_comparisonequal(Empty, UInt8, E_M, Double, UInt8, Bool);
330     scilab_fill_comparisonequal(Empty, Int16, E_M, Double, Int16, Bool);
331     scilab_fill_comparisonequal(Empty, UInt16, E_M, Double, UInt16, Bool);
332     scilab_fill_comparisonequal(Empty, Int32, E_M, Double, Int32, Bool);
333     scilab_fill_comparisonequal(Empty, UInt32, E_M, Double, UInt32, Bool);
334     scilab_fill_comparisonequal(Empty, Int64, E_M, Double, Int64, Bool);
335     scilab_fill_comparisonequal(Empty, UInt64, E_M, Double, UInt64, Bool);
336
337     scilab_fill_comparisonequal(Empty, Polynom, E_M, Double, Polynom, Bool);
338     scilab_fill_comparisonequal(Empty, PolynomComplex, E_M, Double, Polynom, Bool);
339     scilab_fill_comparisonequal(Empty, Sparse, E_M, Double, Sparse, Bool);
340     scilab_fill_comparisonequal(Empty, SparseComplex, E_M, Double, Sparse, Bool);
341
342     //Empty == Matrix Complex
343     scilab_fill_comparisonequal(Empty, DoubleComplex, E_M, Double, Double, Bool);
344     //Empty == Scalar
345     scilab_fill_comparisonequal(Empty, ScalarDouble, E_M, Double, Double, Bool);
346     scilab_fill_comparisonequal(Empty, ScalarInt8, E_M, Double, Int8, Bool);
347     scilab_fill_comparisonequal(Empty, ScalarUInt8, E_M, Double, UInt8, Bool);
348     scilab_fill_comparisonequal(Empty, ScalarInt16, E_M, Double, Int16, Bool);
349     scilab_fill_comparisonequal(Empty, ScalarUInt16, E_M, Double, UInt16, Bool);
350     scilab_fill_comparisonequal(Empty, ScalarInt32, E_M, Double, Int32, Bool);
351     scilab_fill_comparisonequal(Empty, ScalarUInt32, E_M, Double, UInt32, Bool);
352     scilab_fill_comparisonequal(Empty, ScalarInt64, E_M, Double, Int64, Bool);
353     scilab_fill_comparisonequal(Empty, ScalarUInt64, E_M, Double, UInt64, Bool);
354     scilab_fill_comparisonequal(Empty, ScalarBool, E_M, Double, Bool, Bool);
355     scilab_fill_comparisonequal(Empty, ScalarPolynom, E_M, Double, Polynom, Bool);
356
357     //Empty == Scalar Complex
358     scilab_fill_comparisonequal(Empty, ScalarDoubleComplex, E_M, Double, Double, Bool);
359     scilab_fill_comparisonequal(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Bool);
360     //Empty == Empty
361     scilab_fill_comparisonequal(Empty, Empty, E_E, Double, Double, Bool);
362     //Empty == eye
363     scilab_fill_comparisonequal(Empty, Identity, E_M, Double, Double, Bool);
364     scilab_fill_comparisonequal(Empty, IdentityComplex, E_M, Double, Double, Bool);
365
366     //Matrix == Identity
367     scilab_fill_comparisonequal(Double, Identity, M_I, Double, Double, Bool);
368     scilab_fill_comparisonequal(Double, IdentityComplex, M_IC, Double, Double, Bool);
369     scilab_fill_comparisonequal(DoubleComplex, Identity, MC_I, Double, Double, Bool);
370     scilab_fill_comparisonequal(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Bool);
371     scilab_fill_comparisonequal(ScalarDouble, Identity, S_I, Double, Double, Bool);
372     scilab_fill_comparisonequal(ScalarDouble, IdentityComplex, S_IC, Double, Double, Bool);
373     scilab_fill_comparisonequal(ScalarDoubleComplex, Identity, SC_I, Double, Double, Bool);
374     scilab_fill_comparisonequal(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Bool);
375
376     //Int8
377     //Matrix == Matrix
378     scilab_fill_comparisonequal(Int8, Double, M_M, Int8, Double, Bool);
379     scilab_fill_comparisonequal(Int8, Int8, M_M, Int8, Int8, Bool);
380     scilab_fill_comparisonequal(Int8, UInt8, M_M, Int8, UInt8, Bool);
381     scilab_fill_comparisonequal(Int8, Int16, M_M, Int8, Int16, Bool);
382     scilab_fill_comparisonequal(Int8, UInt16, M_M, Int8, UInt16, Bool);
383     scilab_fill_comparisonequal(Int8, Int32, M_M, Int8, Int32, Bool);
384     scilab_fill_comparisonequal(Int8, UInt32, M_M, Int8, UInt32, Bool);
385     scilab_fill_comparisonequal(Int8, Int64, M_M, Int8, Int64, Bool);
386     scilab_fill_comparisonequal(Int8, UInt64, M_M, Int8, UInt64, Bool);
387     scilab_fill_comparisonequal(Int8, Bool, M_B, Int8, Bool, Bool);
388     scilab_fill_comparisonequal(Int8, Empty, M_E, Int8, Double, Bool);
389
390     //Matrix == Scalar
391     scilab_fill_comparisonequal(Int8, ScalarDouble, M_S, Int8, Double, Bool);
392     scilab_fill_comparisonequal(Int8, ScalarInt8, M_S, Int8, Int8, Bool);
393     scilab_fill_comparisonequal(Int8, ScalarUInt8, M_S, Int8, UInt8, Bool);
394     scilab_fill_comparisonequal(Int8, ScalarInt16, M_S, Int8, Int16, Bool);
395     scilab_fill_comparisonequal(Int8, ScalarUInt16, M_S, Int8, UInt16, Bool);
396     scilab_fill_comparisonequal(Int8, ScalarInt32, M_S, Int8, Int32, Bool);
397     scilab_fill_comparisonequal(Int8, ScalarUInt32, M_S, Int8, UInt32, Bool);
398     scilab_fill_comparisonequal(Int8, ScalarInt64, M_S, Int8, Int64, Bool);
399     scilab_fill_comparisonequal(Int8, ScalarUInt64, M_S, Int8, UInt64, Bool);
400     scilab_fill_comparisonequal(Int8, ScalarBool, M_B, Int8, Bool, Bool);
401
402     //Scalar == Matrix
403     scilab_fill_comparisonequal(ScalarInt8, Double, S_M, Int8, Double, Bool);
404     scilab_fill_comparisonequal(ScalarInt8, Int8, S_M, Int8, Int8, Bool);
405     scilab_fill_comparisonequal(ScalarInt8, UInt8, S_M, Int8, UInt8, Bool);
406     scilab_fill_comparisonequal(ScalarInt8, Int16, S_M, Int8, Int16, Bool);
407     scilab_fill_comparisonequal(ScalarInt8, UInt16, S_M, Int8, UInt16, Bool);
408     scilab_fill_comparisonequal(ScalarInt8, Int32, S_M, Int8, Int32, Bool);
409     scilab_fill_comparisonequal(ScalarInt8, UInt32, S_M, Int8, UInt32, Bool);
410     scilab_fill_comparisonequal(ScalarInt8, Int64, S_M, Int8, Int64, Bool);
411     scilab_fill_comparisonequal(ScalarInt8, UInt64, S_M, Int8, UInt64, Bool);
412     scilab_fill_comparisonequal(ScalarInt8, Bool, S_B, Int8, Bool, Bool);
413     scilab_fill_comparisonequal(ScalarInt8, Empty, M_E, Int8, Double, Bool);
414
415     //Scalar == Scalar
416     scilab_fill_comparisonequal(ScalarInt8, ScalarDouble, S_S, Int8, Double, Bool);
417     scilab_fill_comparisonequal(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Bool);
418     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, Bool);
419     scilab_fill_comparisonequal(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Bool);
420     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, Bool);
421     scilab_fill_comparisonequal(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Bool);
422     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, Bool);
423     scilab_fill_comparisonequal(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Bool);
424     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, Bool);
425     scilab_fill_comparisonequal(ScalarInt8, ScalarBool, M_E, Int8, Bool, Bool);
426
427     //UInt8
428     //Matrix == Matrix
429     scilab_fill_comparisonequal(UInt8, Double, M_M, UInt8, Double, Bool);
430     scilab_fill_comparisonequal(UInt8, Int8, M_M, UInt8, Int8, Bool);
431     scilab_fill_comparisonequal(UInt8, UInt8, M_M, UInt8, UInt8, Bool);
432     scilab_fill_comparisonequal(UInt8, Int16, M_M, UInt8, Int16, Bool);
433     scilab_fill_comparisonequal(UInt8, UInt16, M_M, UInt8, UInt16, Bool);
434     scilab_fill_comparisonequal(UInt8, Int32, M_M, UInt8, Int32, Bool);
435     scilab_fill_comparisonequal(UInt8, UInt32, M_M, UInt8, UInt32, Bool);
436     scilab_fill_comparisonequal(UInt8, Int64, M_M, UInt8, Int64, Bool);
437     scilab_fill_comparisonequal(UInt8, UInt64, M_M, UInt8, UInt64, Bool);
438     scilab_fill_comparisonequal(UInt8, Bool, M_B, UInt8, Bool, Bool);
439     scilab_fill_comparisonequal(UInt8, Empty, M_E, UInt8, Double, Bool);
440
441     //Matrix == Scalar
442     scilab_fill_comparisonequal(UInt8, ScalarDouble, M_S, UInt8, Double, Bool);
443     scilab_fill_comparisonequal(UInt8, ScalarInt8, M_S, UInt8, Int8, Bool);
444     scilab_fill_comparisonequal(UInt8, ScalarUInt8, M_S, UInt8, UInt8, Bool);
445     scilab_fill_comparisonequal(UInt8, ScalarInt16, M_S, UInt8, Int16, Bool);
446     scilab_fill_comparisonequal(UInt8, ScalarUInt16, M_S, UInt8, UInt16, Bool);
447     scilab_fill_comparisonequal(UInt8, ScalarInt32, M_S, UInt8, Int32, Bool);
448     scilab_fill_comparisonequal(UInt8, ScalarUInt32, M_S, UInt8, UInt32, Bool);
449     scilab_fill_comparisonequal(UInt8, ScalarInt64, M_S, UInt8, Int64, Bool);
450     scilab_fill_comparisonequal(UInt8, ScalarUInt64, M_S, UInt8, UInt64, Bool);
451     scilab_fill_comparisonequal(UInt8, ScalarBool, M_B, UInt8, Bool, Bool);
452
453     //Scalar == Matrix
454     scilab_fill_comparisonequal(ScalarUInt8, Double, S_M, UInt8, Double, Bool);
455     scilab_fill_comparisonequal(ScalarUInt8, Int8, S_M, UInt8, Int8, Bool);
456     scilab_fill_comparisonequal(ScalarUInt8, UInt8, S_M, UInt8, UInt8, Bool);
457     scilab_fill_comparisonequal(ScalarUInt8, Int16, S_M, UInt8, Int16, Bool);
458     scilab_fill_comparisonequal(ScalarUInt8, UInt16, S_M, UInt8, UInt16, Bool);
459     scilab_fill_comparisonequal(ScalarUInt8, Int32, S_M, UInt8, Int32, Bool);
460     scilab_fill_comparisonequal(ScalarUInt8, UInt32, S_M, UInt8, UInt32, Bool);
461     scilab_fill_comparisonequal(ScalarUInt8, Int64, S_M, UInt8, Int64, Bool);
462     scilab_fill_comparisonequal(ScalarUInt8, UInt64, S_M, UInt8, UInt64, Bool);
463     scilab_fill_comparisonequal(ScalarUInt8, Bool, S_B, UInt8, Bool, Bool);
464     scilab_fill_comparisonequal(ScalarUInt8, Empty, M_E, UInt8, Double, Bool);
465
466     //Scalar == Scalar
467     scilab_fill_comparisonequal(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, Bool);
468     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, Bool);
469     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, Bool);
470     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, Bool);
471     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, Bool);
472     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, Bool);
473     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, Bool);
474     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, Bool);
475     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, Bool);
476     scilab_fill_comparisonequal(ScalarUInt8, ScalarBool, M_E, UInt8, Bool, Bool);
477
478     //Int16
479     //Matrix == Matrix
480     scilab_fill_comparisonequal(Int16, Double, M_M, Int16, Double, Bool);
481     scilab_fill_comparisonequal(Int16, Int8, M_M, Int16, Int8, Bool);
482     scilab_fill_comparisonequal(Int16, UInt8, M_M, Int16, UInt8, Bool);
483     scilab_fill_comparisonequal(Int16, Int16, M_M, Int16, Int16, Bool);
484     scilab_fill_comparisonequal(Int16, UInt16, M_M, Int16, UInt16, Bool);
485     scilab_fill_comparisonequal(Int16, Int32, M_M, Int16, Int32, Bool);
486     scilab_fill_comparisonequal(Int16, UInt32, M_M, Int16, UInt32, Bool);
487     scilab_fill_comparisonequal(Int16, Int64, M_M, Int16, Int64, Bool);
488     scilab_fill_comparisonequal(Int16, UInt64, M_M, Int16, UInt64, Bool);
489     scilab_fill_comparisonequal(Int16, Bool, M_B, Int16, Bool, Bool);
490     scilab_fill_comparisonequal(Int16, Empty, M_E, Int16, Double, Bool);
491
492     //Matrix == Scalar
493     scilab_fill_comparisonequal(Int16, ScalarDouble, M_S, Int16, Double, Bool);
494     scilab_fill_comparisonequal(Int16, ScalarInt8, M_S, Int16, Int8, Bool);
495     scilab_fill_comparisonequal(Int16, ScalarUInt8, M_S, Int16, UInt8, Bool);
496     scilab_fill_comparisonequal(Int16, ScalarInt16, M_S, Int16, Int16, Bool);
497     scilab_fill_comparisonequal(Int16, ScalarUInt16, M_S, Int16, UInt16, Bool);
498     scilab_fill_comparisonequal(Int16, ScalarInt32, M_S, Int16, Int32, Bool);
499     scilab_fill_comparisonequal(Int16, ScalarUInt32, M_S, Int16, UInt32, Bool);
500     scilab_fill_comparisonequal(Int16, ScalarInt64, M_S, Int16, Int64, Bool);
501     scilab_fill_comparisonequal(Int16, ScalarUInt64, M_S, Int16, UInt64, Bool);
502     scilab_fill_comparisonequal(Int16, ScalarBool, M_B, Int16, Bool, Bool);
503
504     //Scalar == Matrix
505     scilab_fill_comparisonequal(ScalarInt16, Double, S_M, Int16, Double, Bool);
506     scilab_fill_comparisonequal(ScalarInt16, Int8, S_M, Int16, Int8, Bool);
507     scilab_fill_comparisonequal(ScalarInt16, UInt8, S_M, Int16, UInt8, Bool);
508     scilab_fill_comparisonequal(ScalarInt16, Int16, S_M, Int16, Int16, Bool);
509     scilab_fill_comparisonequal(ScalarInt16, UInt16, S_M, Int16, UInt16, Bool);
510     scilab_fill_comparisonequal(ScalarInt16, Int32, S_M, Int16, Int32, Bool);
511     scilab_fill_comparisonequal(ScalarInt16, UInt32, S_M, Int16, UInt32, Bool);
512     scilab_fill_comparisonequal(ScalarInt16, Int64, S_M, Int16, Int64, Bool);
513     scilab_fill_comparisonequal(ScalarInt16, UInt64, S_M, Int16, UInt64, Bool);
514     scilab_fill_comparisonequal(ScalarInt16, Bool, S_B, Int16, Bool, Bool);
515     scilab_fill_comparisonequal(ScalarInt16, Empty, M_E, Int16, Double, Bool);
516
517     //Scalar == Scalar
518     scilab_fill_comparisonequal(ScalarInt16, ScalarDouble, S_S, Int16, Double, Bool);
519     scilab_fill_comparisonequal(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Bool);
520     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, Bool);
521     scilab_fill_comparisonequal(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Bool);
522     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, Bool);
523     scilab_fill_comparisonequal(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Bool);
524     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, Bool);
525     scilab_fill_comparisonequal(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Bool);
526     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, Bool);
527     scilab_fill_comparisonequal(ScalarInt16, ScalarBool, M_E, Int16, Bool, Bool);
528
529     //UInt16
530     //Matrix == Matrix
531     scilab_fill_comparisonequal(UInt16, Double, M_M, UInt16, Double, Bool);
532     scilab_fill_comparisonequal(UInt16, Int8, M_M, UInt16, Int8, Bool);
533     scilab_fill_comparisonequal(UInt16, UInt8, M_M, UInt16, UInt8, Bool);
534     scilab_fill_comparisonequal(UInt16, Int16, M_M, UInt16, Int16, Bool);
535     scilab_fill_comparisonequal(UInt16, UInt16, M_M, UInt16, UInt16, Bool);
536     scilab_fill_comparisonequal(UInt16, Int32, M_M, UInt16, Int32, Bool);
537     scilab_fill_comparisonequal(UInt16, UInt32, M_M, UInt16, UInt32, Bool);
538     scilab_fill_comparisonequal(UInt16, Int64, M_M, UInt16, Int64, Bool);
539     scilab_fill_comparisonequal(UInt16, UInt64, M_M, UInt16, UInt64, Bool);
540     scilab_fill_comparisonequal(UInt16, Bool, M_B, UInt16, Bool, Bool);
541     scilab_fill_comparisonequal(UInt16, Empty, M_E, UInt16, Double, Bool);
542
543     //Matrix == Scalar
544     scilab_fill_comparisonequal(UInt16, ScalarDouble, M_S, UInt16, Double, Bool);
545     scilab_fill_comparisonequal(UInt16, ScalarInt8, M_S, UInt16, Int8, Bool);
546     scilab_fill_comparisonequal(UInt16, ScalarUInt8, M_S, UInt16, UInt8, Bool);
547     scilab_fill_comparisonequal(UInt16, ScalarInt16, M_S, UInt16, Int16, Bool);
548     scilab_fill_comparisonequal(UInt16, ScalarUInt16, M_S, UInt16, UInt16, Bool);
549     scilab_fill_comparisonequal(UInt16, ScalarInt32, M_S, UInt16, Int32, Bool);
550     scilab_fill_comparisonequal(UInt16, ScalarUInt32, M_S, UInt16, UInt32, Bool);
551     scilab_fill_comparisonequal(UInt16, ScalarInt64, M_S, UInt16, Int64, Bool);
552     scilab_fill_comparisonequal(UInt16, ScalarUInt64, M_S, UInt16, UInt64, Bool);
553     scilab_fill_comparisonequal(UInt16, ScalarBool, M_B, UInt16, Bool, Bool);
554
555     //Scalar == Matrix
556     scilab_fill_comparisonequal(ScalarUInt16, Double, S_M, UInt16, Double, Bool);
557     scilab_fill_comparisonequal(ScalarUInt16, Int8, S_M, UInt16, Int8, Bool);
558     scilab_fill_comparisonequal(ScalarUInt16, UInt8, S_M, UInt16, UInt8, Bool);
559     scilab_fill_comparisonequal(ScalarUInt16, Int16, S_M, UInt16, Int16, Bool);
560     scilab_fill_comparisonequal(ScalarUInt16, UInt16, S_M, UInt16, UInt16, Bool);
561     scilab_fill_comparisonequal(ScalarUInt16, Int32, S_M, UInt16, Int32, Bool);
562     scilab_fill_comparisonequal(ScalarUInt16, UInt32, S_M, UInt16, UInt32, Bool);
563     scilab_fill_comparisonequal(ScalarUInt16, Int64, S_M, UInt16, Int64, Bool);
564     scilab_fill_comparisonequal(ScalarUInt16, UInt64, S_M, UInt16, UInt64, Bool);
565     scilab_fill_comparisonequal(ScalarUInt16, Bool, S_B, UInt16, Bool, Bool);
566     scilab_fill_comparisonequal(ScalarUInt16, Empty, M_E, UInt16, Double, Bool);
567
568     //Scalar == Scalar
569     scilab_fill_comparisonequal(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, Bool);
570     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, Bool);
571     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, Bool);
572     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, Bool);
573     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, Bool);
574     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, Bool);
575     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, Bool);
576     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, Bool);
577     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, Bool);
578     scilab_fill_comparisonequal(ScalarUInt16, ScalarBool, M_E, UInt16, Bool, Bool);
579
580     //Int32
581     //Matrix == Matrix
582     scilab_fill_comparisonequal(Int32, Double, M_M, Int32, Double, Bool);
583     scilab_fill_comparisonequal(Int32, Int8, M_M, Int32, Int8, Bool);
584     scilab_fill_comparisonequal(Int32, UInt8, M_M, Int32, UInt8, Bool);
585     scilab_fill_comparisonequal(Int32, Int16, M_M, Int32, Int16, Bool);
586     scilab_fill_comparisonequal(Int32, UInt16, M_M, Int32, UInt16, Bool);
587     scilab_fill_comparisonequal(Int32, Int32, M_M, Int32, Int32, Bool);
588     scilab_fill_comparisonequal(Int32, UInt32, M_M, Int32, UInt32, Bool);
589     scilab_fill_comparisonequal(Int32, Int64, M_M, Int32, Int64, Bool);
590     scilab_fill_comparisonequal(Int32, UInt64, M_M, Int32, UInt64, Bool);
591     scilab_fill_comparisonequal(Int32, Bool, M_B, Int32, Bool, Bool);
592     scilab_fill_comparisonequal(Int32, Empty, M_E, Int32, Double, Bool);
593
594     //Matrix == Scalar
595     scilab_fill_comparisonequal(Int32, ScalarDouble, M_S, Int32, Double, Bool);
596     scilab_fill_comparisonequal(Int32, ScalarInt8, M_S, Int32, Int8, Bool);
597     scilab_fill_comparisonequal(Int32, ScalarUInt8, M_S, Int32, UInt8, Bool);
598     scilab_fill_comparisonequal(Int32, ScalarInt16, M_S, Int32, Int16, Bool);
599     scilab_fill_comparisonequal(Int32, ScalarUInt16, M_S, Int32, UInt16, Bool);
600     scilab_fill_comparisonequal(Int32, ScalarInt32, M_S, Int32, Int32, Bool);
601     scilab_fill_comparisonequal(Int32, ScalarUInt32, M_S, Int32, UInt32, Bool);
602     scilab_fill_comparisonequal(Int32, ScalarInt64, M_S, Int32, Int64, Bool);
603     scilab_fill_comparisonequal(Int32, ScalarUInt64, M_S, Int32, UInt64, Bool);
604     scilab_fill_comparisonequal(Int32, ScalarBool, M_B, Int32, Bool, Bool);
605
606     //Scalar == Matrix
607     scilab_fill_comparisonequal(ScalarInt32, Double, S_M, Int32, Double, Bool);
608     scilab_fill_comparisonequal(ScalarInt32, Int8, S_M, Int32, Int8, Bool);
609     scilab_fill_comparisonequal(ScalarInt32, UInt8, S_M, Int32, UInt8, Bool);
610     scilab_fill_comparisonequal(ScalarInt32, Int16, S_M, Int32, Int16, Bool);
611     scilab_fill_comparisonequal(ScalarInt32, UInt16, S_M, Int32, UInt16, Bool);
612     scilab_fill_comparisonequal(ScalarInt32, Int32, S_M, Int32, Int32, Bool);
613     scilab_fill_comparisonequal(ScalarInt32, UInt32, S_M, Int32, UInt32, Bool);
614     scilab_fill_comparisonequal(ScalarInt32, Int64, S_M, Int32, Int64, Bool);
615     scilab_fill_comparisonequal(ScalarInt32, UInt64, S_M, Int32, UInt64, Bool);
616     scilab_fill_comparisonequal(ScalarInt32, Bool, S_B, Int32, Bool, Bool);
617     scilab_fill_comparisonequal(ScalarInt32, Empty, M_E, Int32, Double, Bool);
618
619     //Scalar == Scalar
620     scilab_fill_comparisonequal(ScalarInt32, ScalarDouble, S_S, Int32, Double, Bool);
621     scilab_fill_comparisonequal(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Bool);
622     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, Bool);
623     scilab_fill_comparisonequal(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Bool);
624     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, Bool);
625     scilab_fill_comparisonequal(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Bool);
626     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, Bool);
627     scilab_fill_comparisonequal(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Bool);
628     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, Bool);
629     scilab_fill_comparisonequal(ScalarInt32, ScalarBool, M_E, Int32, Bool, Bool);
630
631     //UInt32
632     //Matrix == Matrix
633     scilab_fill_comparisonequal(UInt32, Double, M_M, UInt32, Double, Bool);
634     scilab_fill_comparisonequal(UInt32, Int8, M_M, UInt32, Int8, Bool);
635     scilab_fill_comparisonequal(UInt32, UInt8, M_M, UInt32, UInt8, Bool);
636     scilab_fill_comparisonequal(UInt32, Int16, M_M, UInt32, Int16, Bool);
637     scilab_fill_comparisonequal(UInt32, UInt16, M_M, UInt32, UInt16, Bool);
638     scilab_fill_comparisonequal(UInt32, Int32, M_M, UInt32, Int32, Bool);
639     scilab_fill_comparisonequal(UInt32, UInt32, M_M, UInt32, UInt32, Bool);
640     scilab_fill_comparisonequal(UInt32, Int64, M_M, UInt32, Int64, Bool);
641     scilab_fill_comparisonequal(UInt32, UInt64, M_M, UInt32, UInt64, Bool);
642     scilab_fill_comparisonequal(UInt32, Bool, M_B, UInt32, Bool, Bool);
643     scilab_fill_comparisonequal(UInt32, Empty, M_E, UInt32, Double, Bool);
644
645     //Matrix == Scalar
646     scilab_fill_comparisonequal(UInt32, ScalarDouble, M_S, UInt32, Double, Bool);
647     scilab_fill_comparisonequal(UInt32, ScalarInt8, M_S, UInt32, Int8, Bool);
648     scilab_fill_comparisonequal(UInt32, ScalarUInt8, M_S, UInt32, UInt8, Bool);
649     scilab_fill_comparisonequal(UInt32, ScalarInt16, M_S, UInt32, Int16, Bool);
650     scilab_fill_comparisonequal(UInt32, ScalarUInt16, M_S, UInt32, UInt16, Bool);
651     scilab_fill_comparisonequal(UInt32, ScalarInt32, M_S, UInt32, Int32, Bool);
652     scilab_fill_comparisonequal(UInt32, ScalarUInt32, M_S, UInt32, UInt32, Bool);
653     scilab_fill_comparisonequal(UInt32, ScalarInt64, M_S, UInt32, Int64, Bool);
654     scilab_fill_comparisonequal(UInt32, ScalarUInt64, M_S, UInt32, UInt64, Bool);
655     scilab_fill_comparisonequal(UInt32, ScalarBool, M_B, UInt32, Bool, Bool);
656
657     //Scalar == Matrix
658     scilab_fill_comparisonequal(ScalarUInt32, Double, S_M, UInt32, Double, Bool);
659     scilab_fill_comparisonequal(ScalarUInt32, Int8, S_M, UInt32, Int8, Bool);
660     scilab_fill_comparisonequal(ScalarUInt32, UInt8, S_M, UInt32, UInt8, Bool);
661     scilab_fill_comparisonequal(ScalarUInt32, Int16, S_M, UInt32, Int16, Bool);
662     scilab_fill_comparisonequal(ScalarUInt32, UInt16, S_M, UInt32, UInt16, Bool);
663     scilab_fill_comparisonequal(ScalarUInt32, Int32, S_M, UInt32, Int32, Bool);
664     scilab_fill_comparisonequal(ScalarUInt32, UInt32, S_M, UInt32, UInt32, Bool);
665     scilab_fill_comparisonequal(ScalarUInt32, Int64, S_M, UInt32, Int64, Bool);
666     scilab_fill_comparisonequal(ScalarUInt32, UInt64, S_M, UInt32, UInt64, Bool);
667     scilab_fill_comparisonequal(ScalarUInt32, Bool, S_B, UInt32, Bool, Bool);
668     scilab_fill_comparisonequal(ScalarUInt32, Empty, M_E, UInt32, Double, Bool);
669
670     //Scalar == Scalar
671     scilab_fill_comparisonequal(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, Bool);
672     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, Bool);
673     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, Bool);
674     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, Bool);
675     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, Bool);
676     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, Bool);
677     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, Bool);
678     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, Bool);
679     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, Bool);
680     scilab_fill_comparisonequal(ScalarUInt32, ScalarBool, M_E, UInt32, Bool, Bool);
681
682     //Int64
683     //Matrix == Matrix
684     scilab_fill_comparisonequal(Int64, Double, M_M, Int64, Double, Bool);
685     scilab_fill_comparisonequal(Int64, Int8, M_M, Int64, Int8, Bool);
686     scilab_fill_comparisonequal(Int64, UInt8, M_M, Int64, UInt8, Bool);
687     scilab_fill_comparisonequal(Int64, Int16, M_M, Int64, Int16, Bool);
688     scilab_fill_comparisonequal(Int64, UInt16, M_M, Int64, UInt16, Bool);
689     scilab_fill_comparisonequal(Int64, Int32, M_M, Int64, Int32, Bool);
690     scilab_fill_comparisonequal(Int64, UInt32, M_M, Int64, UInt32, Bool);
691     scilab_fill_comparisonequal(Int64, Int64, M_M, Int64, Int64, Bool);
692     scilab_fill_comparisonequal(Int64, UInt64, M_M, Int64, UInt64, Bool);
693     scilab_fill_comparisonequal(Int64, Bool, M_B, Int64, Bool, Bool);
694     scilab_fill_comparisonequal(Int64, Empty, M_E, Int64, Double, Bool);
695
696     //Matrix == Scalar
697     scilab_fill_comparisonequal(Int64, ScalarDouble, M_S, Int64, Double, Bool);
698     scilab_fill_comparisonequal(Int64, ScalarInt8, M_S, Int64, Int8, Bool);
699     scilab_fill_comparisonequal(Int64, ScalarUInt8, M_S, Int64, UInt8, Bool);
700     scilab_fill_comparisonequal(Int64, ScalarInt16, M_S, Int64, Int16, Bool);
701     scilab_fill_comparisonequal(Int64, ScalarUInt16, M_S, Int64, UInt16, Bool);
702     scilab_fill_comparisonequal(Int64, ScalarInt32, M_S, Int64, Int32, Bool);
703     scilab_fill_comparisonequal(Int64, ScalarUInt32, M_S, Int64, UInt32, Bool);
704     scilab_fill_comparisonequal(Int64, ScalarInt64, M_S, Int64, Int64, Bool);
705     scilab_fill_comparisonequal(Int64, ScalarUInt64, M_S, Int64, UInt64, Bool);
706     scilab_fill_comparisonequal(Int64, ScalarBool, M_B, Int64, Bool, Bool);
707
708     //Scalar == Matrix
709     scilab_fill_comparisonequal(ScalarInt64, Double, S_M, Int64, Double, Bool);
710     scilab_fill_comparisonequal(ScalarInt64, Int8, S_M, Int64, Int8, Bool);
711     scilab_fill_comparisonequal(ScalarInt64, UInt8, S_M, Int64, UInt8, Bool);
712     scilab_fill_comparisonequal(ScalarInt64, Int16, S_M, Int64, Int16, Bool);
713     scilab_fill_comparisonequal(ScalarInt64, UInt16, S_M, Int64, UInt16, Bool);
714     scilab_fill_comparisonequal(ScalarInt64, Int32, S_M, Int64, Int32, Bool);
715     scilab_fill_comparisonequal(ScalarInt64, UInt32, S_M, Int64, UInt32, Bool);
716     scilab_fill_comparisonequal(ScalarInt64, Int64, S_M, Int64, Int64, Bool);
717     scilab_fill_comparisonequal(ScalarInt64, UInt64, S_M, Int64, UInt64, Bool);
718     scilab_fill_comparisonequal(ScalarInt64, Bool, S_B, Int64, Bool, Bool);
719     scilab_fill_comparisonequal(ScalarInt64, Empty, M_E, Int64, Double, Bool);
720
721     //Scalar == Scalar
722     scilab_fill_comparisonequal(ScalarInt64, ScalarDouble, S_S, Int64, Double, Bool);
723     scilab_fill_comparisonequal(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Bool);
724     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, Bool);
725     scilab_fill_comparisonequal(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Bool);
726     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, Bool);
727     scilab_fill_comparisonequal(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Bool);
728     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, Bool);
729     scilab_fill_comparisonequal(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Bool);
730     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, Bool);
731     scilab_fill_comparisonequal(ScalarInt64, ScalarBool, M_E, Int64, Bool, Bool);
732
733     //UInt64
734     //Matrix == Matrix
735     scilab_fill_comparisonequal(UInt64, Double, M_M, UInt64, Double, Bool);
736     scilab_fill_comparisonequal(UInt64, Int8, M_M, UInt64, Int8, Bool);
737     scilab_fill_comparisonequal(UInt64, UInt8, M_M, UInt64, UInt8, Bool);
738     scilab_fill_comparisonequal(UInt64, Int16, M_M, UInt64, Int16, Bool);
739     scilab_fill_comparisonequal(UInt64, UInt16, M_M, UInt64, UInt16, Bool);
740     scilab_fill_comparisonequal(UInt64, Int32, M_M, UInt64, Int32, Bool);
741     scilab_fill_comparisonequal(UInt64, UInt32, M_M, UInt64, UInt32, Bool);
742     scilab_fill_comparisonequal(UInt64, Int64, M_M, UInt64, Int64, Bool);
743     scilab_fill_comparisonequal(UInt64, UInt64, M_M, UInt64, UInt64, Bool);
744     scilab_fill_comparisonequal(UInt64, Bool, M_B, UInt64, Bool, Bool);
745     scilab_fill_comparisonequal(UInt64, Empty, M_E, UInt64, Double, Bool);
746
747     //Matrix == Scalar
748     scilab_fill_comparisonequal(UInt64, ScalarDouble, M_S, UInt64, Double, Bool);
749     scilab_fill_comparisonequal(UInt64, ScalarInt8, M_S, UInt64, Int8, Bool);
750     scilab_fill_comparisonequal(UInt64, ScalarUInt8, M_S, UInt64, UInt8, Bool);
751     scilab_fill_comparisonequal(UInt64, ScalarInt16, M_S, UInt64, Int16, Bool);
752     scilab_fill_comparisonequal(UInt64, ScalarUInt16, M_S, UInt64, UInt16, Bool);
753     scilab_fill_comparisonequal(UInt64, ScalarInt32, M_S, UInt64, Int32, Bool);
754     scilab_fill_comparisonequal(UInt64, ScalarUInt32, M_S, UInt64, UInt32, Bool);
755     scilab_fill_comparisonequal(UInt64, ScalarInt64, M_S, UInt64, Int64, Bool);
756     scilab_fill_comparisonequal(UInt64, ScalarUInt64, M_S, UInt64, UInt64, Bool);
757     scilab_fill_comparisonequal(UInt64, ScalarBool, M_B, UInt64, Bool, Bool);
758
759     //Scalar == Matrix
760     scilab_fill_comparisonequal(ScalarUInt64, Double, S_M, UInt64, Double, Bool);
761     scilab_fill_comparisonequal(ScalarUInt64, Int8, S_M, UInt64, Int8, Bool);
762     scilab_fill_comparisonequal(ScalarUInt64, UInt8, S_M, UInt64, UInt8, Bool);
763     scilab_fill_comparisonequal(ScalarUInt64, Int16, S_M, UInt64, Int16, Bool);
764     scilab_fill_comparisonequal(ScalarUInt64, UInt16, S_M, UInt64, UInt16, Bool);
765     scilab_fill_comparisonequal(ScalarUInt64, Int32, S_M, UInt64, Int32, Bool);
766     scilab_fill_comparisonequal(ScalarUInt64, UInt32, S_M, UInt64, UInt32, Bool);
767     scilab_fill_comparisonequal(ScalarUInt64, Int64, S_M, UInt64, Int64, Bool);
768     scilab_fill_comparisonequal(ScalarUInt64, UInt64, S_M, UInt64, UInt64, Bool);
769     scilab_fill_comparisonequal(ScalarUInt64, Bool, S_B, UInt64, Bool, Bool);
770     scilab_fill_comparisonequal(ScalarUInt64, Empty, M_E, UInt64, Double, Bool);
771
772     //Scalar == Scalar
773     scilab_fill_comparisonequal(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, Bool);
774     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, Bool);
775     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, Bool);
776     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, Bool);
777     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, Bool);
778     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, Bool);
779     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, Bool);
780     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, Bool);
781     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, Bool);
782     scilab_fill_comparisonequal(ScalarUInt64, ScalarBool, M_E, UInt64, Bool, Bool);
783
784     //Bool
785     //Matrix == Matrix
786     scilab_fill_comparisonequal(Bool, Double, M_E, Bool, Double, Bool);
787     scilab_fill_comparisonequal(Bool, Int8, B_M, Bool, Int8, Bool);
788     scilab_fill_comparisonequal(Bool, UInt8, B_M, Bool, UInt8, Bool);
789     scilab_fill_comparisonequal(Bool, Int16, B_M, Bool, Int16, Bool);
790     scilab_fill_comparisonequal(Bool, UInt16, B_M, Bool, UInt16, Bool);
791     scilab_fill_comparisonequal(Bool, Int32, B_M, Bool, Int32, Bool);
792     scilab_fill_comparisonequal(Bool, UInt32, B_M, Bool, UInt32, Bool);
793     scilab_fill_comparisonequal(Bool, Int64, B_M, Bool, Int64, Bool);
794     scilab_fill_comparisonequal(Bool, UInt64, B_M, Bool, UInt64, Bool);
795     scilab_fill_comparisonequal(Bool, Bool, M_M, Bool, Bool, Bool);
796     scilab_fill_comparisonequal(Bool, Empty, M_E, Bool, Double, Bool);
797
798     //Matrix == Scalar
799     scilab_fill_comparisonequal(Bool, ScalarDouble, M_E, Bool, Double, Bool);
800     scilab_fill_comparisonequal(Bool, ScalarInt8, B_S, Bool, Int8, Bool);
801     scilab_fill_comparisonequal(Bool, ScalarUInt8, B_S, Bool, UInt8, Bool);
802     scilab_fill_comparisonequal(Bool, ScalarInt16, B_S, Bool, Int16, Bool);
803     scilab_fill_comparisonequal(Bool, ScalarUInt16, B_S, Bool, UInt16, Bool);
804     scilab_fill_comparisonequal(Bool, ScalarInt32, B_S, Bool, Int32, Bool);
805     scilab_fill_comparisonequal(Bool, ScalarUInt32, B_S, Bool, UInt32, Bool);
806     scilab_fill_comparisonequal(Bool, ScalarInt64, B_S, Bool, Int64, Bool);
807     scilab_fill_comparisonequal(Bool, ScalarUInt64, B_S, Bool, UInt64, Bool);
808     scilab_fill_comparisonequal(Bool, ScalarBool, M_S, Bool, Bool, Bool);
809
810     //Scalar == Matrix
811     scilab_fill_comparisonequal(ScalarBool, Double, M_E, Bool, Double, Bool);
812     scilab_fill_comparisonequal(ScalarBool, Int8, B_M, Bool, Int8, Bool);
813     scilab_fill_comparisonequal(ScalarBool, UInt8, B_M, Bool, UInt8, Bool);
814     scilab_fill_comparisonequal(ScalarBool, Int16, B_M, Bool, Int16, Bool);
815     scilab_fill_comparisonequal(ScalarBool, UInt16, B_M, Bool, UInt16, Bool);
816     scilab_fill_comparisonequal(ScalarBool, Int32, B_M, Bool, Int32, Bool);
817     scilab_fill_comparisonequal(ScalarBool, UInt32, B_M, Bool, UInt32, Bool);
818     scilab_fill_comparisonequal(ScalarBool, Int64, B_M, Bool, Int64, Bool);
819     scilab_fill_comparisonequal(ScalarBool, UInt64, B_M, Bool, UInt64, Bool);
820     scilab_fill_comparisonequal(ScalarBool, Bool, S_M, Bool, Bool, Bool);
821     scilab_fill_comparisonequal(ScalarBool, Empty, M_E, Bool, Double, Bool);
822
823     //Scalar == Scalar
824     scilab_fill_comparisonequal(ScalarBool, ScalarDouble, M_E, Bool, Double, Bool);
825     scilab_fill_comparisonequal(ScalarBool, ScalarInt8, M_E, Bool, Int8, Bool);
826     scilab_fill_comparisonequal(ScalarBool, ScalarUInt8, M_E, Bool, UInt8, Bool);
827     scilab_fill_comparisonequal(ScalarBool, ScalarInt16, M_E, Bool, Int16, Bool);
828     scilab_fill_comparisonequal(ScalarBool, ScalarUInt16, M_E, Bool, UInt16, Bool);
829     scilab_fill_comparisonequal(ScalarBool, ScalarInt32, M_E, Bool, Int32, Bool);
830     scilab_fill_comparisonequal(ScalarBool, ScalarUInt32, M_E, Bool, UInt32, Bool);
831     scilab_fill_comparisonequal(ScalarBool, ScalarInt64, M_E, Bool, Int64, Bool);
832     scilab_fill_comparisonequal(ScalarBool, ScalarUInt64, M_E, Bool, UInt64, Bool);
833     scilab_fill_comparisonequal(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
834
835     //Bool == Identity
836     scilab_fill_comparisonequal(Bool, Identity, M_E, Bool, Double, Bool);
837     scilab_fill_comparisonequal(Bool, IdentityComplex, M_E, Bool, Double, Bool);
838     scilab_fill_comparisonequal(ScalarBool, Identity, M_E, Bool, Double, Bool);
839     scilab_fill_comparisonequal(ScalarBool, IdentityComplex, M_E, Bool, Double, Bool);
840
841     //Bool == Polynom
842     scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
843     scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
844     scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
845     scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
846     scilab_fill_comparisonequal(ScalarBool, Polynom, M_E, Bool, Polynom, Bool);
847     scilab_fill_comparisonequal(ScalarBool, PolynomComplex, M_E, Bool, Polynom, Bool);
848     scilab_fill_comparisonequal(ScalarBool, ScalarPolynom, M_E, Bool, Polynom, Bool);
849     scilab_fill_comparisonequal(ScalarBool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
850
851     //Bool == Sparse
852     scilab_fill_comparisonequal(Bool, Sparse, M_E, Bool, Sparse, Bool);
853     scilab_fill_comparisonequal(Bool, SparseComplex, M_E, Bool, Sparse, Bool);
854     scilab_fill_comparisonequal(ScalarBool, Sparse, M_E, Bool, Sparse, Bool);
855     scilab_fill_comparisonequal(ScalarBool, SparseComplex, M_E, Bool, Sparse, Bool);
856
857     //Identity
858     scilab_fill_comparisonequal(Identity, Double, I_M, Double, Double, Bool);
859     scilab_fill_comparisonequal(Identity, DoubleComplex, I_MC, Double, Double, Bool);
860     scilab_fill_comparisonequal(Identity, ScalarDouble, I_S, Double, Double, Bool);
861     scilab_fill_comparisonequal(Identity, ScalarDoubleComplex, I_SC, Double, Double, Bool);
862     scilab_fill_comparisonequal(Identity, Identity, I_I, Double, Double, Bool);
863     scilab_fill_comparisonequal(Identity, IdentityComplex, I_IC, Double, Double, Bool);
864     scilab_fill_comparisonequal(Identity, Empty, M_E, Double, Double, Bool);
865
866     scilab_fill_comparisonequal(Identity, Polynom, M_P, Double, Polynom, Bool);
867     scilab_fill_comparisonequal(Identity, PolynomComplex, M_P, Double, Polynom, Bool);
868     scilab_fill_comparisonequal(Identity, ScalarPolynom, M_P, Double, Polynom, Bool);
869     scilab_fill_comparisonequal(Identity, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
870     scilab_fill_comparisonequal(Identity, Sparse, M_E, Double, Sparse, SparseBool);
871     scilab_fill_comparisonequal(Identity, SparseComplex, M_E, Double, Sparse, SparseBool);
872
873     scilab_fill_comparisonequal(IdentityComplex, Double, IC_M, Double, Double, Bool);
874     scilab_fill_comparisonequal(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Bool);
875     scilab_fill_comparisonequal(IdentityComplex, ScalarDouble, IC_S, Double, Double, Bool);
876     scilab_fill_comparisonequal(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Bool);
877     scilab_fill_comparisonequal(IdentityComplex, Identity, IC_I, Double, Double, Bool);
878     scilab_fill_comparisonequal(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Bool);
879     scilab_fill_comparisonequal(IdentityComplex, Empty, M_E, Double, Double, Bool);
880
881     scilab_fill_comparisonequal(IdentityComplex, Polynom, M_P, Double, Polynom, Bool);
882     scilab_fill_comparisonequal(IdentityComplex, PolynomComplex, M_P, Double, Polynom, Bool);
883     scilab_fill_comparisonequal(IdentityComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
884     scilab_fill_comparisonequal(IdentityComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
885     scilab_fill_comparisonequal(IdentityComplex, Sparse, M_E, Double, Sparse, SparseBool);
886     scilab_fill_comparisonequal(IdentityComplex, SparseComplex, M_E, Double, Sparse, SparseBool);
887
888     scilab_fill_comparisonequal(Identity, Bool, M_E, Double, Bool, Bool);
889     scilab_fill_comparisonequal(IdentityComplex, Bool, M_E, Double, Bool, Bool);
890     scilab_fill_comparisonequal(Identity, ScalarBool, M_E, Double, Bool, Bool);
891     scilab_fill_comparisonequal(IdentityComplex, ScalarBool, M_E, Double, Bool, Bool);
892
893     //Polynom
894
895     //poly == poly
896     scilab_fill_comparisonequal(Polynom, Polynom, M_M, Polynom, Polynom, Bool);
897     scilab_fill_comparisonequal(Polynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
898     scilab_fill_comparisonequal(PolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
899     scilab_fill_comparisonequal(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
900
901     //poly == scalar poly
902     scilab_fill_comparisonequal(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
903     scilab_fill_comparisonequal(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
904     scilab_fill_comparisonequal(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
905     scilab_fill_comparisonequal(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
906
907     //poly == double
908     scilab_fill_comparisonequal(Polynom, Double, P_M, Polynom, Double, Bool);
909     scilab_fill_comparisonequal(Polynom, DoubleComplex, P_M, Polynom, Double, Bool);
910     scilab_fill_comparisonequal(PolynomComplex, Double, P_M, Polynom, Double, Bool);
911     scilab_fill_comparisonequal(PolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
912
913     //poly == scalar double
914     scilab_fill_comparisonequal(Polynom, ScalarDouble, P_M, Polynom, Double, Bool);
915     scilab_fill_comparisonequal(Polynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
916     scilab_fill_comparisonequal(PolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
917     scilab_fill_comparisonequal(PolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
918
919     //poly == Bool
920     scilab_fill_comparisonequal(Polynom, Bool, E_M, Polynom, Bool, Bool);
921     scilab_fill_comparisonequal(Polynom, ScalarBool, E_M, Polynom, Bool, Bool);
922     scilab_fill_comparisonequal(PolynomComplex, Bool, E_M, Polynom, Bool, Bool);
923     scilab_fill_comparisonequal(PolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
924
925     //poly == []
926     scilab_fill_comparisonequal(Polynom, Empty, M_E, Polynom, Double, Bool);
927     scilab_fill_comparisonequal(PolynomComplex, Empty, M_E, Polynom, Double, Bool);
928
929     //poly == eye
930     scilab_fill_comparisonequal(Polynom, Identity, P_M, Polynom, Double, Bool);
931     scilab_fill_comparisonequal(Polynom, IdentityComplex, P_M, Polynom, Double, Bool);
932     scilab_fill_comparisonequal(PolynomComplex, Identity, P_M, Polynom, Double, Bool);
933     scilab_fill_comparisonequal(PolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
934
935     //scalar poly == poly
936     scilab_fill_comparisonequal(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Bool);
937     scilab_fill_comparisonequal(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
938     scilab_fill_comparisonequal(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
939     scilab_fill_comparisonequal(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
940
941     //scalar poly == scalar poly
942     scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
943     scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
944     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
945     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
946
947     //scalar poly == double
948     scilab_fill_comparisonequal(ScalarPolynom, Double, P_M, Polynom, Double, Bool);
949     scilab_fill_comparisonequal(ScalarPolynom, DoubleComplex, P_M, Polynom, Double, Bool);
950     scilab_fill_comparisonequal(ScalarPolynomComplex, Double, P_M, Polynom, Double, Bool);
951     scilab_fill_comparisonequal(ScalarPolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
952
953     //scalar poly == scalar double
954     scilab_fill_comparisonequal(ScalarPolynom, ScalarDouble, P_M, Polynom, Double, Bool);
955     scilab_fill_comparisonequal(ScalarPolynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
956     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
957     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
958
959     //poly == Bool
960     scilab_fill_comparisonequal(ScalarPolynom, Bool, E_M, Polynom, Bool, Bool);
961     scilab_fill_comparisonequal(ScalarPolynom, ScalarBool, E_M, Polynom, Bool, Bool);
962     scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, E_M, Polynom, Bool, Bool);
963     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
964
965     //scalar poly == []
966     scilab_fill_comparisonequal(ScalarPolynom, Empty, M_E, Polynom, Double, Bool);
967     scilab_fill_comparisonequal(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Bool);
968
969     //scalar poly == eye
970     scilab_fill_comparisonequal(ScalarPolynom, Identity, P_M, Polynom, Double, Bool);
971     scilab_fill_comparisonequal(ScalarPolynom, IdentityComplex, P_M, Polynom, Double, Bool);
972     scilab_fill_comparisonequal(ScalarPolynomComplex, Identity, P_M, Polynom, Double, Bool);
973     scilab_fill_comparisonequal(ScalarPolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
974
975     //poly == Int8
976     scilab_fill_comparisonequal(Polynom, Int8, P_M, Polynom, Int8, Bool);
977     scilab_fill_comparisonequal(Polynom, UInt8, P_M, Polynom, UInt8, Bool);
978     scilab_fill_comparisonequal(PolynomComplex, Int8, P_M, Polynom, Int8, Bool);
979     scilab_fill_comparisonequal(PolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
980
981     scilab_fill_comparisonequal(Int8, Polynom, M_P, Int8, Polynom, Bool);
982     scilab_fill_comparisonequal(UInt8, Polynom, M_P, UInt8, Polynom, Bool);
983     scilab_fill_comparisonequal(Int8, PolynomComplex, M_P, Int8, Polynom, Bool);
984     scilab_fill_comparisonequal(UInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
985
986     scilab_fill_comparisonequal(ScalarPolynom, Int8, P_M, Polynom, Int8, Bool);
987     scilab_fill_comparisonequal(ScalarPolynom, UInt8, P_M, Polynom, UInt8, Bool);
988     scilab_fill_comparisonequal(ScalarPolynomComplex, Int8, P_M, Polynom, Int8, Bool);
989     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
990
991     scilab_fill_comparisonequal(Int8, ScalarPolynom, M_P, Int8, Polynom, Bool);
992     scilab_fill_comparisonequal(UInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
993     scilab_fill_comparisonequal(Int8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
994     scilab_fill_comparisonequal(UInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
995
996     //poly == Int16
997     scilab_fill_comparisonequal(Polynom, Int16, P_M, Polynom, Int16, Bool);
998     scilab_fill_comparisonequal(Polynom, UInt16, P_M, Polynom, UInt16, Bool);
999     scilab_fill_comparisonequal(PolynomComplex, Int16, P_M, Polynom, Int16, Bool);
1000     scilab_fill_comparisonequal(PolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
1001
1002     scilab_fill_comparisonequal(Int16, Polynom, M_P, Int16, Polynom, Bool);
1003     scilab_fill_comparisonequal(UInt16, Polynom, M_P, UInt16, Polynom, Bool);
1004     scilab_fill_comparisonequal(Int16, PolynomComplex, M_P, Int16, Polynom, Bool);
1005     scilab_fill_comparisonequal(UInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
1006
1007     scilab_fill_comparisonequal(ScalarPolynom, Int16, P_M, Polynom, Int16, Bool);
1008     scilab_fill_comparisonequal(ScalarPolynom, UInt16, P_M, Polynom, UInt16, Bool);
1009     scilab_fill_comparisonequal(ScalarPolynomComplex, Int16, P_M, Polynom, Int16, Bool);
1010     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
1011
1012     scilab_fill_comparisonequal(Int16, ScalarPolynom, M_P, Int16, Polynom, Bool);
1013     scilab_fill_comparisonequal(UInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
1014     scilab_fill_comparisonequal(Int16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
1015     scilab_fill_comparisonequal(UInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
1016
1017     //poly == Int32
1018     scilab_fill_comparisonequal(Polynom, Int32, P_M, Polynom, Int32, Bool);
1019     scilab_fill_comparisonequal(Polynom, UInt32, P_M, Polynom, UInt32, Bool);
1020     scilab_fill_comparisonequal(PolynomComplex, Int32, P_M, Polynom, Int32, Bool);
1021     scilab_fill_comparisonequal(PolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
1022
1023     scilab_fill_comparisonequal(Int32, Polynom, M_P, Int32, Polynom, Bool);
1024     scilab_fill_comparisonequal(UInt32, Polynom, M_P, UInt32, Polynom, Bool);
1025     scilab_fill_comparisonequal(Int32, PolynomComplex, M_P, Int32, Polynom, Bool);
1026     scilab_fill_comparisonequal(UInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
1027
1028     scilab_fill_comparisonequal(ScalarPolynom, Int32, P_M, Polynom, Int32, Bool);
1029     scilab_fill_comparisonequal(ScalarPolynom, UInt32, P_M, Polynom, UInt32, Bool);
1030     scilab_fill_comparisonequal(ScalarPolynomComplex, Int32, P_M, Polynom, Int32, Bool);
1031     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
1032
1033     scilab_fill_comparisonequal(Int32, ScalarPolynom, M_P, Int32, Polynom, Bool);
1034     scilab_fill_comparisonequal(UInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
1035     scilab_fill_comparisonequal(Int32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
1036     scilab_fill_comparisonequal(UInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
1037
1038     //poly == Int64
1039     scilab_fill_comparisonequal(Polynom, Int64, P_M, Polynom, Int64, Bool);
1040     scilab_fill_comparisonequal(Polynom, UInt64, P_M, Polynom, UInt64, Bool);
1041     scilab_fill_comparisonequal(PolynomComplex, Int64, P_M, Polynom, Int64, Bool);
1042     scilab_fill_comparisonequal(PolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
1043
1044     scilab_fill_comparisonequal(Int64, Polynom, M_P, Int64, Polynom, Bool);
1045     scilab_fill_comparisonequal(UInt64, Polynom, M_P, UInt64, Polynom, Bool);
1046     scilab_fill_comparisonequal(Int64, PolynomComplex, M_P, Int64, Polynom, Bool);
1047     scilab_fill_comparisonequal(UInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
1048
1049     scilab_fill_comparisonequal(ScalarPolynom, Int64, P_M, Polynom, Int64, Bool);
1050     scilab_fill_comparisonequal(ScalarPolynom, UInt64, P_M, Polynom, UInt64, Bool);
1051     scilab_fill_comparisonequal(ScalarPolynomComplex, Int64, P_M, Polynom, Int64, Bool);
1052     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
1053
1054     scilab_fill_comparisonequal(Int64, ScalarPolynom, M_P, Int64, Polynom, Bool);
1055     scilab_fill_comparisonequal(UInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
1056     scilab_fill_comparisonequal(Int64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
1057     scilab_fill_comparisonequal(UInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
1058
1059     //poly == Int8
1060     scilab_fill_comparisonequal(Polynom, ScalarInt8, P_M, Polynom, Int8, Bool);
1061     scilab_fill_comparisonequal(Polynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1062     scilab_fill_comparisonequal(PolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
1063     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1064
1065     scilab_fill_comparisonequal(ScalarInt8, Polynom, M_P, Int8, Polynom, Bool);
1066     scilab_fill_comparisonequal(ScalarUInt8, Polynom, M_P, UInt8, Polynom, Bool);
1067     scilab_fill_comparisonequal(ScalarInt8, PolynomComplex, M_P, Int8, Polynom, Bool);
1068     scilab_fill_comparisonequal(ScalarUInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
1069
1070     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt8, P_M, Polynom, Int8, Bool);
1071     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1072     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
1073     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1074
1075     scilab_fill_comparisonequal(ScalarInt8, ScalarPolynom, M_P, Int8, Polynom, Bool);
1076     scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
1077     scilab_fill_comparisonequal(ScalarInt8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
1078     scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
1079
1080     //poly == Int16
1081     scilab_fill_comparisonequal(Polynom, ScalarInt16, P_M, Polynom, Int16, Bool);
1082     scilab_fill_comparisonequal(Polynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1083     scilab_fill_comparisonequal(PolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
1084     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1085
1086     scilab_fill_comparisonequal(ScalarInt16, Polynom, M_P, Polynom, Int16, Bool);
1087     scilab_fill_comparisonequal(ScalarUInt16, Polynom, M_P, Polynom, UInt16, Bool);
1088     scilab_fill_comparisonequal(ScalarInt16, PolynomComplex, M_P, Int16, Polynom, Bool);
1089     scilab_fill_comparisonequal(ScalarUInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
1090
1091     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt16, P_M, Polynom, Int16, Bool);
1092     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1093     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
1094     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1095
1096     scilab_fill_comparisonequal(ScalarInt16, ScalarPolynom, M_P, Int16, Polynom, Bool);
1097     scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
1098     scilab_fill_comparisonequal(ScalarInt16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
1099     scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
1100
1101     //poly == Int32
1102     scilab_fill_comparisonequal(Polynom, ScalarInt32, P_M, Polynom, Int32, Bool);
1103     scilab_fill_comparisonequal(Polynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1104     scilab_fill_comparisonequal(PolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
1105     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1106
1107     scilab_fill_comparisonequal(ScalarInt32, Polynom, M_P, Int32, Polynom, Bool);
1108     scilab_fill_comparisonequal(ScalarUInt32, Polynom, M_P, UInt32, Polynom, Bool);
1109     scilab_fill_comparisonequal(ScalarInt32, PolynomComplex, M_P, Int32, Polynom, Bool);
1110     scilab_fill_comparisonequal(ScalarUInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
1111
1112     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt32, P_M, Polynom, Int32, Bool);
1113     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1114     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
1115     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1116
1117     scilab_fill_comparisonequal(ScalarInt32, ScalarPolynom, M_P, Int32, Polynom, Bool);
1118     scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
1119     scilab_fill_comparisonequal(ScalarInt32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
1120     scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
1121
1122     //poly == Int64
1123     scilab_fill_comparisonequal(Polynom, ScalarInt64, P_M, Polynom, Int64, Bool);
1124     scilab_fill_comparisonequal(Polynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1125     scilab_fill_comparisonequal(PolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
1126     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1127
1128     scilab_fill_comparisonequal(ScalarInt64, Polynom, M_P, Int64, Polynom, Bool);
1129     scilab_fill_comparisonequal(ScalarUInt64, Polynom, M_P, UInt64, Polynom, Bool);
1130     scilab_fill_comparisonequal(ScalarInt64, PolynomComplex, M_P, Int64, Polynom, Bool);
1131     scilab_fill_comparisonequal(ScalarUInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
1132
1133     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt64, P_M, Polynom, Int64, Bool);
1134     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1135     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
1136     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1137
1138     scilab_fill_comparisonequal(ScalarInt64, ScalarPolynom, M_P, Int64, Polynom, Bool);
1139     scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
1140     scilab_fill_comparisonequal(ScalarInt64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
1141     scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
1142
1143     //poly == bool
1144     scilab_fill_comparisonequal(Polynom, Bool, M_E, Polynom, Bool, Bool);
1145     scilab_fill_comparisonequal(PolynomComplex, Bool, M_E, Polynom, Bool, Bool);
1146     scilab_fill_comparisonequal(ScalarPolynom, Bool, M_E, Polynom, Bool, Bool);
1147     scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, M_E, Polynom, Bool, Bool);
1148
1149     scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
1150     scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
1151     scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
1152     scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
1153
1154     //Sparse
1155     scilab_fill_comparisonequal(Sparse, Sparse, M_M, Sparse, Sparse, SparseBool);
1156     scilab_fill_comparisonequal(Sparse, SparseComplex, M_M, Sparse, Sparse, SparseBool);
1157     scilab_fill_comparisonequal(Sparse, Double, SP_M, Sparse, Double, SparseBool);
1158     scilab_fill_comparisonequal(Sparse, DoubleComplex, SP_M, Sparse, Double, SparseBool);
1159     scilab_fill_comparisonequal(Sparse, ScalarDouble, SP_M, Sparse, Double, SparseBool);
1160     scilab_fill_comparisonequal(Sparse, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
1161
1162     scilab_fill_comparisonequal(Sparse, Empty, M_E, Sparse, Double, Bool);
1163     scilab_fill_comparisonequal(Sparse, Identity, M_E, Sparse, Double, SparseBool);
1164     scilab_fill_comparisonequal(Sparse, IdentityComplex, M_E, Sparse, Double, SparseBool);
1165
1166     scilab_fill_comparisonequal(SparseComplex, Sparse, M_M, Sparse, Sparse, SparseBool);
1167     scilab_fill_comparisonequal(SparseComplex, SparseComplex, M_M, Sparse, Sparse, SparseBool);
1168     scilab_fill_comparisonequal(SparseComplex, Double, SP_M, Sparse, Double, SparseBool);
1169     scilab_fill_comparisonequal(SparseComplex, DoubleComplex, SP_M, Sparse, Double, SparseBool);
1170     scilab_fill_comparisonequal(SparseComplex, ScalarDouble, SP_M, Sparse, Double, SparseBool);
1171     scilab_fill_comparisonequal(SparseComplex, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
1172
1173     scilab_fill_comparisonequal(SparseComplex, Empty, M_E, Sparse, Double, Bool);
1174     scilab_fill_comparisonequal(SparseComplex, Identity, M_E, Sparse, Double, SparseBool);
1175     scilab_fill_comparisonequal(SparseComplex, IdentityComplex, M_E, Sparse, Double, SparseBool);
1176
1177     scilab_fill_comparisonequal(Sparse, Bool, M_E, Sparse, Bool, Bool);
1178     scilab_fill_comparisonequal(Sparse, ScalarBool, M_E, Sparse, Bool, Bool);
1179     scilab_fill_comparisonequal(SparseComplex, Bool, M_E, Sparse, Bool, Bool);
1180     scilab_fill_comparisonequal(SparseComplex, ScalarBool, M_E, Sparse, Bool, Bool);
1181
1182     scilab_fill_comparisonequal(Sparse, Int8, SP_M, Sparse, Int8, SparseBool);
1183     scilab_fill_comparisonequal(Int8, Sparse, M_SP, Int8, Sparse, SparseBool);
1184     scilab_fill_comparisonequal(SparseComplex, Int8, SP_M, Sparse, Int8, SparseBool);
1185     scilab_fill_comparisonequal(Int8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
1186
1187     scilab_fill_comparisonequal(Sparse, UInt8, SP_M, Sparse, UInt8, SparseBool);
1188     scilab_fill_comparisonequal(UInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
1189     scilab_fill_comparisonequal(SparseComplex, UInt8, SP_M, Sparse, UInt8, SparseBool);
1190     scilab_fill_comparisonequal(UInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
1191
1192     scilab_fill_comparisonequal(Sparse, Int16, SP_M, Sparse, Int16, SparseBool);
1193     scilab_fill_comparisonequal(Int16, Sparse, M_SP, Int16, Sparse, SparseBool);
1194     scilab_fill_comparisonequal(SparseComplex, Int16, SP_M, Sparse, Int16, SparseBool);
1195     scilab_fill_comparisonequal(Int16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
1196
1197     scilab_fill_comparisonequal(Sparse, UInt16, SP_M, Sparse, UInt16, SparseBool);
1198     scilab_fill_comparisonequal(UInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
1199     scilab_fill_comparisonequal(SparseComplex, UInt16, SP_M, Sparse, UInt16, SparseBool);
1200     scilab_fill_comparisonequal(UInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
1201
1202     scilab_fill_comparisonequal(Sparse, Int32, SP_M, Sparse, Int32, SparseBool);
1203     scilab_fill_comparisonequal(Int32, Sparse, M_SP, Int32, Sparse, SparseBool);
1204     scilab_fill_comparisonequal(SparseComplex, Int32, SP_M, Sparse, Int32, SparseBool);
1205     scilab_fill_comparisonequal(Int32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
1206
1207     scilab_fill_comparisonequal(Sparse, UInt32, SP_M, Sparse, UInt32, SparseBool);
1208     scilab_fill_comparisonequal(UInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
1209     scilab_fill_comparisonequal(SparseComplex, UInt32, SP_M, Sparse, UInt32, SparseBool);
1210     scilab_fill_comparisonequal(UInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
1211
1212     scilab_fill_comparisonequal(Sparse, Int64, SP_M, Sparse, Int64, SparseBool);
1213     scilab_fill_comparisonequal(Int64, Sparse, M_SP, Int64, Sparse, SparseBool);
1214     scilab_fill_comparisonequal(SparseComplex, Int64, SP_M, Sparse, Int64, SparseBool);
1215     scilab_fill_comparisonequal(Int64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
1216
1217     scilab_fill_comparisonequal(Sparse, UInt64, SP_M, Sparse, UInt64, SparseBool);
1218     scilab_fill_comparisonequal(UInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
1219     scilab_fill_comparisonequal(SparseComplex, UInt64, SP_M, Sparse, UInt64, SparseBool);
1220     scilab_fill_comparisonequal(UInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
1221
1222     scilab_fill_comparisonequal(Sparse, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
1223     scilab_fill_comparisonequal(ScalarInt8, Sparse, M_SP, Int8, Sparse, SparseBool);
1224     scilab_fill_comparisonequal(SparseComplex, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
1225     scilab_fill_comparisonequal(ScalarInt8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
1226
1227     scilab_fill_comparisonequal(Sparse, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
1228     scilab_fill_comparisonequal(ScalarUInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
1229     scilab_fill_comparisonequal(SparseComplex, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
1230     scilab_fill_comparisonequal(ScalarUInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
1231
1232     scilab_fill_comparisonequal(Sparse, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
1233     scilab_fill_comparisonequal(ScalarInt16, Sparse, M_SP, Int16, Sparse, SparseBool);
1234     scilab_fill_comparisonequal(SparseComplex, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
1235     scilab_fill_comparisonequal(ScalarInt16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
1236
1237     scilab_fill_comparisonequal(Sparse, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
1238     scilab_fill_comparisonequal(ScalarUInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
1239     scilab_fill_comparisonequal(SparseComplex, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
1240     scilab_fill_comparisonequal(ScalarUInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
1241
1242     scilab_fill_comparisonequal(Sparse, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
1243     scilab_fill_comparisonequal(ScalarInt32, Sparse, M_SP, Int32, Sparse, SparseBool);
1244     scilab_fill_comparisonequal(SparseComplex, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
1245     scilab_fill_comparisonequal(ScalarInt32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
1246
1247     scilab_fill_comparisonequal(Sparse, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
1248     scilab_fill_comparisonequal(ScalarUInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
1249     scilab_fill_comparisonequal(SparseComplex, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
1250     scilab_fill_comparisonequal(ScalarUInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
1251
1252     scilab_fill_comparisonequal(Sparse, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
1253     scilab_fill_comparisonequal(ScalarInt64, Sparse, M_SP, Int64, Sparse, SparseBool);
1254     scilab_fill_comparisonequal(SparseComplex, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
1255     scilab_fill_comparisonequal(ScalarInt64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
1256
1257     scilab_fill_comparisonequal(Sparse, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
1258     scilab_fill_comparisonequal(ScalarUInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
1259     scilab_fill_comparisonequal(SparseComplex, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
1260     scilab_fill_comparisonequal(ScalarUInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
1261
1262
1263     //SparseBool
1264     scilab_fill_comparisonequal(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
1265     scilab_fill_comparisonequal(SparseBool, Bool, M_M, SparseBool, Bool, SparseBool);
1266     scilab_fill_comparisonequal(Bool, SparseBool, M_M, Bool, SparseBool, SparseBool);
1267     scilab_fill_comparisonequal(SparseBool, ScalarBool, M_M, SparseBool, Bool, SparseBool);
1268     scilab_fill_comparisonequal(ScalarBool, SparseBool, M_M, Bool, SparseBool, SparseBool);
1269
1270     scilab_fill_comparisonequal(SparseBool, Double, M_E, SparseBool, Double, Bool);
1271     scilab_fill_comparisonequal(Double, SparseBool, M_E, Double, SparseBool, Bool);
1272     scilab_fill_comparisonequal(SparseBool, DoubleComplex, M_E, SparseBool, Double, Bool);
1273     scilab_fill_comparisonequal(DoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
1274
1275     scilab_fill_comparisonequal(SparseBool, ScalarDouble, M_E, SparseBool, Double, Bool);
1276     scilab_fill_comparisonequal(ScalarDouble, SparseBool, M_E, Double, SparseBool, Bool);
1277     scilab_fill_comparisonequal(SparseBool, ScalarDoubleComplex, M_E, SparseBool, Double, Bool);
1278     scilab_fill_comparisonequal(ScalarDoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
1279
1280     scilab_fill_comparisonequal(SparseBool, Empty, M_E, SparseBool, Double, Bool);
1281     scilab_fill_comparisonequal(Empty, SparseBool, M_E, Double, SparseBool, Bool);
1282     scilab_fill_comparisonequal(SparseBool, Identity, M_E, SparseBool, Double, Bool);
1283     scilab_fill_comparisonequal(Identity, SparseBool, M_E, Double, SparseBool, Bool);
1284     scilab_fill_comparisonequal(SparseBool, IdentityComplex, M_E, SparseBool, Double, Bool);
1285     scilab_fill_comparisonequal(IdentityComplex, SparseBool, M_E, Double, SparseBool, Bool);
1286
1287     scilab_fill_comparisonequal(SparseBool, Int8, M_E, SparseBool, Int8, Bool);
1288     scilab_fill_comparisonequal(Int8, SparseBool, M_E, Int8, SparseBool, Bool);
1289     scilab_fill_comparisonequal(SparseBool, UInt8, M_E, SparseBool, UInt8, Bool);
1290     scilab_fill_comparisonequal(UInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
1291
1292     scilab_fill_comparisonequal(SparseBool, Int16, M_E, SparseBool, Int16, Bool);
1293     scilab_fill_comparisonequal(Int16, SparseBool, M_E, Int16, SparseBool, Bool);
1294     scilab_fill_comparisonequal(SparseBool, UInt16, M_E, SparseBool, UInt16, Bool);
1295     scilab_fill_comparisonequal(UInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
1296
1297     scilab_fill_comparisonequal(SparseBool, Int32, M_E, SparseBool, Int32, Bool);
1298     scilab_fill_comparisonequal(Int32, SparseBool, M_E, Int32, SparseBool, Bool);
1299     scilab_fill_comparisonequal(SparseBool, UInt32, M_E, SparseBool, UInt32, Bool);
1300     scilab_fill_comparisonequal(UInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
1301
1302     scilab_fill_comparisonequal(SparseBool, Int64, M_E, SparseBool, Int64, Bool);
1303     scilab_fill_comparisonequal(Int64, SparseBool, M_E, Int64, SparseBool, Bool);
1304     scilab_fill_comparisonequal(SparseBool, UInt64, M_E, SparseBool, UInt64, Bool);
1305     scilab_fill_comparisonequal(UInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
1306
1307     scilab_fill_comparisonequal(SparseBool, ScalarInt8, M_E, SparseBool, Int8, Bool);
1308     scilab_fill_comparisonequal(ScalarInt8, SparseBool, M_E, Int8, SparseBool, Bool);
1309     scilab_fill_comparisonequal(SparseBool, ScalarUInt8, M_E, SparseBool, UInt8, Bool);
1310     scilab_fill_comparisonequal(ScalarUInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
1311
1312     scilab_fill_comparisonequal(SparseBool, ScalarInt16, M_E, SparseBool, Int16, Bool);
1313     scilab_fill_comparisonequal(ScalarInt16, SparseBool, M_E, Int16, SparseBool, Bool);
1314     scilab_fill_comparisonequal(SparseBool, ScalarUInt16, M_E, SparseBool, UInt16, Bool);
1315     scilab_fill_comparisonequal(ScalarUInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
1316
1317     scilab_fill_comparisonequal(SparseBool, ScalarInt32, M_E, SparseBool, Int32, Bool);
1318     scilab_fill_comparisonequal(ScalarInt32, SparseBool, M_E, Int32, SparseBool, Bool);
1319     scilab_fill_comparisonequal(SparseBool, ScalarUInt32, M_E, SparseBool, UInt32, Bool);
1320     scilab_fill_comparisonequal(ScalarUInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
1321
1322     scilab_fill_comparisonequal(SparseBool, ScalarInt64, M_E, SparseBool, Int64, Bool);
1323     scilab_fill_comparisonequal(ScalarInt64, SparseBool, M_E, Int64, SparseBool, Bool);
1324     scilab_fill_comparisonequal(SparseBool, ScalarUInt64, M_E, SparseBool, UInt64, Bool);
1325     scilab_fill_comparisonequal(ScalarUInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
1326
1327     scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
1328     scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
1329     scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
1330     scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
1331
1332     scilab_fill_comparisonequal(SparseBool, SparseComplex, M_E, SparseBool, Sparse, Bool);
1333     scilab_fill_comparisonequal(SparseComplex, SparseBool, M_E, Sparse, SparseBool, Bool);
1334
1335     scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
1336     scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
1337
1338     scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
1339     scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
1340
1341     //struct
1342     scilab_fill_comparisonequal(Struct, Struct, M_M, Struct, Struct, Bool);
1343
1344     /*    scilab_fill_comparisonequal(Struct, Double, M_E, Struct, Double, Bool);
1345         scilab_fill_comparisonequal(Double, Struct, M_E, Double, Struct, Bool);
1346         scilab_fill_comparisonequal(Struct, DoubleComplex, M_E, Struct, Double, Bool);
1347         scilab_fill_comparisonequal(DoubleComplex, Struct, M_E, Double, Struct, Bool);
1348
1349         scilab_fill_comparisonequal(Struct, ScalarDouble, M_E, Struct, Double, Bool);
1350         scilab_fill_comparisonequal(ScalarDouble, Struct, M_E, Double, Struct, Bool);
1351         scilab_fill_comparisonequal(Struct, ScalarDoubleComplex, M_E, Struct, Double, Bool);
1352         scilab_fill_comparisonequal(ScalarDoubleComplex, Struct, M_E, Double, Struct, Bool);
1353
1354         scilab_fill_comparisonequal(Struct, Empty, M_E, Struct, Double, Bool);
1355         scilab_fill_comparisonequal(Empty, Struct, M_E, Double, Struct, Bool);
1356         scilab_fill_comparisonequal(Struct, Identity, M_E, Struct, Double, Bool);
1357         scilab_fill_comparisonequal(Identity, Struct, M_E, Double, Struct, Bool);
1358         scilab_fill_comparisonequal(Struct, IdentityComplex, M_E, Struct, Double, Bool);
1359         scilab_fill_comparisonequal(IdentityComplex, Struct, M_E, Double, Struct, Bool);
1360
1361         scilab_fill_comparisonequal(Struct, Int8, M_E, Struct, Int8, Bool);
1362         scilab_fill_comparisonequal(Int8, Struct, M_E, Int8, Struct, Bool);
1363         scilab_fill_comparisonequal(Struct, UInt8, M_E, Struct, UInt8, Bool);
1364         scilab_fill_comparisonequal(UInt8, Struct, M_E, UInt8, Struct, Bool);
1365
1366         scilab_fill_comparisonequal(Struct, Int16, M_E, Struct, Int16, Bool);
1367         scilab_fill_comparisonequal(Int16, Struct, M_E, Int16, Struct, Bool);
1368         scilab_fill_comparisonequal(Struct, UInt16, M_E, Struct, UInt16, Bool);
1369         scilab_fill_comparisonequal(UInt16, Struct, M_E, UInt16, Struct, Bool);
1370
1371         scilab_fill_comparisonequal(Struct, Int32, M_E, Struct, Int32, Bool);
1372         scilab_fill_comparisonequal(Int32, Struct, M_E, Int32, Struct, Bool);
1373         scilab_fill_comparisonequal(Struct, UInt32, M_E, Struct, UInt32, Bool);
1374         scilab_fill_comparisonequal(UInt32, Struct, M_E, UInt32, Struct, Bool);
1375
1376         scilab_fill_comparisonequal(Struct, Int64, M_E, Struct, Int64, Bool);
1377         scilab_fill_comparisonequal(Int64, Struct, M_E, Int64, Struct, Bool);
1378         scilab_fill_comparisonequal(Struct, UInt64, M_E, Struct, UInt64, Bool);
1379         scilab_fill_comparisonequal(UInt64, Struct, M_E, UInt64, Struct, Bool);
1380
1381         scilab_fill_comparisonequal(Struct, ScalarInt8, M_E, Struct, Int8, Bool);
1382         scilab_fill_comparisonequal(ScalarInt8, Struct, M_E, Int8, Struct, Bool);
1383         scilab_fill_comparisonequal(Struct, ScalarUInt8, M_E, Struct, UInt8, Bool);
1384         scilab_fill_comparisonequal(ScalarUInt8, Struct, M_E, UInt8, Struct, Bool);
1385
1386         scilab_fill_comparisonequal(Struct, ScalarInt16, M_E, Struct, Int16, Bool);
1387         scilab_fill_comparisonequal(ScalarInt16, Struct, M_E, Int16, Struct, Bool);
1388         scilab_fill_comparisonequal(Struct, ScalarUInt16, M_E, Struct, UInt16, Bool);
1389         scilab_fill_comparisonequal(ScalarUInt16, Struct, M_E, UInt16, Struct, Bool);
1390
1391         scilab_fill_comparisonequal(Struct, ScalarInt32, M_E, Struct, Int32, Bool);
1392         scilab_fill_comparisonequal(ScalarInt32, Struct, M_E, Int32, Struct, Bool);
1393         scilab_fill_comparisonequal(Struct, ScalarUInt32, M_E, Struct, UInt32, Bool);
1394         scilab_fill_comparisonequal(ScalarUInt32, Struct, M_E, UInt32, Struct, Bool);
1395
1396         scilab_fill_comparisonequal(Struct, ScalarInt64, M_E, Struct, Int64, Bool);
1397         scilab_fill_comparisonequal(ScalarInt64, Struct, M_E, Int64, Struct, Bool);
1398         scilab_fill_comparisonequal(Struct, ScalarUInt64, M_E, Struct, UInt64, Bool);
1399         scilab_fill_comparisonequal(ScalarUInt64, Struct, M_E, UInt64, Struct, Bool);
1400
1401         scilab_fill_comparisonequal(Struct, String, M_E, Struct, String, Bool);
1402         scilab_fill_comparisonequal(String, Struct, M_E, String, Struct, Bool);
1403         scilab_fill_comparisonequal(Struct, ScalarString, M_E, Struct, String, Bool);
1404         scilab_fill_comparisonequal(ScalarString, Struct, M_E, String, Struct, Bool);
1405
1406         scilab_fill_comparisonequal(Struct, SparseComplex, M_E, Struct, Sparse, Bool);
1407         scilab_fill_comparisonequal(SparseComplex, Struct, M_E, Sparse, Struct, Bool);
1408
1409         scilab_fill_comparisonequal(Struct, Sparse, M_E, Struct, Sparse, Bool);
1410         scilab_fill_comparisonequal(Sparse, Struct, M_E, Sparse, Struct, Bool);
1411
1412         scilab_fill_comparisonequal(Struct, SparseBool, M_E, Struct, SparseBool, Bool);
1413         scilab_fill_comparisonequal(SparseBool, Struct, M_E, SparseBool, Struct, Bool);*/
1414
1415     //List, TList, MList
1416     scilab_fill_comparisonequal(List, List, LT_LT, List, List, Bool);
1417     scilab_fill_comparisonequal(MList, MList, LT_LT, MList, MList, Bool);
1418     scilab_fill_comparisonequal(TList, TList, LT_LT, TList, TList, Bool);
1419
1420     scilab_fill_comparisonequal(List, TList, LT_LT, List, TList, Bool);
1421     scilab_fill_comparisonequal(TList, List, LT_LT, TList, List, Bool);
1422     scilab_fill_comparisonequal(List, MList, LT_LT, List, MList, Bool);
1423     scilab_fill_comparisonequal(MList, List, LT_LT, MList, List, Bool);
1424
1425     scilab_fill_comparisonequal(TList, MList, LT_LT, TList, MList, Bool);
1426     scilab_fill_comparisonequal(MList, TList, LT_LT, MList, TList, Bool);
1427
1428     //Cell
1429     scilab_fill_comparisonequal(Cell, Cell, M_M, Cell, Cell, Bool);
1430
1431     //Handle
1432     scilab_fill_comparisonequal(Handle, Handle, M_M, GraphicHandle, GraphicHandle, Bool);
1433
1434     //Macro
1435     scilab_fill_comparisonequal(Macro, Macro, MCR_MCR, Macro, Macro, Bool);
1436     scilab_fill_comparisonequal(MacroFile, MacroFile, MCR_MCR, MacroFile, MacroFile, Bool);
1437     scilab_fill_comparisonequal(Macro, MacroFile, MCR_MCR, Macro, MacroFile, Bool);
1438     scilab_fill_comparisonequal(MacroFile, Macro, MCR_MCR, MacroFile, Macro, Bool);
1439
1440
1441 #undef scilab_fill_comparisonequal
1442
1443 }
1444
1445 InternalType *GenericComparisonEqual(InternalType *_pLeftOperand, InternalType *_pRightOperand)
1446 {
1447     InternalType *pResult = NULL;
1448
1449     compequal_function compequal = pComparisonEqualfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
1450     if (compequal)
1451     {
1452         pResult = compequal(_pLeftOperand, _pRightOperand);
1453         if (pResult)
1454         {
1455             return pResult;
1456         }
1457     }
1458
1459     /*
1460     ** Default case : Return NULL will Call Overloading.
1461     */
1462     return NULL;
1463 }
1464
1465
1466 //Matrix == x
1467 template<class T, class U, class O>
1468 InternalType* compequal_M_M(T *_pL, U *_pR)
1469 {
1470     //check dims
1471     int iDimsL = _pL->getDims();
1472     int iDimsR = _pR->getDims();
1473
1474     if (iDimsL != iDimsR)
1475     {
1476         return new Bool(false);
1477     }
1478
1479     int* piDimsL = _pL->getDimsArray();
1480     int* piDimsR = _pR->getDimsArray();
1481
1482     for (int i = 0; i < iDimsL; ++i)
1483     {
1484         if (piDimsL[i] != piDimsR[i])
1485         {
1486             return new Bool(false);
1487         }
1488     }
1489
1490     O* pOut = new O(iDimsL, piDimsL);
1491     int iSize = pOut->getSize();
1492
1493     compequal(_pL->get(), iSize, _pR->get(), pOut->get());
1494     return pOut;
1495 }
1496
1497 template<class T, class U, class O>
1498 InternalType* compequal_M_MC(T *_pL, U *_pR)
1499 {
1500     //check dims
1501     int iDimsL = _pL->getDims();
1502     int iDimsR = _pR->getDims();
1503
1504     if (iDimsL != iDimsR)
1505     {
1506         return new Bool(false);
1507     }
1508
1509     int* piDimsL = _pL->getDimsArray();
1510     int* piDimsR = _pR->getDimsArray();
1511
1512     for (int i = 0; i < iDimsL; ++i)
1513     {
1514         if (piDimsL[i] != piDimsR[i])
1515         {
1516             return new Bool(false);
1517         }
1518     }
1519
1520     O* pOut = new O(iDimsL, piDimsL);
1521     int iSize = pOut->getSize();
1522
1523     compequal(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get());
1524     return pOut;
1525 }
1526
1527 template<class T, class U, class O>
1528 InternalType* compequal_M_S(T *_pL, U *_pR)
1529 {
1530     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1531     compequal(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
1532     return pOut;
1533 }
1534
1535 template<class T, class U, class O>
1536 InternalType* compequal_M_SC(T *_pL, U *_pR)
1537 {
1538     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1539     compequal(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
1540     return pOut;
1541 }
1542
1543 template<class T, class U, class O>
1544 InternalType* compequal_M_I(T *_pL, U *_pR)
1545 {
1546     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1547     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
1548     compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
1549     delete pIdentity;
1550     return pOut;
1551 }
1552
1553 template<class T, class U, class O>
1554 InternalType* compequal_M_IC(T *_pL, U *_pR)
1555 {
1556     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1557     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
1558     compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
1559     delete pIdentity;
1560     return pOut;
1561 }
1562
1563 template<class T, class U, class O>
1564 InternalType* compequal_M_E(T *_pL, U *_pR)
1565 {
1566     return new Bool(false);
1567 }
1568
1569 template<class T, class U, class O>
1570 InternalType* compequal_E_M(T *_pL, U *_pR)
1571 {
1572     return new Bool(false);
1573 }
1574
1575 template<class T, class U, class O>
1576 InternalType* compequal_E_E(T *_pL, U *_pR)
1577 {
1578     return new Bool(true);
1579 }
1580
1581 //B == x
1582 template<class T, class U, class O>
1583 InternalType* compequal_B_M(T *_pL, U *_pR)
1584 {
1585     //check dims
1586     int iDimsL = _pL->getDims();
1587     int iDimsR = _pR->getDims();
1588     int* piDimsR = _pR->getDimsArray();
1589
1590     if (_pL->isScalar() == false)
1591     {
1592         if (iDimsL != iDimsR)
1593         {
1594             return new Bool(false);
1595         }
1596
1597         int* piDimsL = _pL->getDimsArray();
1598
1599         for (int i = 0; i < iDimsL; ++i)
1600         {
1601             if (piDimsL[i] != piDimsR[i])
1602             {
1603                 return new Bool(false);
1604             }
1605         }
1606     }
1607
1608     O* pOut = new O(iDimsR, piDimsR);
1609
1610     pOut->setFalse();
1611
1612     return pOut;
1613 }
1614
1615 template<class T, class U, class O>
1616 InternalType* compequal_M_B(T *_pL, U *_pR)
1617 {
1618     //check dims
1619     int iDimsL = _pL->getDims();
1620     int iDimsR = _pR->getDims();
1621     int* piDimsL = _pL->getDimsArray();
1622
1623     if (_pR->isScalar() == false)
1624     {
1625         if (iDimsL != iDimsR)
1626         {
1627             return new Bool(false);
1628         }
1629
1630         int* piDimsR = _pR->getDimsArray();
1631
1632         for (int i = 0; i < iDimsL; ++i)
1633         {
1634             if (piDimsL[i] != piDimsR[i])
1635             {
1636                 return new Bool(false);
1637             }
1638         }
1639     }
1640
1641     O* pOut = new O(iDimsL, piDimsL);
1642
1643     pOut->setFalse();
1644
1645     return pOut;
1646 }
1647
1648 //B == x
1649 template<class T, class U, class O>
1650 InternalType* compequal_B_S(T *_pL, U *_pR)
1651 {
1652
1653     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1654
1655     pOut->setFalse();
1656
1657     return pOut;
1658 }
1659
1660 template<class T, class U, class O>
1661 InternalType* compequal_S_B(T *_pL, U *_pR)
1662 {
1663
1664     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1665
1666     pOut->setFalse();
1667
1668     return pOut;
1669 }
1670
1671
1672
1673 //Matrix complex == x
1674 template<class T, class U, class O>
1675 InternalType* compequal_MC_M(T *_pL, U *_pR)
1676 {
1677     //check dims
1678     int iDimsL = _pL->getDims();
1679     int iDimsR = _pR->getDims();
1680
1681     if (iDimsL != iDimsR)
1682     {
1683         return new Bool(false);
1684     }
1685
1686     int* piDimsL = _pL->getDimsArray();
1687     int* piDimsR = _pR->getDimsArray();
1688
1689     for (int i = 0; i < iDimsL; ++i)
1690     {
1691         if (piDimsL[i] != piDimsR[i])
1692         {
1693             return new Bool(false);
1694         }
1695     }
1696
1697     O* pOut = new O(iDimsL, piDimsL);
1698     int iSize = pOut->getSize();
1699
1700     compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get());
1701     return pOut;
1702 }
1703
1704 template<class T, class U, class O>
1705 InternalType* compequal_MC_MC(T *_pL, U *_pR)
1706 {
1707     //check dims
1708     int iDimsL = _pL->getDims();
1709     int iDimsR = _pR->getDims();
1710
1711     if (iDimsL != iDimsR)
1712     {
1713         return new Bool(false);
1714     }
1715
1716     int* piDimsL = _pL->getDimsArray();
1717     int* piDimsR = _pR->getDimsArray();
1718
1719     for (int i = 0; i < iDimsL; ++i)
1720     {
1721         if (piDimsL[i] != piDimsR[i])
1722         {
1723             return new Bool(false);
1724         }
1725     }
1726
1727     O* pOut = new O(iDimsL, piDimsL);
1728     int iSize = pOut->getSize();
1729
1730     compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get());
1731     return pOut;
1732 }
1733
1734 template<class T, class U, class O>
1735 InternalType* compequal_MC_S(T *_pL, U *_pR)
1736 {
1737     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1738     compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get());
1739     return pOut;
1740 }
1741
1742 template<class T, class U, class O>
1743 InternalType* compequal_MC_SC(T *_pL, U *_pR)
1744 {
1745     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1746     compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
1747     return pOut;
1748 }
1749
1750 template<class T, class U, class O>
1751 InternalType* compequal_MC_I(T *_pL, U *_pR)
1752 {
1753     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1754     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
1755     compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
1756     delete pIdentity;
1757     return pOut;
1758 }
1759
1760 template<class T, class U, class O>
1761 InternalType* compequal_MC_IC(T *_pL, U *_pR)
1762 {
1763     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
1764     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
1765     compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
1766     delete pIdentity;
1767     return pOut;
1768 }
1769
1770 //Scalar == x
1771 template<class T, class U, class O>
1772 InternalType* compequal_S_M(T *_pL, U *_pR)
1773 {
1774     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1775     compequal(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
1776     return pOut;
1777 }
1778
1779 template<class T, class U, class O>
1780 InternalType* compequal_S_MC(T *_pL, U *_pR)
1781 {
1782     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1783     compequal(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
1784     return pOut;
1785 }
1786
1787 template<class T, class U, class O>
1788 InternalType* compequal_S_S(T *_pL, U *_pR)
1789 {
1790     O* pOut = new O(1, 1);
1791     compequal(_pL->get(0), _pR->get(0), pOut->get());
1792     return pOut;
1793 }
1794
1795 template<class T, class U, class O>
1796 InternalType* compequal_S_SC(T *_pL, U *_pR)
1797 {
1798     O* pOut = new O(1, 1);
1799     compequal(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get());
1800     return pOut;
1801 }
1802
1803 template<class T, class U, class O>
1804 InternalType* compequal_S_I(T *_pL, U *_pR)
1805 {
1806     O* pOut = new O(1, 1);
1807     compequal(_pL->get(0), _pR->get(0), pOut->get());
1808     return pOut;
1809 }
1810
1811 template<class T, class U, class O>
1812 InternalType* compequal_S_IC(T *_pL, U *_pR)
1813 {
1814
1815     O* pOut = new  Bool(false);
1816     compequal(_pL->get(0), 1, _pR->get(), _pR->getImg(), pOut->get());
1817     return pOut;
1818 }
1819 //Scalar complex == x
1820 template<class T, class U, class O>
1821 InternalType* compequal_SC_M(T *_pL, U *_pR)
1822 {
1823     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1824     compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), pOut->get());
1825     return pOut;
1826 }
1827
1828 template<class T, class U, class O>
1829 InternalType* compequal_SC_MC(T *_pL, U *_pR)
1830 {
1831     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
1832     compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
1833     return pOut;
1834 }
1835
1836 template<class T, class U, class O>
1837 InternalType* compequal_SC_S(T *_pL, U *_pR)
1838 {
1839     O* pOut = new O(false);
1840     if (_pL->getImg(0) == 0)
1841     {
1842         compequal(_pL->get(0), _pR->get(0), pOut->get());
1843     }
1844     return pOut;
1845 }
1846
1847 template<class T, class U, class O>
1848 InternalType* compequal_SC_SC(T *_pL, U *_pR)
1849 {
1850     O* pOut = new O(true);
1851     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
1852     return pOut;
1853 }
1854
1855 template<class T, class U, class O>
1856 InternalType* compequal_SC_I(T *_pL, U *_pR)
1857 {
1858     O* pOut = new Bool(false);
1859     if (_pL->getImg(0) == 0)
1860     {
1861         compequal(_pL->get(0), _pR->get(0), pOut->get());
1862     }
1863     return pOut;
1864 }
1865
1866 template<class T, class U, class O>
1867 InternalType* compequal_SC_IC(T *_pL, U *_pR)
1868 {
1869     O* pOut = new Bool(false);
1870     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
1871     return pOut;
1872 }
1873
1874 //Identity == x
1875 template<class T, class U, class O>
1876 InternalType* compequal_I_M(T *_pL, U *_pR)
1877 {
1878     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
1879     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
1880     compequal(pIdentity->get(), pOut->getSize(), _pR->get(), pOut->get());
1881     delete pIdentity;
1882     return pOut;
1883 }
1884
1885 template<class T, class U, class O>
1886 InternalType* compequal_I_MC(T *_pL, U *_pR)
1887 {
1888     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
1889     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
1890     compequal(pIdentity->get(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
1891     delete pIdentity;
1892     return pOut;
1893 }
1894
1895 template<class T, class U, class O>
1896 InternalType* compequal_I_S(T *_pL, U *_pR)
1897 {
1898     O* pOut = new Bool(1, 1);
1899     compequal(_pL->get(0), _pR->get(0), pOut->get());
1900     return pOut;
1901 }
1902
1903 template<class T, class U, class O>
1904 InternalType* compequal_I_SC(T *_pL, U *_pR)
1905 {
1906     return compequal_SC_I<U, T, O>(_pR, _pL);
1907 }
1908
1909 template<class T, class U, class O>
1910 InternalType* compequal_I_I(T *_pL, U *_pR)
1911 {
1912     O* pOut = new Bool(1, 1);
1913     compequal(_pL->get(0), _pR->get(0), pOut->get());
1914     return pOut;
1915 }
1916
1917 template<class T, class U, class O>
1918 InternalType* compequal_I_IC(T *_pL, U *_pR)
1919 {
1920     O* pOut = new Bool(false);
1921     if (_pR->getImg(0) == 0)
1922     {
1923         compequal(_pL->get(0), _pR->get(0), pOut->get());
1924     }
1925     return pOut;
1926 }
1927
1928 //Identity complex == x
1929 template<class T, class U, class O>
1930 InternalType* compequal_IC_M(T *_pL, U *_pR)
1931 {
1932     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
1933     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
1934     compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), pOut->get());
1935     delete pIdentity;
1936     return pOut;
1937 }
1938
1939 template<class T, class U, class O>
1940 InternalType* compequal_IC_MC(T *_pL, U *_pR)
1941 {
1942     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
1943     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
1944     compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
1945     delete pIdentity;
1946     return pOut;
1947 }
1948
1949 template<class T, class U, class O>
1950 InternalType* compequal_IC_S(T *_pL, U *_pR)
1951 {
1952     O* pOut = new Bool(false);
1953     if (_pL->getImg(0) == 0)
1954     {
1955         compequal(_pL->get(0), _pR->get(0), pOut->get());
1956     }
1957     return pOut;
1958 }
1959
1960 template<class T, class U, class O>
1961 InternalType* compequal_IC_SC(T *_pL, U *_pR)
1962 {
1963     O* pOut = new Bool(1, 1);
1964     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
1965     return pOut;
1966 }
1967
1968 template<class T, class U, class O>
1969 InternalType* compequal_IC_I(T *_pL, U *_pR)
1970 {
1971     O* pOut = new Bool(false);
1972     if (_pL->getImg(0) == 0)
1973     {
1974         compequal(_pL->get(0), _pR->get(0), pOut->get());
1975     }
1976     return pOut;
1977 }
1978
1979 template<class T, class U, class O>
1980 InternalType* compequal_IC_IC(T *_pL, U *_pR)
1981 {
1982     O* pOut = new Bool(1, 1);
1983     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
1984     return pOut;
1985 }
1986
1987 template<>
1988 InternalType* compequal_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
1989 {
1990     //pending changes
1991     if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
1992     {
1993         return new Bool(false);
1994     }
1995
1996     return _pR->newEqualTo(*_pL);
1997 }
1998
1999 template<>
2000 InternalType* compequal_M_M<Sparse, Sparse, SparseBool>(Sparse* _pL, Sparse* _pR)
2001 {
2002     //pending changes
2003     if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
2004     {
2005         return new Bool(false);
2006     }
2007
2008     return _pR->newEqualTo(*_pL);
2009 }
2010
2011 //[] == SP
2012 template<>
2013 InternalType* compequal_M_M<Double, Sparse, Bool>(Double* _pL, Sparse* _pR)
2014 {
2015     return new Bool(false);
2016 }
2017
2018 //SP == []
2019 template<>
2020 InternalType* compequal_M_M<Sparse, Double, Bool>(Sparse* _pL, Double* _pR)
2021 {
2022     return new Bool(false);
2023 }
2024
2025 //sparse
2026 template<class T, class U, class O>
2027 InternalType* compequal_M_SP(T* _pL, U* _pR)
2028 {
2029     //pending changes
2030
2031     //D -> SP == SP
2032     Sparse* pspConvert = NULL;
2033     types::SparseBool* pOut = NULL;
2034
2035
2036     if (_pL->isScalar())
2037     {
2038         int iSizeOut = _pR->getSize();
2039         if (_pL->isComplex())
2040         {
2041             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
2042             std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
2043             for (int i = 0; i < iSizeOut; i++)
2044             {
2045                 pspConvert->set(i, stComplex);
2046             }
2047         }
2048         else
2049         {
2050             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
2051             for (int i = 0; i < iSizeOut; i++)
2052             {
2053                 pspConvert->set(i, (double)_pL->get(0));
2054             }
2055         }
2056     }
2057     else
2058     {
2059         //check dimensions
2060         if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2061         {
2062             return new Bool(false);
2063         }
2064
2065         int iSizeOut = _pR->getSize();
2066         if (_pL->isComplex())
2067         {
2068             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
2069
2070             for (int i = 0; i < iSizeOut; i++)
2071             {
2072                 std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
2073                 pspConvert->set(i, stComplex);
2074             }
2075         }
2076         else
2077         {
2078             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
2079             for (int i = 0; i < iSizeOut; i++)
2080             {
2081                 pspConvert->set(i, (double)_pL->get(i));
2082             }
2083         }
2084     }
2085
2086     pOut = _pR->newEqualTo(*pspConvert);
2087     delete pspConvert;
2088     return pOut;
2089 }
2090
2091 template<class T, class U, class O>
2092 InternalType* compequal_SP_M(T* _pL, U* _pR)
2093 {
2094     //pending changes
2095
2096     Sparse* pspConvert = NULL;
2097     types::SparseBool* pOut = NULL;
2098
2099     if (_pR->isScalar())
2100     {
2101         int iSizeOut = _pL->getSize();
2102         if (_pR->isComplex())
2103         {
2104             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
2105             std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
2106             for (int i = 0; i < iSizeOut; i++)
2107             {
2108                 pspConvert->set(i, stComplex);
2109             }
2110         }
2111         else
2112         {
2113             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
2114             for (int i = 0; i < iSizeOut; i++)
2115             {
2116                 pspConvert->set(i, (double)_pR->get(0));
2117             }
2118         }
2119     }
2120     else
2121     {
2122         //check dimensions
2123         if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
2124         {
2125             return new Bool(false);
2126         }
2127
2128         int iSizeOut = _pL->getSize();
2129         if (_pR->isComplex())
2130         {
2131             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
2132
2133             for (int i = 0; i < iSizeOut; i++)
2134             {
2135                 std::complex<double> stComplex((double)_pR->get(i), (double)_pR->getImg(i));
2136                 pspConvert->set(i, stComplex);
2137             }
2138         }
2139         else
2140         {
2141             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
2142             for (int i = 0; i < iSizeOut; i++)
2143             {
2144                 pspConvert->set(i, (double)_pR->get(i));
2145
2146             }
2147         }
2148     }
2149
2150     pOut = _pL->newEqualTo(*pspConvert);
2151     delete pspConvert;
2152     return pOut;
2153
2154 }
2155
2156 //sparsebool
2157 template<>
2158 InternalType* compequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
2159 {
2160     //pending changes
2161
2162     //D -> SP == SP
2163     SparseBool* pspConvert = NULL;
2164     types::SparseBool* pOut = NULL;
2165
2166
2167     if (_pL->isScalar())
2168     {
2169         int iSizeOut = _pR->getSize();
2170
2171         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
2172         for (int i = 0; i < iSizeOut; i++)
2173         {
2174             pspConvert->set(i, _pL->get(0) == 1);
2175         }
2176
2177     }
2178     else
2179     {
2180         //check dimensions
2181         if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2182         {
2183             return new Bool(false);
2184         }
2185
2186         int iSizeOut = _pR->getSize();
2187
2188         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
2189         for (int i = 0; i < iSizeOut; i++)
2190         {
2191             pspConvert->set(i, _pL->get(i) == 1);
2192         }
2193     }
2194
2195     pOut = _pR->newEqualTo(*pspConvert);
2196     delete pspConvert;
2197     return pOut;
2198 }
2199
2200 template<>
2201 InternalType* compequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
2202 {
2203     //pending changes
2204
2205     SparseBool* pspConvert = NULL;
2206     types::SparseBool* pOut = NULL;
2207
2208     if (_pR->isScalar())
2209     {
2210         int iSizeOut = _pL->getSize();
2211
2212         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
2213         for (int i = 0; i < iSizeOut; i++)
2214         {
2215             pspConvert->set(i, _pR->get(0) == 1);
2216         }
2217
2218     }
2219     else
2220     {
2221         //check dimensions
2222         if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
2223         {
2224             return new Bool(false);
2225         }
2226
2227         int iSizeOut = _pL->getSize();
2228
2229         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
2230         for (int i = 0; i < iSizeOut; i++)
2231         {
2232             pspConvert->set(i, _pR->get(i) == 1);
2233         }
2234     }
2235
2236     pOut = _pL->newEqualTo(*pspConvert);
2237     delete pspConvert;
2238     return pOut;
2239
2240 }
2241
2242 //Polynom
2243 template<>
2244 InternalType* compequal_M_M<Polynom, Polynom, Bool>(Polynom* _pL, Polynom* _pR)
2245 {
2246     Bool* pbOut = NULL;
2247     bool bPoise = true;
2248
2249     SinglePoly** pSPL = _pL->get();
2250     SinglePoly** pSPR = _pR->get();
2251
2252     if (_pR->isScalar())
2253     {
2254         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2255         int iSize = pbOut->getSize();
2256
2257         if (_pL->isComplex())
2258         {
2259             if (_pR->isComplex())
2260             {
2261                 for (int i = 0; i < iSize; i++)
2262                 {
2263                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
2264                     {
2265                         bPoise = false;
2266                     }
2267                     else
2268                     {
2269                         bPoise = true;
2270                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2271                         {
2272                             compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
2273                         }
2274                     }
2275                     pbOut->set(i, bPoise);
2276
2277                 }
2278             }
2279             else
2280             {
2281                 for (int i = 0; i < iSize; i++)
2282                 {
2283                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
2284                     {
2285                         bPoise = false;
2286                     }
2287                     else
2288                     {
2289                         bPoise = true;
2290                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2291                         {
2292                             compequal(pSPR[0]->get(j), (double)0, pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
2293                         }
2294                     }
2295                     pbOut->set(i, bPoise);
2296                 }
2297             }
2298         }
2299         else
2300         {
2301             if (_pR->isComplex())
2302             {
2303                 for (int i = 0; i < iSize; i++)
2304                 {
2305                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
2306                     {
2307                         bPoise = false;
2308                     }
2309                     else
2310                     {
2311                         bPoise = true;
2312                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2313                         {
2314                             compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
2315                         }
2316                     }
2317                     pbOut->set(i, bPoise);
2318                 }
2319             }
2320             else
2321             {
2322                 for (int i = 0; i < iSize; i++)
2323                 {
2324                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
2325                     {
2326                         bPoise = false;
2327                     }
2328                     else
2329                     {
2330                         bPoise = true;
2331                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2332                         {
2333                             compequal(pSPR[0]->get(j), pSPL[i]->get(j), &bPoise);
2334                         }
2335                     }
2336                     pbOut->set(i, bPoise);
2337                 }
2338             }
2339         }
2340     }
2341     else if (_pL->isScalar())
2342     {
2343         pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2344         int iSize = pbOut->getSize();
2345
2346         if (pSPR[0]->getSize() != 1)
2347         {
2348             if (_pL->isComplex())
2349             {
2350                 if (_pR->isComplex())
2351                 {
2352                     for (int i = 0; i < iSize; i++)
2353                     {
2354                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
2355                         {
2356                             bPoise = false;
2357                         }
2358                         else
2359                         {
2360                             bPoise = true;
2361                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2362                             {
2363                                 compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), pSPR[i]->getImg(j), &bPoise);
2364                             }
2365                         }
2366                         pbOut->set(i, bPoise);
2367                     }
2368                 }
2369                 else
2370                 {
2371                     for (int i = 0; i < iSize; i++)
2372                     {
2373                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
2374                         {
2375                             bPoise = false;
2376                         }
2377                         else
2378                         {
2379                             bPoise = true;
2380                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2381                             {
2382                                 compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
2383                             }
2384                         }
2385                         pbOut->set(i, bPoise);
2386                     }
2387                 }
2388             }
2389             else
2390             {
2391
2392                 if (_pR->isComplex())
2393                 {
2394                     for (int i = 0; i < iSize; i++)
2395                     {
2396                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
2397                         {
2398                             bPoise = false;
2399                         }
2400                         else
2401                         {
2402                             bPoise = true;
2403                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
2404                             {
2405                                 compequal(pSPL[0]->get(j), (double)0, pSPR[i]->get(j), pSPR[i]->get(j), &bPoise);
2406                             }
2407                         }
2408                         pbOut->set(i, bPoise);
2409                     }
2410                 }
2411                 else
2412                 {
2413                     for (int i = 0; i < iSize; i++)
2414                     {
2415                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
2416                         {
2417                             bPoise = false;
2418                         }
2419                         else
2420                         {
2421                             bPoise = true;
2422                             for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
2423                             {
2424                                 compequal(pSPL[0]->get(j), pSPR[i]->get(j), &bPoise);
2425                             }
2426                         }
2427                         pbOut->set(i, bPoise);
2428                     }
2429                 }
2430
2431             }
2432         }
2433     }
2434     else
2435     {
2436         //check dimensions
2437         if (_pL->getDims() != _pR->getDims())
2438         {
2439             return new Bool(false);
2440         }
2441
2442         for (int i = 0; i < _pL->getDims(); i++)
2443         {
2444             if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
2445             {
2446                 return new Bool(false);
2447             }
2448         }
2449
2450         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2451         int iSize = pbOut->getSize();
2452
2453         if (_pL->isComplex())
2454         {
2455             if (_pR->isComplex())
2456             {
2457                 for (int i = 0; i < iSize; i++)
2458                 {
2459                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
2460                     {
2461                         bPoise = false;
2462                     }
2463                     else
2464                     {
2465                         bPoise = true;
2466                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
2467                         {
2468                             compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
2469                         }
2470                     }
2471                     pbOut->set(i, bPoise);
2472                 }
2473             }
2474             else
2475             {
2476                 for (int i = 0; i < iSize; i++)
2477                 {
2478                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
2479                     {
2480                         bPoise = false;
2481                     }
2482                     else
2483                     {
2484                         bPoise = true;
2485                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
2486                         {
2487                             compequal(pSPL[i]->get(j), pSPL[i]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
2488                         }
2489                     }
2490                     pbOut->set(i, bPoise);
2491                 }
2492             }
2493         }
2494         else
2495         {
2496             if (_pR->isComplex())
2497             {
2498                 for (int i = 0; i < iSize; i++)
2499                 {
2500                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
2501                     {
2502                         bPoise = false;
2503                     }
2504                     else
2505                     {
2506                         bPoise = true;
2507                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
2508                         {
2509                             compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
2510                         }
2511                     }
2512                     pbOut->set(i, bPoise);
2513                 }
2514             }
2515             else
2516             {
2517                 for (int i = 0; i < iSize; i++)
2518                 {
2519                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
2520                     {
2521                         bPoise = false;
2522                     }
2523                     else
2524                     {
2525                         bPoise = true;
2526                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
2527                         {
2528                             compequal(pSPR[i]->get(j), pSPL[i]->get(j), &bPoise);
2529                         }
2530                     }
2531                     pbOut->set(i, bPoise);
2532                 }
2533             }
2534         }
2535     }
2536
2537     return pbOut;
2538 }
2539
2540 template<class T, class U, class O>
2541 InternalType* compequal_P_M(T *_pL, U *_pR)
2542 {
2543     Bool* pbOut = NULL;
2544
2545     SinglePoly** pSPR = _pL->get();
2546
2547     if (_pR->isIdentity())
2548     {
2549         Double* pdblEye = NULL;
2550         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2551         int iSize = pbOut->getSize();
2552
2553         if (_pL->isComplex())
2554         {
2555             if (_pR->isComplex())
2556             {
2557                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
2558                 for (int i = 0; i < iSize; i++)
2559                 {
2560                     if (pSPR[i]->getSize() != 1)
2561                     {
2562                         pbOut->set(i, false);
2563                     }
2564                     else
2565                     {
2566                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
2567                     }
2568                 }
2569             }
2570             else
2571             {
2572                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
2573                 for (int i = 0; i < iSize; i++)
2574                 {
2575                     if (pSPR[i]->getSize() != 1)
2576                     {
2577                         pbOut->set(i, false);
2578                     }
2579                     else
2580                     {
2581                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)0, &(pbOut->get()[i]));
2582                     }
2583                 }
2584             }
2585         }
2586         else
2587         {
2588             if (_pR->isComplex())
2589             {
2590                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
2591                 for (int i = 0; i < iSize; i++)
2592                 {
2593                     if (pSPR[i]->getSize() != 1)
2594                     {
2595                         pbOut->set(i, false);
2596                     }
2597                     else
2598                     {
2599                         compequal((double)pSPR[i]->get(0), (double)0, (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
2600                     }
2601                 }
2602             }
2603             else
2604             {
2605                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
2606                 for (int i = 0; i < iSize; i++)
2607                 {
2608                     if (pSPR[i]->getSize() != 1)
2609                     {
2610                         pbOut->set(i, false);
2611                     }
2612                     else
2613                     {
2614                         compequal((double)pSPR[i]->get(0), (double)pdblEye->get(i), &(pbOut->get()[i]));
2615                     }
2616                 }
2617             }
2618         }
2619         delete pdblEye;
2620     }
2621     else if (_pR->isScalar())
2622     {
2623         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2624         int iSize = pbOut->getSize();
2625
2626         if (_pL->isComplex())
2627         {
2628             if (_pR->isComplex())
2629             {
2630                 for (int i = 0; i < iSize; i++)
2631                 {
2632                     if (pSPR[i]->getSize() != 1)
2633                     {
2634                         pbOut->set(i, false);
2635                     }
2636                     else
2637                     {
2638                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
2639                     }
2640                 }
2641             }
2642             else
2643             {
2644                 for (int i = 0; i < iSize; i++)
2645                 {
2646                     if (pSPR[i]->getSize() != 1)
2647                     {
2648                         pbOut->set(i, false);
2649                     }
2650                     else
2651                     {
2652                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)0, &(pbOut->get()[i]));
2653                     }
2654                 }
2655             }
2656         }
2657         else
2658         {
2659             if (_pR->isComplex())
2660             {
2661                 for (int i = 0; i < iSize; i++)
2662                 {
2663                     if (pSPR[i]->getSize() != 1)
2664                     {
2665                         pbOut->set(i, false);
2666                     }
2667                     else
2668                     {
2669                         compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
2670                     }
2671                 }
2672             }
2673             else
2674             {
2675                 for (int i = 0; i < iSize; i++)
2676                 {
2677                     if (pSPR[i]->getSize() != 1)
2678                     {
2679                         pbOut->set(i, false);
2680                     }
2681                     else
2682                     {
2683                         compequal((double)pSPR[i]->get(0), (double)_pR->get(0), &(pbOut->get()[i]));
2684                     }
2685                 }
2686             }
2687         }
2688     }
2689     else if (_pL->isScalar())
2690     {
2691         pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2692         int iSize = pbOut->getSize();
2693
2694         if (pSPR[0]->getSize() == 1)
2695         {
2696             if (_pL->isComplex())
2697             {
2698                 if (_pR->isComplex())
2699                 {
2700                     for (int i = 0; i < iSize; i++)
2701                     {
2702                         compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
2703                     }
2704                 }
2705                 else
2706                 {
2707                     for (int i = 0; i < iSize; i++)
2708                     {
2709                         compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
2710                     }
2711                 }
2712             }
2713             else
2714             {
2715                 if (_pR->isComplex())
2716                 {
2717                     for (int i = 0; i < iSize; i++)
2718                     {
2719                         compequal((double)pSPR[0]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
2720                     }
2721                 }
2722                 else
2723                 {
2724                     for (int i = 0; i < iSize; i++)
2725                     {
2726                         compequal((double)pSPR[0]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
2727                     }
2728                 }
2729
2730             }
2731         }
2732         else
2733         {
2734             pbOut->setFalse();
2735         }
2736
2737     }
2738     else
2739     {
2740         //check dimensions
2741         if (_pL->getDims() != _pR->getDims())
2742         {
2743             return new Bool(false);
2744         }
2745
2746         for (int i = 0; i < _pL->getDims(); i++)
2747         {
2748             if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
2749             {
2750                 return new Bool(false);
2751             }
2752         }
2753
2754         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2755         int iSize = pbOut->getSize();
2756
2757         if (_pL->isComplex())
2758         {
2759             if (_pR->isComplex())
2760             {
2761                 for (int i = 0; i < iSize; i++)
2762                 {
2763                     if (pSPR[i]->getSize() != 1)
2764                     {
2765                         pbOut->set(i, false);
2766                     }
2767                     else
2768                     {
2769                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
2770                     }
2771                 }
2772             }
2773             else
2774             {
2775                 for (int i = 0; i < iSize; i++)
2776                 {
2777                     if (pSPR[i]->getSize() != 1)
2778                     {
2779                         pbOut->set(i, false);
2780                     }
2781                     else
2782                     {
2783                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
2784                     }
2785                 }
2786             }
2787         }
2788         else
2789         {
2790             if (_pR->isComplex())
2791             {
2792                 for (int i = 0; i < iSize; i++)
2793                 {
2794                     if (pSPR[i]->getSize() != 1)
2795                     {
2796                         pbOut->set(i, false);
2797                     }
2798                     else
2799                     {
2800                         compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
2801                     }
2802                 }
2803             }
2804             else
2805             {
2806                 for (int i = 0; i < iSize; i++)
2807                 {
2808                     if (pSPR[i]->getSize() != 1)
2809                     {
2810                         pbOut->set(i, false);
2811                     }
2812                     else
2813                     {
2814                         compequal((double)pSPR[i]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
2815                     }
2816                 }
2817             }
2818         }
2819     }
2820
2821     return pbOut;
2822 }
2823
2824 template<class T, class U, class O>
2825 InternalType* compequal_M_P(T *_pL, U *_pR)
2826 {
2827     return GenericComparisonEqual(_pR, _pL);
2828 }
2829
2830 template<>
2831 InternalType* compequal_M_M<String, String, Bool>(String* _pL, String* _pR)
2832 {
2833     if (_pL->getSize() == _pR->getSize())
2834     {
2835         //check dims
2836         int iDimsL = _pL->getDims();
2837         int iDimsR = _pR->getDims();
2838
2839         if (iDimsL != iDimsR)
2840         {
2841             return new Bool(false);
2842         }
2843
2844         int* piDimsL = _pL->getDimsArray();
2845         int* piDimsR = _pR->getDimsArray();
2846
2847         for (int i = 0; i < iDimsL; ++i)
2848         {
2849             if (piDimsL[i] != piDimsR[i])
2850             {
2851                 return new Bool(false);
2852             }
2853         }
2854         Bool*  pOut = new Bool(iDimsL, piDimsL);
2855
2856         for (int i = 0; i < _pL->getSize(); i++)
2857         {
2858             pOut->set(i, wcscmp(_pL->get(i), _pR->get(i)) == 0);
2859         }
2860         return pOut;
2861     }
2862     else if (_pL->getSize() == 1)
2863     {
2864         Bool*  pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2865         for (int i = 0; i < _pR->getSize(); i++)
2866         {
2867             pOut->set(i, wcscmp(_pL->get(0), _pR->get(i)) == 0);
2868         }
2869         return pOut;
2870     }
2871     else if (_pR->getSize() == 1)
2872     {
2873         Bool*  pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2874         for (int i = 0; i < _pL->getSize(); i++)
2875         {
2876             pOut->set(i, wcscmp(_pL->get(i), _pR->get(0)) == 0);
2877         }
2878         return pOut;
2879     }
2880
2881     return NULL;
2882 }
2883
2884 template<>
2885 types::InternalType* compequal_M_M<Struct, Struct, Bool>(types::Struct* _pL, types::Struct* _pR)
2886 {
2887
2888     if (_pL->getSize() != _pR->getSize())
2889     {
2890         return new Bool(false);
2891     }
2892
2893     String* pStringFielNamesPL = _pL->getFieldNames();
2894     String* pStringFielNamesPR = _pR->getFieldNames();
2895     wchar_t** ppwchPR = pStringFielNamesPR->get();
2896     wchar_t** ppwchPL = pStringFielNamesPL->get();
2897
2898     Bool* pOut = new Bool(1, 2 * pStringFielNamesPL->getSize());
2899     pOut->setTrue();
2900     int* piPOut = pOut->get();
2901
2902     for (int iComptSStruct = 0; iComptSStruct < _pL->getSize(); iComptSStruct++)
2903     {
2904         for (int i = 0; i < pStringFielNamesPL->getSize(); i++)
2905         {
2906             piPOut[i * 2] = (wcscmp(ppwchPR[i], ppwchPL[i]) == 0) && (piPOut[i * 2] == 1);
2907
2908
2909             if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == _pR->get(iComptSStruct)->get(ppwchPR[i])->getType())
2910             {
2911                 if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == types::InternalType::ScilabStruct)
2912                 {
2913                     piPOut[i * 2 + 1] = _pL->get(iComptSStruct)->get(ppwchPL[i]) == _pR->get(iComptSStruct)->get(ppwchPR[i]) && (piPOut[i * 2] == 1);
2914                 }
2915                 else
2916                 {
2917                     types::InternalType* pResolution = GenericComparisonEqual(_pL->get(iComptSStruct)->get(pStringFielNamesPL->get(i)), _pR->get(iComptSStruct)->get(pStringFielNamesPR->get(i)));
2918                     bool bValeur = true;
2919                     if (pResolution->getType() == types::InternalType::ScilabBool)
2920                     {
2921                         Bool* pBoolTempo = pResolution->getAs<Bool>();
2922                         for (int j = 0; j < pBoolTempo->getSize() && bValeur == true; j++)
2923                         {
2924                             if (pBoolTempo->get(j) != 1)
2925                             {
2926                                 bValeur = false;
2927                                 break;
2928                             }
2929                         }
2930                     }
2931                     else
2932                     {
2933                         SparseBool* pSparseBoolTempo = pResolution->getAs<SparseBool>();
2934                         for (int j = 0; j < pSparseBoolTempo->getSize() && bValeur == true; j++)
2935                         {
2936                             if (pSparseBoolTempo->get(j) != 1)
2937                             {
2938                                 bValeur = false;
2939                                 break;
2940                             }
2941                         }
2942                     }
2943                     piPOut[i * 2 + 1] = bValeur && (piPOut[i * 2 + 1] == 1);
2944                 }
2945             }
2946             else
2947             {
2948                 piPOut[i * 2 + 1] = false;
2949             }
2950         }
2951     }
2952
2953     return pOut;
2954 }
2955
2956 template<class T, class U, class O>
2957 InternalType* compequal_LT_LT(T *_pL, U *_pR)
2958 {
2959     if ((_pL->getType() != _pR->getType()) && (_pL->getType() == GenericType::ScilabList || _pR->getType() == GenericType::ScilabList))
2960     {
2961         return NULL;
2962     }
2963
2964     if (_pL->getSize() != _pR->getSize())
2965     {
2966         return new Bool(false);
2967     }
2968
2969     if (_pL->getSize() == 0 && _pR->getSize() == 0)
2970     {
2971         return new Bool(true);
2972     }
2973
2974     Bool* pB = new Bool(1, _pL->getSize());
2975     for (int i = 0; i < _pL->getSize(); i++)
2976     {
2977         pB->set(i, ((*_pL->get(i) == *_pR->get(i)) && (_pL->get(i)->getType() != types::InternalType::ScilabVoid)));
2978     }
2979
2980     return pB;
2981 }
2982
2983 template<>
2984 types::InternalType* compequal_M_M<Cell, Cell, Bool>(types::Cell* _pL, types::Cell* _pR)
2985 {
2986     /* check dimension*/
2987     if (_pL->getDims() != _pR->getDims())
2988     {
2989         return new Bool(false);
2990     }
2991
2992     int* piDimsL = _pL->getDimsArray();
2993     int* piDimsR = _pR->getDimsArray();
2994
2995     for (int i = 0; i < _pL->getDims(); i++)
2996     {
2997         if (piDimsL[i] != piDimsR[i])
2998         {
2999             return new Bool(false);
3000         }
3001     }
3002
3003     if (_pL->getSize() == 0)
3004     {
3005         //{} == {} -> return true
3006         return new Bool(true);
3007     }
3008
3009     Bool *pB = new Bool(_pL->getDims(), piDimsL);
3010     for (int i = 0; i < _pL->getSize(); i++)
3011     {
3012         pB->set(i, *_pL->get(i) == *_pR->get(i));
3013     }
3014
3015     return pB;
3016 }
3017
3018 template<>
3019 types::InternalType* compequal_M_M<GraphicHandle, GraphicHandle, Bool>(GraphicHandle* _pL, GraphicHandle* _pR)
3020 {
3021
3022     /* check dimension*/
3023     if (_pL->getDims() != _pR->getDims())
3024     {
3025         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
3026     }
3027
3028     int* piDimsL = _pL->getDimsArray();
3029     int* piDimsR = _pR->getDimsArray();
3030
3031     for (int i = 0; i < _pL->getDims(); i++)
3032     {
3033         if (piDimsL[i] != piDimsR[i])
3034         {
3035             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
3036         }
3037     }
3038
3039     Bool* pOut = new Bool(_pL->getDims(), piDimsL);
3040     int iSize = pOut->getSize();
3041
3042     compequal(_pL->get(), iSize, _pR->get(), pOut->get());
3043     return pOut;
3044 }
3045
3046 template<class T, class U, class O>
3047 InternalType* compequal_MCR_MCR(T *_pL, U *_pR)
3048 {
3049     bool ret = false;
3050     if (_pL->getType() == GenericType::ScilabMacroFile)
3051     {
3052         types::InternalType* pIT = ((InternalType *) _pL);
3053         types::MacroFile* pL = pIT->getAs<types::MacroFile>();
3054         ret = *pL == *_pR;
3055     }
3056     else if (_pL->getType() == GenericType::ScilabMacro)
3057     {
3058         types::InternalType* pIT = ((InternalType *) _pL);
3059         types::Macro* pL = pIT->getAs<types::Macro>();
3060         if (_pR->getType() == GenericType::ScilabMacroFile)
3061         {
3062             types::InternalType* pIT = ((InternalType *) _pR);
3063             types::MacroFile* pR = pIT->getAs<types::MacroFile>();
3064             ret = *pR == *pL;
3065         }
3066         else
3067         {
3068             ret = *pL == *_pR;
3069         }
3070     }
3071
3072     return new Bool(ret);
3073 }