List comparison fixed
[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 #include "overload.hxx"
28 #include "user.hxx"
29
30 using namespace types;
31
32 //define arrays on operation functions
33 static compequal_function pComparisonEqualfunction[types::InternalType::IdLast][types::InternalType::IdLast] = { NULL };
34
35
36 void fillComparisonEqualFunction()
37 {
38 #define scilab_fill_comparisonequal(id1, id2, func, typeIn1, typeIn2, typeOut) \
39     pComparisonEqualfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (compequal_function)&compequal_##func<typeIn1, typeIn2, typeOut>
40
41     //String == String
42     scilab_fill_comparisonequal(String, String, M_M, String, String, Bool);
43     scilab_fill_comparisonequal(String, ScalarString, M_M, String, String, Bool);
44     scilab_fill_comparisonequal(ScalarString, ScalarString, M_M, String, String, Bool);
45     scilab_fill_comparisonequal(ScalarString, String, M_M, String, String, Bool);
46     //String == Empty
47     scilab_fill_comparisonequal(Empty, ScalarString, E_M, String, String, Bool);
48     scilab_fill_comparisonequal(ScalarString, Empty, M_E, String, String, Bool);
49     scilab_fill_comparisonequal(String, Empty, M_E, String, String, Bool);
50     scilab_fill_comparisonequal(Empty, String, E_M, String, String, Bool);
51     //String == Double
52     scilab_fill_comparisonequal(Double, ScalarString, M_E, Double, String, Bool);
53     scilab_fill_comparisonequal(ScalarString, Double, M_E, String, Double, Bool);
54     scilab_fill_comparisonequal(String, Double, M_E, String, Double, Bool);
55     scilab_fill_comparisonequal(Double, String, M_E, Double, String, Bool);
56     //String == ScalarDouble
57     scilab_fill_comparisonequal(ScalarDouble, ScalarString, M_E, Double, String, Bool);
58     scilab_fill_comparisonequal(ScalarString, ScalarDouble, M_E, String, Double, Bool);
59     scilab_fill_comparisonequal(String, ScalarDouble, M_E, String, Double, Bool);
60     scilab_fill_comparisonequal(ScalarDouble, String, M_E, Double, String, Bool);
61     //String == Int8
62     scilab_fill_comparisonequal(Int8, ScalarString, M_E, Int8, String, Bool);
63     scilab_fill_comparisonequal(ScalarString, Int8, M_E, String, Int8, Bool);
64     scilab_fill_comparisonequal(String, Int8, M_E, String, Int8, Bool);
65     scilab_fill_comparisonequal(Int8, String, M_E, Int8, String, Bool);
66     //String == UInt8
67     scilab_fill_comparisonequal(UInt8, ScalarString, M_E, UInt8, String, Bool);
68     scilab_fill_comparisonequal(ScalarString, UInt8, M_E, String, UInt8, Bool);
69     scilab_fill_comparisonequal(String, UInt8, M_E, String, UInt8, Bool);
70     scilab_fill_comparisonequal(UInt8, String, M_E, UInt8, String, Bool);
71     //String == Int16
72     scilab_fill_comparisonequal(Int16, ScalarString, M_E, Int16, String, Bool);
73     scilab_fill_comparisonequal(ScalarString, Int16, M_E, String, Int16, Bool);
74     scilab_fill_comparisonequal(String, Int16, M_E, String, Int16, Bool);
75     scilab_fill_comparisonequal(Int16, String, M_E, Int16, String, Bool);
76     //String == UInt16
77     scilab_fill_comparisonequal(UInt16, ScalarString, M_E, UInt16, String, Bool);
78     scilab_fill_comparisonequal(ScalarString, UInt16, M_E, String, UInt16, Bool);
79     scilab_fill_comparisonequal(String, UInt16, M_E, String, UInt16, Bool);
80     scilab_fill_comparisonequal(UInt16, String, M_E, UInt16, String, Bool);
81     //String == Int32
82     scilab_fill_comparisonequal(Int32, ScalarString, M_E, Int32, String, Bool);
83     scilab_fill_comparisonequal(ScalarString, Int32, M_E, String, Int32, Bool);
84     scilab_fill_comparisonequal(String, Int32, M_E, String, Int32, Bool);
85     scilab_fill_comparisonequal(Int32, String, M_E, Int32, String, Bool);
86     //String == UInt32
87     scilab_fill_comparisonequal(UInt32, ScalarString, M_E, UInt32, String, Bool);
88     scilab_fill_comparisonequal(ScalarString, UInt32, M_E, String, UInt32, Bool);
89     scilab_fill_comparisonequal(String, UInt32, M_E, String, UInt32, Bool);
90     scilab_fill_comparisonequal(UInt32, String, M_E, UInt32, String, Bool);
91     //String == Int64
92     scilab_fill_comparisonequal(Int64, ScalarString, M_E, Int64, String, Bool);
93     scilab_fill_comparisonequal(ScalarString, Int64, M_E, String, Int64, Bool);
94     scilab_fill_comparisonequal(String, Int64, M_E, String, Int64, Bool);
95     scilab_fill_comparisonequal(Int64, String, M_E, Int64, String, Bool);
96     //String == UInt64
97     scilab_fill_comparisonequal(UInt64, ScalarString, M_E, UInt64, String, Bool);
98     scilab_fill_comparisonequal(ScalarString, UInt64, M_E, String, UInt64, Bool);
99     scilab_fill_comparisonequal(String, UInt64, M_E, String, UInt64, Bool);
100     scilab_fill_comparisonequal(UInt64, String, M_E, UInt64, String, Bool);
101     //String == Bool
102     scilab_fill_comparisonequal(Bool, ScalarString, M_E, Bool, String, Bool);
103     scilab_fill_comparisonequal(ScalarString, Bool, M_E, String, Bool, Bool);
104     scilab_fill_comparisonequal(String, Bool, M_E, String, Bool, Bool);
105     scilab_fill_comparisonequal(Bool, String, M_E, Bool, String, Bool);
106     //String == Polynom
107     scilab_fill_comparisonequal(Polynom, ScalarString, M_E, Polynom, String, Bool);
108     scilab_fill_comparisonequal(ScalarString, Polynom, M_E, String, Polynom, Bool);
109     scilab_fill_comparisonequal(String, Polynom, M_E, String, Polynom, Bool);
110     scilab_fill_comparisonequal(Polynom, String, M_E, Polynom, String, Bool);
111     //String == PolynomComplex
112     scilab_fill_comparisonequal(PolynomComplex, ScalarString, M_E, Polynom, String, Bool);
113     scilab_fill_comparisonequal(ScalarString, PolynomComplex, M_E, String, Polynom, Bool);
114     scilab_fill_comparisonequal(String, PolynomComplex, M_E, String, Polynom, Bool);
115     scilab_fill_comparisonequal(PolynomComplex, String, M_E, Polynom, String, Bool);
116     //String == ScalarPolynom
117     scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
118     scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
119     scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
120     scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
121     //String == ScalarPolynomComplex
122     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
123     scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
124     scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
125     scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
126     //String == Sparse
127     scilab_fill_comparisonequal(Sparse, ScalarString, M_E, Sparse, String, Bool);
128     scilab_fill_comparisonequal(ScalarString, Sparse, M_E, String, Sparse, Bool);
129     scilab_fill_comparisonequal(String, Sparse, M_E, String, Sparse, Bool);
130     scilab_fill_comparisonequal(Sparse, String, M_E, Sparse, String, Bool);
131     //String == SparseBool
132     scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
133     scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
134     scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
135     scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
136     //String == ScalarInt8
137     scilab_fill_comparisonequal(ScalarInt8, ScalarString, M_E, Int8, String, Bool);
138     scilab_fill_comparisonequal(ScalarString, ScalarInt8, M_E, String, Int8, Bool);
139     scilab_fill_comparisonequal(String, ScalarInt8, M_E, String, Int8, Bool);
140     scilab_fill_comparisonequal(ScalarInt8, String, M_E, Int8, String, Bool);
141     //String == ScalarUInt8
142     scilab_fill_comparisonequal(ScalarUInt8, ScalarString, M_E, UInt8, String, Bool);
143     scilab_fill_comparisonequal(ScalarString, ScalarUInt8, M_E, String, UInt8, Bool);
144     scilab_fill_comparisonequal(String, ScalarUInt8, M_E, String, UInt8, Bool);
145     scilab_fill_comparisonequal(ScalarUInt8, String, M_E, UInt8, String, Bool);
146     //String == ScalarInt16
147     scilab_fill_comparisonequal(ScalarInt16, ScalarString, M_E, Int16, String, Bool);
148     scilab_fill_comparisonequal(ScalarString, ScalarInt16, M_E, String, Int16, Bool);
149     scilab_fill_comparisonequal(String, ScalarInt16, M_E, String, Int16, Bool);
150     scilab_fill_comparisonequal(ScalarInt16, String, M_E, Int16, String, Bool);
151     //String == ScalarUInt16
152     scilab_fill_comparisonequal(ScalarUInt16, ScalarString, M_E, UInt16, String, Bool);
153     scilab_fill_comparisonequal(ScalarString, ScalarUInt16, M_E, String, UInt16, Bool);
154     scilab_fill_comparisonequal(String, ScalarUInt16, M_E, String, UInt16, Bool);
155     scilab_fill_comparisonequal(ScalarUInt16, String, M_E, UInt16, String, Bool);
156     //String == ScalarInt32
157     scilab_fill_comparisonequal(ScalarInt32, ScalarString, M_E, Int32, String, Bool);
158     scilab_fill_comparisonequal(ScalarString, ScalarInt32, M_E, String, Int32, Bool);
159     scilab_fill_comparisonequal(String, ScalarInt32, M_E, String, Int32, Bool);
160     scilab_fill_comparisonequal(ScalarInt32, String, M_E, Int32, String, Bool);
161     //String == ScalarUInt32
162     scilab_fill_comparisonequal(ScalarUInt32, ScalarString, M_E, UInt32, String, Bool);
163     scilab_fill_comparisonequal(ScalarString, ScalarUInt32, M_E, String, UInt32, Bool);
164     scilab_fill_comparisonequal(String, ScalarUInt32, M_E, String, UInt32, Bool);
165     scilab_fill_comparisonequal(ScalarUInt32, String, M_E, UInt32, String, Bool);
166     //String == ScalarInt64
167     scilab_fill_comparisonequal(ScalarInt64, ScalarString, M_E, Int64, String, Bool);
168     scilab_fill_comparisonequal(ScalarString, ScalarInt64, M_E, String, Int64, Bool);
169     scilab_fill_comparisonequal(String, ScalarInt64, M_E, String, Int64, Bool);
170     scilab_fill_comparisonequal(ScalarInt64, String, M_E, Int64, String, Bool);
171     //String == ScalarUInt64
172     scilab_fill_comparisonequal(ScalarUInt64, ScalarString, M_E, UInt64, String, Bool);
173     scilab_fill_comparisonequal(ScalarString, ScalarUInt64, M_E, String, UInt64, Bool);
174     scilab_fill_comparisonequal(String, ScalarUInt64, M_E, String, UInt64, Bool);
175     scilab_fill_comparisonequal(ScalarUInt64, String, M_E, UInt64, String, Bool);
176     //String == ScalarBool
177     scilab_fill_comparisonequal(ScalarBool, ScalarString, M_E, Bool, String, Bool);
178     scilab_fill_comparisonequal(ScalarString, ScalarBool, M_E, String, Bool, Bool);
179     scilab_fill_comparisonequal(String, ScalarBool, M_E, String, Bool, Bool);
180     scilab_fill_comparisonequal(ScalarBool, String, M_E, Bool, String, Bool);
181     //String == ScalarPolynom
182     scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
183     scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
184     scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
185     scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
186     //String == ScalarDoubleComplex
187     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarString, M_E, Double, String, Bool);
188     scilab_fill_comparisonequal(ScalarString, ScalarDoubleComplex, M_E, String, Double, Bool);
189     scilab_fill_comparisonequal(String, ScalarDoubleComplex, M_E, String, Double, Bool);
190     scilab_fill_comparisonequal(ScalarDoubleComplex, String, M_E, Double, String, Bool);
191     //String == DoubleComplex
192     scilab_fill_comparisonequal(DoubleComplex, ScalarString, M_E, Double, String, Bool);
193     scilab_fill_comparisonequal(ScalarString, DoubleComplex, M_E, String, Double, Bool);
194     scilab_fill_comparisonequal(String, DoubleComplex, M_E, String, Double, Bool);
195     scilab_fill_comparisonequal(DoubleComplex, String, M_E, Double, String, Bool);
196     //String == ScalarPolynomComplex
197     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
198     scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
199     scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
200     scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
201     //String == SparseComplex
202     scilab_fill_comparisonequal(SparseComplex, ScalarString, M_E, Sparse, String, Bool);
203     scilab_fill_comparisonequal(ScalarString, SparseComplex, M_E, String, Sparse, Bool);
204     scilab_fill_comparisonequal(String, SparseComplex, M_E, String, Sparse, Bool);
205     scilab_fill_comparisonequal(SparseComplex, String, M_E, Sparse, String, Bool);
206     //String == Identity
207     scilab_fill_comparisonequal(Identity, ScalarString, M_E, Double, String, Bool);
208     scilab_fill_comparisonequal(ScalarString, Identity, M_E, String, Double, Bool);
209     scilab_fill_comparisonequal(String, Identity, M_E, String, Double, Bool);
210     scilab_fill_comparisonequal(Identity, String, M_E, Double, String, Bool);
211     //String == IdentityComplex
212     scilab_fill_comparisonequal(IdentityComplex, ScalarString, M_E, Double, String, Bool);
213     scilab_fill_comparisonequal(ScalarString, IdentityComplex, M_E, String, Double, Bool);
214     scilab_fill_comparisonequal(String, IdentityComplex, M_E, String, Double, Bool);
215     scilab_fill_comparisonequal(IdentityComplex, String, M_E, Double, String, Bool);
216
217     //Double
218     //Matrix == Matrix
219     scilab_fill_comparisonequal(Double, Double, M_M, Double, Double, Bool);
220     scilab_fill_comparisonequal(Double, Int8, M_M, Double, Int8, Bool);
221     scilab_fill_comparisonequal(Double, UInt8, M_M, Double, UInt8, Bool);
222     scilab_fill_comparisonequal(Double, Int16, M_M, Double, Int16, Bool);
223     scilab_fill_comparisonequal(Double, UInt16, M_M, Double, UInt16, Bool);
224     scilab_fill_comparisonequal(Double, Int32, M_M, Double, Int32, Bool);
225     scilab_fill_comparisonequal(Double, UInt32, M_M, Double, UInt32, Bool);
226     scilab_fill_comparisonequal(Double, Int64, M_M, Double, Int64, Bool);
227     scilab_fill_comparisonequal(Double, UInt64, M_M, Double, UInt64, Bool);
228     scilab_fill_comparisonequal(Double, Bool, M_E, Double, Bool, Bool);
229     scilab_fill_comparisonequal(Double, Polynom, M_P, Double, Polynom, Bool);
230     scilab_fill_comparisonequal(Double, Sparse, M_SP, Double, Sparse, SparseBool);
231
232     //Matrix == Matrix Complex
233     scilab_fill_comparisonequal(Double, DoubleComplex, M_MC, Double, Double, Bool);
234     scilab_fill_comparisonequal(Double, PolynomComplex, M_P, Double, Polynom, Bool);
235     scilab_fill_comparisonequal(Double, SparseComplex, M_SP, Double, Sparse, SparseBool);
236
237     //Matrix == Scalar
238     scilab_fill_comparisonequal(Double, ScalarDouble, M_S, Double, Double, Bool);
239     scilab_fill_comparisonequal(Double, ScalarInt8, M_S, Double, Int8, Bool);
240     scilab_fill_comparisonequal(Double, ScalarUInt8, M_S, Double, UInt8, Bool);
241     scilab_fill_comparisonequal(Double, ScalarInt16, M_S, Double, Int16, Bool);
242     scilab_fill_comparisonequal(Double, ScalarUInt16, M_S, Double, UInt16, Bool);
243     scilab_fill_comparisonequal(Double, ScalarInt32, M_S, Double, Int32, Bool);
244     scilab_fill_comparisonequal(Double, ScalarUInt32, M_S, Double, UInt32, Bool);
245     scilab_fill_comparisonequal(Double, ScalarInt64, M_S, Double, Int64, Bool);
246     scilab_fill_comparisonequal(Double, ScalarUInt64, M_S, Double, UInt64, Bool);
247     scilab_fill_comparisonequal(Double, ScalarBool, M_E, Double, Bool, Bool);
248     scilab_fill_comparisonequal(Double, ScalarPolynom, M_P, Double, Polynom, Bool);
249
250     //Matrix == Scalar Complex
251     scilab_fill_comparisonequal(Double, ScalarDoubleComplex, M_SC, Double, Double, Bool);
252     scilab_fill_comparisonequal(Double, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
253
254     //Matrix == Empty
255     scilab_fill_comparisonequal(Double, Empty, M_E, Double, Double, Bool);
256
257
258     //Matrix Complex == Matrix
259     scilab_fill_comparisonequal(DoubleComplex, Double, MC_M, Double, Double, Bool);
260     scilab_fill_comparisonequal(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Bool);
261     scilab_fill_comparisonequal(DoubleComplex, ScalarDouble, MC_S, Double, Double, Bool);
262     scilab_fill_comparisonequal(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Bool);
263     scilab_fill_comparisonequal(DoubleComplex, Empty, M_E, Double, Double, Bool);
264     scilab_fill_comparisonequal(DoubleComplex, Polynom, M_P, Double, Polynom, Bool);
265     scilab_fill_comparisonequal(DoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
266     scilab_fill_comparisonequal(DoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
267     scilab_fill_comparisonequal(DoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
268     scilab_fill_comparisonequal(DoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
269     scilab_fill_comparisonequal(DoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
270
271     //Scalar == Matrix
272     scilab_fill_comparisonequal(ScalarDouble, Double, S_M, Double, Double, Bool);
273     scilab_fill_comparisonequal(ScalarDouble, Int8, S_M, Double, Int8, Bool);
274     scilab_fill_comparisonequal(ScalarDouble, UInt8, S_M, Double, UInt8, Bool);
275     scilab_fill_comparisonequal(ScalarDouble, Int16, S_M, Double, Int16, Bool);
276     scilab_fill_comparisonequal(ScalarDouble, UInt16, S_M, Double, UInt16, Bool);
277     scilab_fill_comparisonequal(ScalarDouble, Int32, S_M, Double, Int32, Bool);
278     scilab_fill_comparisonequal(ScalarDouble, UInt32, S_M, Double, UInt32, Bool);
279     scilab_fill_comparisonequal(ScalarDouble, Int64, S_M, Double, Int64, Bool);
280     scilab_fill_comparisonequal(ScalarDouble, UInt64, S_M, Double, UInt64, Bool);
281     scilab_fill_comparisonequal(ScalarDouble, Bool, M_E, Double, Bool, Bool);
282     scilab_fill_comparisonequal(ScalarDouble, Polynom, M_P, Double, Polynom, Bool);
283     scilab_fill_comparisonequal(ScalarDouble, Sparse, M_SP, Double, Sparse, SparseBool);
284
285     //Scalar == Matrix Complex
286     scilab_fill_comparisonequal(ScalarDouble, DoubleComplex, S_MC, Double, Double, Bool);
287     scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
288     scilab_fill_comparisonequal(ScalarDouble, SparseComplex, M_SP, Double, Sparse, SparseBool);
289
290     //Scalar == Scalar
291     scilab_fill_comparisonequal(ScalarDouble, ScalarDouble, S_S, Double, Double, Bool);
292     scilab_fill_comparisonequal(ScalarDouble, ScalarInt8, S_S, Double, Int8, Bool);
293     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, Bool);
294     scilab_fill_comparisonequal(ScalarDouble, ScalarInt16, S_S, Double, Int16, Bool);
295     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, Bool);
296     scilab_fill_comparisonequal(ScalarDouble, ScalarInt32, S_S, Double, Int32, Bool);
297     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, Bool);
298     scilab_fill_comparisonequal(ScalarDouble, ScalarInt64, S_S, Double, Int64, Bool);
299     scilab_fill_comparisonequal(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, Bool);
300     scilab_fill_comparisonequal(ScalarDouble, ScalarBool, M_E, Double, Bool, Bool);
301     scilab_fill_comparisonequal(ScalarDouble, ScalarPolynom, M_P, Double, Polynom, Bool);
302
303     //Scalar == Scalar Complex
304     scilab_fill_comparisonequal(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Bool);
305     scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
306     scilab_fill_comparisonequal(ScalarDouble, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
307
308     //Scalar == Empty
309     scilab_fill_comparisonequal(ScalarDouble, Empty, M_E, Double, Double, Bool);
310
311     //Scalar Complex == Matrix
312     scilab_fill_comparisonequal(ScalarDoubleComplex, Double, SC_M, Double, Double, Bool);
313     scilab_fill_comparisonequal(ScalarDoubleComplex, Polynom, M_P, Double, Polynom, Bool);
314     scilab_fill_comparisonequal(ScalarDoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
315     //Scalar Complex == Matrix Complex
316     scilab_fill_comparisonequal(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Bool);
317     scilab_fill_comparisonequal(ScalarDoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
318     scilab_fill_comparisonequal(ScalarDoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
319     //Scalar Complex == Scalar
320     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Bool);
321     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
322     //Scalar Complex == Scalar Complex
323     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Bool);
324     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
325     //Scalar Complex == Empty
326     scilab_fill_comparisonequal(ScalarDoubleComplex, Empty, M_E, Double, Double, Bool);
327
328     //Empty == Matrix
329     scilab_fill_comparisonequal(Empty, Double, E_M, Double, Double, Bool);
330     scilab_fill_comparisonequal(Empty, Int8, E_M, Double, Int8, Bool);
331     scilab_fill_comparisonequal(Empty, UInt8, E_M, Double, UInt8, Bool);
332     scilab_fill_comparisonequal(Empty, Int16, E_M, Double, Int16, Bool);
333     scilab_fill_comparisonequal(Empty, UInt16, E_M, Double, UInt16, Bool);
334     scilab_fill_comparisonequal(Empty, Int32, E_M, Double, Int32, Bool);
335     scilab_fill_comparisonequal(Empty, UInt32, E_M, Double, UInt32, Bool);
336     scilab_fill_comparisonequal(Empty, Int64, E_M, Double, Int64, Bool);
337     scilab_fill_comparisonequal(Empty, UInt64, E_M, Double, UInt64, Bool);
338
339     scilab_fill_comparisonequal(Empty, Polynom, E_M, Double, Polynom, Bool);
340     scilab_fill_comparisonequal(Empty, PolynomComplex, E_M, Double, Polynom, Bool);
341     scilab_fill_comparisonequal(Empty, Sparse, E_M, Double, Sparse, Bool);
342     scilab_fill_comparisonequal(Empty, SparseComplex, E_M, Double, Sparse, Bool);
343
344     //Empty == Matrix Complex
345     scilab_fill_comparisonequal(Empty, DoubleComplex, E_M, Double, Double, Bool);
346     //Empty == Scalar
347     scilab_fill_comparisonequal(Empty, ScalarDouble, E_M, Double, Double, Bool);
348     scilab_fill_comparisonequal(Empty, ScalarInt8, E_M, Double, Int8, Bool);
349     scilab_fill_comparisonequal(Empty, ScalarUInt8, E_M, Double, UInt8, Bool);
350     scilab_fill_comparisonequal(Empty, ScalarInt16, E_M, Double, Int16, Bool);
351     scilab_fill_comparisonequal(Empty, ScalarUInt16, E_M, Double, UInt16, Bool);
352     scilab_fill_comparisonequal(Empty, ScalarInt32, E_M, Double, Int32, Bool);
353     scilab_fill_comparisonequal(Empty, ScalarUInt32, E_M, Double, UInt32, Bool);
354     scilab_fill_comparisonequal(Empty, ScalarInt64, E_M, Double, Int64, Bool);
355     scilab_fill_comparisonequal(Empty, ScalarUInt64, E_M, Double, UInt64, Bool);
356     scilab_fill_comparisonequal(Empty, ScalarBool, E_M, Double, Bool, Bool);
357     scilab_fill_comparisonequal(Empty, ScalarPolynom, E_M, Double, Polynom, Bool);
358
359     //Empty == Scalar Complex
360     scilab_fill_comparisonequal(Empty, ScalarDoubleComplex, E_M, Double, Double, Bool);
361     scilab_fill_comparisonequal(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Bool);
362     //Empty == Empty
363     scilab_fill_comparisonequal(Empty, Empty, E_E, Double, Double, Bool);
364     //Empty == eye
365     scilab_fill_comparisonequal(Empty, Identity, E_M, Double, Double, Bool);
366     scilab_fill_comparisonequal(Empty, IdentityComplex, E_M, Double, Double, Bool);
367
368     //Matrix == Identity
369     scilab_fill_comparisonequal(Double, Identity, M_I, Double, Double, Bool);
370     scilab_fill_comparisonequal(Double, IdentityComplex, M_IC, Double, Double, Bool);
371     scilab_fill_comparisonequal(DoubleComplex, Identity, MC_I, Double, Double, Bool);
372     scilab_fill_comparisonequal(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Bool);
373     scilab_fill_comparisonequal(ScalarDouble, Identity, S_I, Double, Double, Bool);
374     scilab_fill_comparisonequal(ScalarDouble, IdentityComplex, S_IC, Double, Double, Bool);
375     scilab_fill_comparisonequal(ScalarDoubleComplex, Identity, SC_I, Double, Double, Bool);
376     scilab_fill_comparisonequal(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Bool);
377
378     //Int8
379     //Matrix == Matrix
380     scilab_fill_comparisonequal(Int8, Double, M_M, Int8, Double, Bool);
381     scilab_fill_comparisonequal(Int8, Int8, M_M, Int8, Int8, Bool);
382     scilab_fill_comparisonequal(Int8, UInt8, M_M, Int8, UInt8, Bool);
383     scilab_fill_comparisonequal(Int8, Int16, M_M, Int8, Int16, Bool);
384     scilab_fill_comparisonequal(Int8, UInt16, M_M, Int8, UInt16, Bool);
385     scilab_fill_comparisonequal(Int8, Int32, M_M, Int8, Int32, Bool);
386     scilab_fill_comparisonequal(Int8, UInt32, M_M, Int8, UInt32, Bool);
387     scilab_fill_comparisonequal(Int8, Int64, M_M, Int8, Int64, Bool);
388     scilab_fill_comparisonequal(Int8, UInt64, M_M, Int8, UInt64, Bool);
389     scilab_fill_comparisonequal(Int8, Bool, M_B, Int8, Bool, Bool);
390     scilab_fill_comparisonequal(Int8, Empty, M_E, Int8, Double, Bool);
391
392     //Matrix == Scalar
393     scilab_fill_comparisonequal(Int8, ScalarDouble, M_S, Int8, Double, Bool);
394     scilab_fill_comparisonequal(Int8, ScalarInt8, M_S, Int8, Int8, Bool);
395     scilab_fill_comparisonequal(Int8, ScalarUInt8, M_S, Int8, UInt8, Bool);
396     scilab_fill_comparisonequal(Int8, ScalarInt16, M_S, Int8, Int16, Bool);
397     scilab_fill_comparisonequal(Int8, ScalarUInt16, M_S, Int8, UInt16, Bool);
398     scilab_fill_comparisonequal(Int8, ScalarInt32, M_S, Int8, Int32, Bool);
399     scilab_fill_comparisonequal(Int8, ScalarUInt32, M_S, Int8, UInt32, Bool);
400     scilab_fill_comparisonequal(Int8, ScalarInt64, M_S, Int8, Int64, Bool);
401     scilab_fill_comparisonequal(Int8, ScalarUInt64, M_S, Int8, UInt64, Bool);
402     scilab_fill_comparisonequal(Int8, ScalarBool, M_B, Int8, Bool, Bool);
403
404     //Scalar == Matrix
405     scilab_fill_comparisonequal(ScalarInt8, Double, S_M, Int8, Double, Bool);
406     scilab_fill_comparisonequal(ScalarInt8, Int8, S_M, Int8, Int8, Bool);
407     scilab_fill_comparisonequal(ScalarInt8, UInt8, S_M, Int8, UInt8, Bool);
408     scilab_fill_comparisonequal(ScalarInt8, Int16, S_M, Int8, Int16, Bool);
409     scilab_fill_comparisonequal(ScalarInt8, UInt16, S_M, Int8, UInt16, Bool);
410     scilab_fill_comparisonequal(ScalarInt8, Int32, S_M, Int8, Int32, Bool);
411     scilab_fill_comparisonequal(ScalarInt8, UInt32, S_M, Int8, UInt32, Bool);
412     scilab_fill_comparisonequal(ScalarInt8, Int64, S_M, Int8, Int64, Bool);
413     scilab_fill_comparisonequal(ScalarInt8, UInt64, S_M, Int8, UInt64, Bool);
414     scilab_fill_comparisonequal(ScalarInt8, Bool, S_B, Int8, Bool, Bool);
415     scilab_fill_comparisonequal(ScalarInt8, Empty, M_E, Int8, Double, Bool);
416
417     //Scalar == Scalar
418     scilab_fill_comparisonequal(ScalarInt8, ScalarDouble, S_S, Int8, Double, Bool);
419     scilab_fill_comparisonequal(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Bool);
420     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, Bool);
421     scilab_fill_comparisonequal(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Bool);
422     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, Bool);
423     scilab_fill_comparisonequal(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Bool);
424     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, Bool);
425     scilab_fill_comparisonequal(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Bool);
426     scilab_fill_comparisonequal(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, Bool);
427     scilab_fill_comparisonequal(ScalarInt8, ScalarBool, M_E, Int8, Bool, Bool);
428
429     //UInt8
430     //Matrix == Matrix
431     scilab_fill_comparisonequal(UInt8, Double, M_M, UInt8, Double, Bool);
432     scilab_fill_comparisonequal(UInt8, Int8, M_M, UInt8, Int8, Bool);
433     scilab_fill_comparisonequal(UInt8, UInt8, M_M, UInt8, UInt8, Bool);
434     scilab_fill_comparisonequal(UInt8, Int16, M_M, UInt8, Int16, Bool);
435     scilab_fill_comparisonequal(UInt8, UInt16, M_M, UInt8, UInt16, Bool);
436     scilab_fill_comparisonequal(UInt8, Int32, M_M, UInt8, Int32, Bool);
437     scilab_fill_comparisonequal(UInt8, UInt32, M_M, UInt8, UInt32, Bool);
438     scilab_fill_comparisonequal(UInt8, Int64, M_M, UInt8, Int64, Bool);
439     scilab_fill_comparisonequal(UInt8, UInt64, M_M, UInt8, UInt64, Bool);
440     scilab_fill_comparisonequal(UInt8, Bool, M_B, UInt8, Bool, Bool);
441     scilab_fill_comparisonequal(UInt8, Empty, M_E, UInt8, Double, Bool);
442
443     //Matrix == Scalar
444     scilab_fill_comparisonequal(UInt8, ScalarDouble, M_S, UInt8, Double, Bool);
445     scilab_fill_comparisonequal(UInt8, ScalarInt8, M_S, UInt8, Int8, Bool);
446     scilab_fill_comparisonequal(UInt8, ScalarUInt8, M_S, UInt8, UInt8, Bool);
447     scilab_fill_comparisonequal(UInt8, ScalarInt16, M_S, UInt8, Int16, Bool);
448     scilab_fill_comparisonequal(UInt8, ScalarUInt16, M_S, UInt8, UInt16, Bool);
449     scilab_fill_comparisonequal(UInt8, ScalarInt32, M_S, UInt8, Int32, Bool);
450     scilab_fill_comparisonequal(UInt8, ScalarUInt32, M_S, UInt8, UInt32, Bool);
451     scilab_fill_comparisonequal(UInt8, ScalarInt64, M_S, UInt8, Int64, Bool);
452     scilab_fill_comparisonequal(UInt8, ScalarUInt64, M_S, UInt8, UInt64, Bool);
453     scilab_fill_comparisonequal(UInt8, ScalarBool, M_B, UInt8, Bool, Bool);
454
455     //Scalar == Matrix
456     scilab_fill_comparisonequal(ScalarUInt8, Double, S_M, UInt8, Double, Bool);
457     scilab_fill_comparisonequal(ScalarUInt8, Int8, S_M, UInt8, Int8, Bool);
458     scilab_fill_comparisonequal(ScalarUInt8, UInt8, S_M, UInt8, UInt8, Bool);
459     scilab_fill_comparisonequal(ScalarUInt8, Int16, S_M, UInt8, Int16, Bool);
460     scilab_fill_comparisonequal(ScalarUInt8, UInt16, S_M, UInt8, UInt16, Bool);
461     scilab_fill_comparisonequal(ScalarUInt8, Int32, S_M, UInt8, Int32, Bool);
462     scilab_fill_comparisonequal(ScalarUInt8, UInt32, S_M, UInt8, UInt32, Bool);
463     scilab_fill_comparisonequal(ScalarUInt8, Int64, S_M, UInt8, Int64, Bool);
464     scilab_fill_comparisonequal(ScalarUInt8, UInt64, S_M, UInt8, UInt64, Bool);
465     scilab_fill_comparisonequal(ScalarUInt8, Bool, S_B, UInt8, Bool, Bool);
466     scilab_fill_comparisonequal(ScalarUInt8, Empty, M_E, UInt8, Double, Bool);
467
468     //Scalar == Scalar
469     scilab_fill_comparisonequal(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, Bool);
470     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, Bool);
471     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, Bool);
472     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, Bool);
473     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, Bool);
474     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, Bool);
475     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, Bool);
476     scilab_fill_comparisonequal(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, Bool);
477     scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, Bool);
478     scilab_fill_comparisonequal(ScalarUInt8, ScalarBool, M_E, UInt8, Bool, Bool);
479
480     //Int16
481     //Matrix == Matrix
482     scilab_fill_comparisonequal(Int16, Double, M_M, Int16, Double, Bool);
483     scilab_fill_comparisonequal(Int16, Int8, M_M, Int16, Int8, Bool);
484     scilab_fill_comparisonequal(Int16, UInt8, M_M, Int16, UInt8, Bool);
485     scilab_fill_comparisonequal(Int16, Int16, M_M, Int16, Int16, Bool);
486     scilab_fill_comparisonequal(Int16, UInt16, M_M, Int16, UInt16, Bool);
487     scilab_fill_comparisonequal(Int16, Int32, M_M, Int16, Int32, Bool);
488     scilab_fill_comparisonequal(Int16, UInt32, M_M, Int16, UInt32, Bool);
489     scilab_fill_comparisonequal(Int16, Int64, M_M, Int16, Int64, Bool);
490     scilab_fill_comparisonequal(Int16, UInt64, M_M, Int16, UInt64, Bool);
491     scilab_fill_comparisonequal(Int16, Bool, M_B, Int16, Bool, Bool);
492     scilab_fill_comparisonequal(Int16, Empty, M_E, Int16, Double, Bool);
493
494     //Matrix == Scalar
495     scilab_fill_comparisonequal(Int16, ScalarDouble, M_S, Int16, Double, Bool);
496     scilab_fill_comparisonequal(Int16, ScalarInt8, M_S, Int16, Int8, Bool);
497     scilab_fill_comparisonequal(Int16, ScalarUInt8, M_S, Int16, UInt8, Bool);
498     scilab_fill_comparisonequal(Int16, ScalarInt16, M_S, Int16, Int16, Bool);
499     scilab_fill_comparisonequal(Int16, ScalarUInt16, M_S, Int16, UInt16, Bool);
500     scilab_fill_comparisonequal(Int16, ScalarInt32, M_S, Int16, Int32, Bool);
501     scilab_fill_comparisonequal(Int16, ScalarUInt32, M_S, Int16, UInt32, Bool);
502     scilab_fill_comparisonequal(Int16, ScalarInt64, M_S, Int16, Int64, Bool);
503     scilab_fill_comparisonequal(Int16, ScalarUInt64, M_S, Int16, UInt64, Bool);
504     scilab_fill_comparisonequal(Int16, ScalarBool, M_B, Int16, Bool, Bool);
505
506     //Scalar == Matrix
507     scilab_fill_comparisonequal(ScalarInt16, Double, S_M, Int16, Double, Bool);
508     scilab_fill_comparisonequal(ScalarInt16, Int8, S_M, Int16, Int8, Bool);
509     scilab_fill_comparisonequal(ScalarInt16, UInt8, S_M, Int16, UInt8, Bool);
510     scilab_fill_comparisonequal(ScalarInt16, Int16, S_M, Int16, Int16, Bool);
511     scilab_fill_comparisonequal(ScalarInt16, UInt16, S_M, Int16, UInt16, Bool);
512     scilab_fill_comparisonequal(ScalarInt16, Int32, S_M, Int16, Int32, Bool);
513     scilab_fill_comparisonequal(ScalarInt16, UInt32, S_M, Int16, UInt32, Bool);
514     scilab_fill_comparisonequal(ScalarInt16, Int64, S_M, Int16, Int64, Bool);
515     scilab_fill_comparisonequal(ScalarInt16, UInt64, S_M, Int16, UInt64, Bool);
516     scilab_fill_comparisonequal(ScalarInt16, Bool, S_B, Int16, Bool, Bool);
517     scilab_fill_comparisonequal(ScalarInt16, Empty, M_E, Int16, Double, Bool);
518
519     //Scalar == Scalar
520     scilab_fill_comparisonequal(ScalarInt16, ScalarDouble, S_S, Int16, Double, Bool);
521     scilab_fill_comparisonequal(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Bool);
522     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, Bool);
523     scilab_fill_comparisonequal(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Bool);
524     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, Bool);
525     scilab_fill_comparisonequal(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Bool);
526     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, Bool);
527     scilab_fill_comparisonequal(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Bool);
528     scilab_fill_comparisonequal(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, Bool);
529     scilab_fill_comparisonequal(ScalarInt16, ScalarBool, M_E, Int16, Bool, Bool);
530
531     //UInt16
532     //Matrix == Matrix
533     scilab_fill_comparisonequal(UInt16, Double, M_M, UInt16, Double, Bool);
534     scilab_fill_comparisonequal(UInt16, Int8, M_M, UInt16, Int8, Bool);
535     scilab_fill_comparisonequal(UInt16, UInt8, M_M, UInt16, UInt8, Bool);
536     scilab_fill_comparisonequal(UInt16, Int16, M_M, UInt16, Int16, Bool);
537     scilab_fill_comparisonequal(UInt16, UInt16, M_M, UInt16, UInt16, Bool);
538     scilab_fill_comparisonequal(UInt16, Int32, M_M, UInt16, Int32, Bool);
539     scilab_fill_comparisonequal(UInt16, UInt32, M_M, UInt16, UInt32, Bool);
540     scilab_fill_comparisonequal(UInt16, Int64, M_M, UInt16, Int64, Bool);
541     scilab_fill_comparisonequal(UInt16, UInt64, M_M, UInt16, UInt64, Bool);
542     scilab_fill_comparisonequal(UInt16, Bool, M_B, UInt16, Bool, Bool);
543     scilab_fill_comparisonequal(UInt16, Empty, M_E, UInt16, Double, Bool);
544
545     //Matrix == Scalar
546     scilab_fill_comparisonequal(UInt16, ScalarDouble, M_S, UInt16, Double, Bool);
547     scilab_fill_comparisonequal(UInt16, ScalarInt8, M_S, UInt16, Int8, Bool);
548     scilab_fill_comparisonequal(UInt16, ScalarUInt8, M_S, UInt16, UInt8, Bool);
549     scilab_fill_comparisonequal(UInt16, ScalarInt16, M_S, UInt16, Int16, Bool);
550     scilab_fill_comparisonequal(UInt16, ScalarUInt16, M_S, UInt16, UInt16, Bool);
551     scilab_fill_comparisonequal(UInt16, ScalarInt32, M_S, UInt16, Int32, Bool);
552     scilab_fill_comparisonequal(UInt16, ScalarUInt32, M_S, UInt16, UInt32, Bool);
553     scilab_fill_comparisonequal(UInt16, ScalarInt64, M_S, UInt16, Int64, Bool);
554     scilab_fill_comparisonequal(UInt16, ScalarUInt64, M_S, UInt16, UInt64, Bool);
555     scilab_fill_comparisonequal(UInt16, ScalarBool, M_B, UInt16, Bool, Bool);
556
557     //Scalar == Matrix
558     scilab_fill_comparisonequal(ScalarUInt16, Double, S_M, UInt16, Double, Bool);
559     scilab_fill_comparisonequal(ScalarUInt16, Int8, S_M, UInt16, Int8, Bool);
560     scilab_fill_comparisonequal(ScalarUInt16, UInt8, S_M, UInt16, UInt8, Bool);
561     scilab_fill_comparisonequal(ScalarUInt16, Int16, S_M, UInt16, Int16, Bool);
562     scilab_fill_comparisonequal(ScalarUInt16, UInt16, S_M, UInt16, UInt16, Bool);
563     scilab_fill_comparisonequal(ScalarUInt16, Int32, S_M, UInt16, Int32, Bool);
564     scilab_fill_comparisonequal(ScalarUInt16, UInt32, S_M, UInt16, UInt32, Bool);
565     scilab_fill_comparisonequal(ScalarUInt16, Int64, S_M, UInt16, Int64, Bool);
566     scilab_fill_comparisonequal(ScalarUInt16, UInt64, S_M, UInt16, UInt64, Bool);
567     scilab_fill_comparisonequal(ScalarUInt16, Bool, S_B, UInt16, Bool, Bool);
568     scilab_fill_comparisonequal(ScalarUInt16, Empty, M_E, UInt16, Double, Bool);
569
570     //Scalar == Scalar
571     scilab_fill_comparisonequal(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, Bool);
572     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, Bool);
573     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, Bool);
574     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, Bool);
575     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, Bool);
576     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, Bool);
577     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, Bool);
578     scilab_fill_comparisonequal(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, Bool);
579     scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, Bool);
580     scilab_fill_comparisonequal(ScalarUInt16, ScalarBool, M_E, UInt16, Bool, Bool);
581
582     //Int32
583     //Matrix == Matrix
584     scilab_fill_comparisonequal(Int32, Double, M_M, Int32, Double, Bool);
585     scilab_fill_comparisonequal(Int32, Int8, M_M, Int32, Int8, Bool);
586     scilab_fill_comparisonequal(Int32, UInt8, M_M, Int32, UInt8, Bool);
587     scilab_fill_comparisonequal(Int32, Int16, M_M, Int32, Int16, Bool);
588     scilab_fill_comparisonequal(Int32, UInt16, M_M, Int32, UInt16, Bool);
589     scilab_fill_comparisonequal(Int32, Int32, M_M, Int32, Int32, Bool);
590     scilab_fill_comparisonequal(Int32, UInt32, M_M, Int32, UInt32, Bool);
591     scilab_fill_comparisonequal(Int32, Int64, M_M, Int32, Int64, Bool);
592     scilab_fill_comparisonequal(Int32, UInt64, M_M, Int32, UInt64, Bool);
593     scilab_fill_comparisonequal(Int32, Bool, M_B, Int32, Bool, Bool);
594     scilab_fill_comparisonequal(Int32, Empty, M_E, Int32, Double, Bool);
595
596     //Matrix == Scalar
597     scilab_fill_comparisonequal(Int32, ScalarDouble, M_S, Int32, Double, Bool);
598     scilab_fill_comparisonequal(Int32, ScalarInt8, M_S, Int32, Int8, Bool);
599     scilab_fill_comparisonequal(Int32, ScalarUInt8, M_S, Int32, UInt8, Bool);
600     scilab_fill_comparisonequal(Int32, ScalarInt16, M_S, Int32, Int16, Bool);
601     scilab_fill_comparisonequal(Int32, ScalarUInt16, M_S, Int32, UInt16, Bool);
602     scilab_fill_comparisonequal(Int32, ScalarInt32, M_S, Int32, Int32, Bool);
603     scilab_fill_comparisonequal(Int32, ScalarUInt32, M_S, Int32, UInt32, Bool);
604     scilab_fill_comparisonequal(Int32, ScalarInt64, M_S, Int32, Int64, Bool);
605     scilab_fill_comparisonequal(Int32, ScalarUInt64, M_S, Int32, UInt64, Bool);
606     scilab_fill_comparisonequal(Int32, ScalarBool, M_B, Int32, Bool, Bool);
607
608     //Scalar == Matrix
609     scilab_fill_comparisonequal(ScalarInt32, Double, S_M, Int32, Double, Bool);
610     scilab_fill_comparisonequal(ScalarInt32, Int8, S_M, Int32, Int8, Bool);
611     scilab_fill_comparisonequal(ScalarInt32, UInt8, S_M, Int32, UInt8, Bool);
612     scilab_fill_comparisonequal(ScalarInt32, Int16, S_M, Int32, Int16, Bool);
613     scilab_fill_comparisonequal(ScalarInt32, UInt16, S_M, Int32, UInt16, Bool);
614     scilab_fill_comparisonequal(ScalarInt32, Int32, S_M, Int32, Int32, Bool);
615     scilab_fill_comparisonequal(ScalarInt32, UInt32, S_M, Int32, UInt32, Bool);
616     scilab_fill_comparisonequal(ScalarInt32, Int64, S_M, Int32, Int64, Bool);
617     scilab_fill_comparisonequal(ScalarInt32, UInt64, S_M, Int32, UInt64, Bool);
618     scilab_fill_comparisonequal(ScalarInt32, Bool, S_B, Int32, Bool, Bool);
619     scilab_fill_comparisonequal(ScalarInt32, Empty, M_E, Int32, Double, Bool);
620
621     //Scalar == Scalar
622     scilab_fill_comparisonequal(ScalarInt32, ScalarDouble, S_S, Int32, Double, Bool);
623     scilab_fill_comparisonequal(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Bool);
624     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, Bool);
625     scilab_fill_comparisonequal(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Bool);
626     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, Bool);
627     scilab_fill_comparisonequal(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Bool);
628     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, Bool);
629     scilab_fill_comparisonequal(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Bool);
630     scilab_fill_comparisonequal(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, Bool);
631     scilab_fill_comparisonequal(ScalarInt32, ScalarBool, M_E, Int32, Bool, Bool);
632
633     //UInt32
634     //Matrix == Matrix
635     scilab_fill_comparisonequal(UInt32, Double, M_M, UInt32, Double, Bool);
636     scilab_fill_comparisonequal(UInt32, Int8, M_M, UInt32, Int8, Bool);
637     scilab_fill_comparisonequal(UInt32, UInt8, M_M, UInt32, UInt8, Bool);
638     scilab_fill_comparisonequal(UInt32, Int16, M_M, UInt32, Int16, Bool);
639     scilab_fill_comparisonequal(UInt32, UInt16, M_M, UInt32, UInt16, Bool);
640     scilab_fill_comparisonequal(UInt32, Int32, M_M, UInt32, Int32, Bool);
641     scilab_fill_comparisonequal(UInt32, UInt32, M_M, UInt32, UInt32, Bool);
642     scilab_fill_comparisonequal(UInt32, Int64, M_M, UInt32, Int64, Bool);
643     scilab_fill_comparisonequal(UInt32, UInt64, M_M, UInt32, UInt64, Bool);
644     scilab_fill_comparisonequal(UInt32, Bool, M_B, UInt32, Bool, Bool);
645     scilab_fill_comparisonequal(UInt32, Empty, M_E, UInt32, Double, Bool);
646
647     //Matrix == Scalar
648     scilab_fill_comparisonequal(UInt32, ScalarDouble, M_S, UInt32, Double, Bool);
649     scilab_fill_comparisonequal(UInt32, ScalarInt8, M_S, UInt32, Int8, Bool);
650     scilab_fill_comparisonequal(UInt32, ScalarUInt8, M_S, UInt32, UInt8, Bool);
651     scilab_fill_comparisonequal(UInt32, ScalarInt16, M_S, UInt32, Int16, Bool);
652     scilab_fill_comparisonequal(UInt32, ScalarUInt16, M_S, UInt32, UInt16, Bool);
653     scilab_fill_comparisonequal(UInt32, ScalarInt32, M_S, UInt32, Int32, Bool);
654     scilab_fill_comparisonequal(UInt32, ScalarUInt32, M_S, UInt32, UInt32, Bool);
655     scilab_fill_comparisonequal(UInt32, ScalarInt64, M_S, UInt32, Int64, Bool);
656     scilab_fill_comparisonequal(UInt32, ScalarUInt64, M_S, UInt32, UInt64, Bool);
657     scilab_fill_comparisonequal(UInt32, ScalarBool, M_B, UInt32, Bool, Bool);
658
659     //Scalar == Matrix
660     scilab_fill_comparisonequal(ScalarUInt32, Double, S_M, UInt32, Double, Bool);
661     scilab_fill_comparisonequal(ScalarUInt32, Int8, S_M, UInt32, Int8, Bool);
662     scilab_fill_comparisonequal(ScalarUInt32, UInt8, S_M, UInt32, UInt8, Bool);
663     scilab_fill_comparisonequal(ScalarUInt32, Int16, S_M, UInt32, Int16, Bool);
664     scilab_fill_comparisonequal(ScalarUInt32, UInt16, S_M, UInt32, UInt16, Bool);
665     scilab_fill_comparisonequal(ScalarUInt32, Int32, S_M, UInt32, Int32, Bool);
666     scilab_fill_comparisonequal(ScalarUInt32, UInt32, S_M, UInt32, UInt32, Bool);
667     scilab_fill_comparisonequal(ScalarUInt32, Int64, S_M, UInt32, Int64, Bool);
668     scilab_fill_comparisonequal(ScalarUInt32, UInt64, S_M, UInt32, UInt64, Bool);
669     scilab_fill_comparisonequal(ScalarUInt32, Bool, S_B, UInt32, Bool, Bool);
670     scilab_fill_comparisonequal(ScalarUInt32, Empty, M_E, UInt32, Double, Bool);
671
672     //Scalar == Scalar
673     scilab_fill_comparisonequal(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, Bool);
674     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, Bool);
675     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, Bool);
676     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, Bool);
677     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, Bool);
678     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, Bool);
679     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, Bool);
680     scilab_fill_comparisonequal(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, Bool);
681     scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, Bool);
682     scilab_fill_comparisonequal(ScalarUInt32, ScalarBool, M_E, UInt32, Bool, Bool);
683
684     //Int64
685     //Matrix == Matrix
686     scilab_fill_comparisonequal(Int64, Double, M_M, Int64, Double, Bool);
687     scilab_fill_comparisonequal(Int64, Int8, M_M, Int64, Int8, Bool);
688     scilab_fill_comparisonequal(Int64, UInt8, M_M, Int64, UInt8, Bool);
689     scilab_fill_comparisonequal(Int64, Int16, M_M, Int64, Int16, Bool);
690     scilab_fill_comparisonequal(Int64, UInt16, M_M, Int64, UInt16, Bool);
691     scilab_fill_comparisonequal(Int64, Int32, M_M, Int64, Int32, Bool);
692     scilab_fill_comparisonequal(Int64, UInt32, M_M, Int64, UInt32, Bool);
693     scilab_fill_comparisonequal(Int64, Int64, M_M, Int64, Int64, Bool);
694     scilab_fill_comparisonequal(Int64, UInt64, M_M, Int64, UInt64, Bool);
695     scilab_fill_comparisonequal(Int64, Bool, M_B, Int64, Bool, Bool);
696     scilab_fill_comparisonequal(Int64, Empty, M_E, Int64, Double, Bool);
697
698     //Matrix == Scalar
699     scilab_fill_comparisonequal(Int64, ScalarDouble, M_S, Int64, Double, Bool);
700     scilab_fill_comparisonequal(Int64, ScalarInt8, M_S, Int64, Int8, Bool);
701     scilab_fill_comparisonequal(Int64, ScalarUInt8, M_S, Int64, UInt8, Bool);
702     scilab_fill_comparisonequal(Int64, ScalarInt16, M_S, Int64, Int16, Bool);
703     scilab_fill_comparisonequal(Int64, ScalarUInt16, M_S, Int64, UInt16, Bool);
704     scilab_fill_comparisonequal(Int64, ScalarInt32, M_S, Int64, Int32, Bool);
705     scilab_fill_comparisonequal(Int64, ScalarUInt32, M_S, Int64, UInt32, Bool);
706     scilab_fill_comparisonequal(Int64, ScalarInt64, M_S, Int64, Int64, Bool);
707     scilab_fill_comparisonequal(Int64, ScalarUInt64, M_S, Int64, UInt64, Bool);
708     scilab_fill_comparisonequal(Int64, ScalarBool, M_B, Int64, Bool, Bool);
709
710     //Scalar == Matrix
711     scilab_fill_comparisonequal(ScalarInt64, Double, S_M, Int64, Double, Bool);
712     scilab_fill_comparisonequal(ScalarInt64, Int8, S_M, Int64, Int8, Bool);
713     scilab_fill_comparisonequal(ScalarInt64, UInt8, S_M, Int64, UInt8, Bool);
714     scilab_fill_comparisonequal(ScalarInt64, Int16, S_M, Int64, Int16, Bool);
715     scilab_fill_comparisonequal(ScalarInt64, UInt16, S_M, Int64, UInt16, Bool);
716     scilab_fill_comparisonequal(ScalarInt64, Int32, S_M, Int64, Int32, Bool);
717     scilab_fill_comparisonequal(ScalarInt64, UInt32, S_M, Int64, UInt32, Bool);
718     scilab_fill_comparisonequal(ScalarInt64, Int64, S_M, Int64, Int64, Bool);
719     scilab_fill_comparisonequal(ScalarInt64, UInt64, S_M, Int64, UInt64, Bool);
720     scilab_fill_comparisonequal(ScalarInt64, Bool, S_B, Int64, Bool, Bool);
721     scilab_fill_comparisonequal(ScalarInt64, Empty, M_E, Int64, Double, Bool);
722
723     //Scalar == Scalar
724     scilab_fill_comparisonequal(ScalarInt64, ScalarDouble, S_S, Int64, Double, Bool);
725     scilab_fill_comparisonequal(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Bool);
726     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, Bool);
727     scilab_fill_comparisonequal(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Bool);
728     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, Bool);
729     scilab_fill_comparisonequal(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Bool);
730     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, Bool);
731     scilab_fill_comparisonequal(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Bool);
732     scilab_fill_comparisonequal(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, Bool);
733     scilab_fill_comparisonequal(ScalarInt64, ScalarBool, M_E, Int64, Bool, Bool);
734
735     //UInt64
736     //Matrix == Matrix
737     scilab_fill_comparisonequal(UInt64, Double, M_M, UInt64, Double, Bool);
738     scilab_fill_comparisonequal(UInt64, Int8, M_M, UInt64, Int8, Bool);
739     scilab_fill_comparisonequal(UInt64, UInt8, M_M, UInt64, UInt8, Bool);
740     scilab_fill_comparisonequal(UInt64, Int16, M_M, UInt64, Int16, Bool);
741     scilab_fill_comparisonequal(UInt64, UInt16, M_M, UInt64, UInt16, Bool);
742     scilab_fill_comparisonequal(UInt64, Int32, M_M, UInt64, Int32, Bool);
743     scilab_fill_comparisonequal(UInt64, UInt32, M_M, UInt64, UInt32, Bool);
744     scilab_fill_comparisonequal(UInt64, Int64, M_M, UInt64, Int64, Bool);
745     scilab_fill_comparisonequal(UInt64, UInt64, M_M, UInt64, UInt64, Bool);
746     scilab_fill_comparisonequal(UInt64, Bool, M_B, UInt64, Bool, Bool);
747     scilab_fill_comparisonequal(UInt64, Empty, M_E, UInt64, Double, Bool);
748
749     //Matrix == Scalar
750     scilab_fill_comparisonequal(UInt64, ScalarDouble, M_S, UInt64, Double, Bool);
751     scilab_fill_comparisonequal(UInt64, ScalarInt8, M_S, UInt64, Int8, Bool);
752     scilab_fill_comparisonequal(UInt64, ScalarUInt8, M_S, UInt64, UInt8, Bool);
753     scilab_fill_comparisonequal(UInt64, ScalarInt16, M_S, UInt64, Int16, Bool);
754     scilab_fill_comparisonequal(UInt64, ScalarUInt16, M_S, UInt64, UInt16, Bool);
755     scilab_fill_comparisonequal(UInt64, ScalarInt32, M_S, UInt64, Int32, Bool);
756     scilab_fill_comparisonequal(UInt64, ScalarUInt32, M_S, UInt64, UInt32, Bool);
757     scilab_fill_comparisonequal(UInt64, ScalarInt64, M_S, UInt64, Int64, Bool);
758     scilab_fill_comparisonequal(UInt64, ScalarUInt64, M_S, UInt64, UInt64, Bool);
759     scilab_fill_comparisonequal(UInt64, ScalarBool, M_B, UInt64, Bool, Bool);
760
761     //Scalar == Matrix
762     scilab_fill_comparisonequal(ScalarUInt64, Double, S_M, UInt64, Double, Bool);
763     scilab_fill_comparisonequal(ScalarUInt64, Int8, S_M, UInt64, Int8, Bool);
764     scilab_fill_comparisonequal(ScalarUInt64, UInt8, S_M, UInt64, UInt8, Bool);
765     scilab_fill_comparisonequal(ScalarUInt64, Int16, S_M, UInt64, Int16, Bool);
766     scilab_fill_comparisonequal(ScalarUInt64, UInt16, S_M, UInt64, UInt16, Bool);
767     scilab_fill_comparisonequal(ScalarUInt64, Int32, S_M, UInt64, Int32, Bool);
768     scilab_fill_comparisonequal(ScalarUInt64, UInt32, S_M, UInt64, UInt32, Bool);
769     scilab_fill_comparisonequal(ScalarUInt64, Int64, S_M, UInt64, Int64, Bool);
770     scilab_fill_comparisonequal(ScalarUInt64, UInt64, S_M, UInt64, UInt64, Bool);
771     scilab_fill_comparisonequal(ScalarUInt64, Bool, S_B, UInt64, Bool, Bool);
772     scilab_fill_comparisonequal(ScalarUInt64, Empty, M_E, UInt64, Double, Bool);
773
774     //Scalar == Scalar
775     scilab_fill_comparisonequal(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, Bool);
776     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, Bool);
777     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, Bool);
778     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, Bool);
779     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, Bool);
780     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, Bool);
781     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, Bool);
782     scilab_fill_comparisonequal(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, Bool);
783     scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, Bool);
784     scilab_fill_comparisonequal(ScalarUInt64, ScalarBool, M_E, UInt64, Bool, Bool);
785
786     //Bool
787     //Matrix == Matrix
788     scilab_fill_comparisonequal(Bool, Double, M_E, Bool, Double, Bool);
789     scilab_fill_comparisonequal(Bool, Int8, B_M, Bool, Int8, Bool);
790     scilab_fill_comparisonequal(Bool, UInt8, B_M, Bool, UInt8, Bool);
791     scilab_fill_comparisonequal(Bool, Int16, B_M, Bool, Int16, Bool);
792     scilab_fill_comparisonequal(Bool, UInt16, B_M, Bool, UInt16, Bool);
793     scilab_fill_comparisonequal(Bool, Int32, B_M, Bool, Int32, Bool);
794     scilab_fill_comparisonequal(Bool, UInt32, B_M, Bool, UInt32, Bool);
795     scilab_fill_comparisonequal(Bool, Int64, B_M, Bool, Int64, Bool);
796     scilab_fill_comparisonequal(Bool, UInt64, B_M, Bool, UInt64, Bool);
797     scilab_fill_comparisonequal(Bool, Bool, M_M, Bool, Bool, Bool);
798     scilab_fill_comparisonequal(Bool, Empty, M_E, Bool, Double, Bool);
799
800     //Matrix == Scalar
801     scilab_fill_comparisonequal(Bool, ScalarDouble, M_E, Bool, Double, Bool);
802     scilab_fill_comparisonequal(Bool, ScalarInt8, B_S, Bool, Int8, Bool);
803     scilab_fill_comparisonequal(Bool, ScalarUInt8, B_S, Bool, UInt8, Bool);
804     scilab_fill_comparisonequal(Bool, ScalarInt16, B_S, Bool, Int16, Bool);
805     scilab_fill_comparisonequal(Bool, ScalarUInt16, B_S, Bool, UInt16, Bool);
806     scilab_fill_comparisonequal(Bool, ScalarInt32, B_S, Bool, Int32, Bool);
807     scilab_fill_comparisonequal(Bool, ScalarUInt32, B_S, Bool, UInt32, Bool);
808     scilab_fill_comparisonequal(Bool, ScalarInt64, B_S, Bool, Int64, Bool);
809     scilab_fill_comparisonequal(Bool, ScalarUInt64, B_S, Bool, UInt64, Bool);
810     scilab_fill_comparisonequal(Bool, ScalarBool, M_S, Bool, Bool, Bool);
811
812     //Scalar == Matrix
813     scilab_fill_comparisonequal(ScalarBool, Double, M_E, Bool, Double, Bool);
814     scilab_fill_comparisonequal(ScalarBool, Int8, B_M, Bool, Int8, Bool);
815     scilab_fill_comparisonequal(ScalarBool, UInt8, B_M, Bool, UInt8, Bool);
816     scilab_fill_comparisonequal(ScalarBool, Int16, B_M, Bool, Int16, Bool);
817     scilab_fill_comparisonequal(ScalarBool, UInt16, B_M, Bool, UInt16, Bool);
818     scilab_fill_comparisonequal(ScalarBool, Int32, B_M, Bool, Int32, Bool);
819     scilab_fill_comparisonequal(ScalarBool, UInt32, B_M, Bool, UInt32, Bool);
820     scilab_fill_comparisonequal(ScalarBool, Int64, B_M, Bool, Int64, Bool);
821     scilab_fill_comparisonequal(ScalarBool, UInt64, B_M, Bool, UInt64, Bool);
822     scilab_fill_comparisonequal(ScalarBool, Bool, S_M, Bool, Bool, Bool);
823     scilab_fill_comparisonequal(ScalarBool, Empty, M_E, Bool, Double, Bool);
824
825     //Scalar == Scalar
826     scilab_fill_comparisonequal(ScalarBool, ScalarDouble, M_E, Bool, Double, Bool);
827     scilab_fill_comparisonequal(ScalarBool, ScalarInt8, M_E, Bool, Int8, Bool);
828     scilab_fill_comparisonequal(ScalarBool, ScalarUInt8, M_E, Bool, UInt8, Bool);
829     scilab_fill_comparisonequal(ScalarBool, ScalarInt16, M_E, Bool, Int16, Bool);
830     scilab_fill_comparisonequal(ScalarBool, ScalarUInt16, M_E, Bool, UInt16, Bool);
831     scilab_fill_comparisonequal(ScalarBool, ScalarInt32, M_E, Bool, Int32, Bool);
832     scilab_fill_comparisonequal(ScalarBool, ScalarUInt32, M_E, Bool, UInt32, Bool);
833     scilab_fill_comparisonequal(ScalarBool, ScalarInt64, M_E, Bool, Int64, Bool);
834     scilab_fill_comparisonequal(ScalarBool, ScalarUInt64, M_E, Bool, UInt64, Bool);
835     scilab_fill_comparisonequal(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
836
837     //Bool == Identity
838     scilab_fill_comparisonequal(Bool, Identity, M_E, Bool, Double, Bool);
839     scilab_fill_comparisonequal(Bool, IdentityComplex, M_E, Bool, Double, Bool);
840     scilab_fill_comparisonequal(ScalarBool, Identity, M_E, Bool, Double, Bool);
841     scilab_fill_comparisonequal(ScalarBool, IdentityComplex, M_E, Bool, Double, Bool);
842
843     //Bool == Polynom
844     scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
845     scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
846     scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
847     scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
848     scilab_fill_comparisonequal(ScalarBool, Polynom, M_E, Bool, Polynom, Bool);
849     scilab_fill_comparisonequal(ScalarBool, PolynomComplex, M_E, Bool, Polynom, Bool);
850     scilab_fill_comparisonequal(ScalarBool, ScalarPolynom, M_E, Bool, Polynom, Bool);
851     scilab_fill_comparisonequal(ScalarBool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
852
853     //Bool == Sparse
854     scilab_fill_comparisonequal(Bool, Sparse, M_E, Bool, Sparse, Bool);
855     scilab_fill_comparisonequal(Bool, SparseComplex, M_E, Bool, Sparse, Bool);
856     scilab_fill_comparisonequal(ScalarBool, Sparse, M_E, Bool, Sparse, Bool);
857     scilab_fill_comparisonequal(ScalarBool, SparseComplex, M_E, Bool, Sparse, Bool);
858
859     //Identity
860     scilab_fill_comparisonequal(Identity, Double, I_M, Double, Double, Bool);
861     scilab_fill_comparisonequal(Identity, DoubleComplex, I_MC, Double, Double, Bool);
862     scilab_fill_comparisonequal(Identity, ScalarDouble, I_S, Double, Double, Bool);
863     scilab_fill_comparisonequal(Identity, ScalarDoubleComplex, I_SC, Double, Double, Bool);
864     scilab_fill_comparisonequal(Identity, Identity, I_I, Double, Double, Bool);
865     scilab_fill_comparisonequal(Identity, IdentityComplex, I_IC, Double, Double, Bool);
866     scilab_fill_comparisonequal(Identity, Empty, M_E, Double, Double, Bool);
867
868     scilab_fill_comparisonequal(Identity, Polynom, M_P, Double, Polynom, Bool);
869     scilab_fill_comparisonequal(Identity, PolynomComplex, M_P, Double, Polynom, Bool);
870     scilab_fill_comparisonequal(Identity, ScalarPolynom, M_P, Double, Polynom, Bool);
871     scilab_fill_comparisonequal(Identity, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
872     scilab_fill_comparisonequal(Identity, Sparse, M_E, Double, Sparse, SparseBool);
873     scilab_fill_comparisonequal(Identity, SparseComplex, M_E, Double, Sparse, SparseBool);
874
875     scilab_fill_comparisonequal(IdentityComplex, Double, IC_M, Double, Double, Bool);
876     scilab_fill_comparisonequal(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Bool);
877     scilab_fill_comparisonequal(IdentityComplex, ScalarDouble, IC_S, Double, Double, Bool);
878     scilab_fill_comparisonequal(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Bool);
879     scilab_fill_comparisonequal(IdentityComplex, Identity, IC_I, Double, Double, Bool);
880     scilab_fill_comparisonequal(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Bool);
881     scilab_fill_comparisonequal(IdentityComplex, Empty, M_E, Double, Double, Bool);
882
883     scilab_fill_comparisonequal(IdentityComplex, Polynom, M_P, Double, Polynom, Bool);
884     scilab_fill_comparisonequal(IdentityComplex, PolynomComplex, M_P, Double, Polynom, Bool);
885     scilab_fill_comparisonequal(IdentityComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
886     scilab_fill_comparisonequal(IdentityComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
887     scilab_fill_comparisonequal(IdentityComplex, Sparse, M_E, Double, Sparse, SparseBool);
888     scilab_fill_comparisonequal(IdentityComplex, SparseComplex, M_E, Double, Sparse, SparseBool);
889
890     scilab_fill_comparisonequal(Identity, Bool, M_E, Double, Bool, Bool);
891     scilab_fill_comparisonequal(IdentityComplex, Bool, M_E, Double, Bool, Bool);
892     scilab_fill_comparisonequal(Identity, ScalarBool, M_E, Double, Bool, Bool);
893     scilab_fill_comparisonequal(IdentityComplex, ScalarBool, M_E, Double, Bool, Bool);
894
895     //Polynom
896
897     //poly == poly
898     scilab_fill_comparisonequal(Polynom, Polynom, M_M, Polynom, Polynom, Bool);
899     scilab_fill_comparisonequal(Polynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
900     scilab_fill_comparisonequal(PolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
901     scilab_fill_comparisonequal(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
902
903     //poly == scalar poly
904     scilab_fill_comparisonequal(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
905     scilab_fill_comparisonequal(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
906     scilab_fill_comparisonequal(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
907     scilab_fill_comparisonequal(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
908
909     //poly == double
910     scilab_fill_comparisonequal(Polynom, Double, P_M, Polynom, Double, Bool);
911     scilab_fill_comparisonequal(Polynom, DoubleComplex, P_M, Polynom, Double, Bool);
912     scilab_fill_comparisonequal(PolynomComplex, Double, P_M, Polynom, Double, Bool);
913     scilab_fill_comparisonequal(PolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
914
915     //poly == scalar double
916     scilab_fill_comparisonequal(Polynom, ScalarDouble, P_M, Polynom, Double, Bool);
917     scilab_fill_comparisonequal(Polynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
918     scilab_fill_comparisonequal(PolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
919     scilab_fill_comparisonequal(PolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
920
921     //poly == Bool
922     scilab_fill_comparisonequal(Polynom, Bool, E_M, Polynom, Bool, Bool);
923     scilab_fill_comparisonequal(Polynom, ScalarBool, E_M, Polynom, Bool, Bool);
924     scilab_fill_comparisonequal(PolynomComplex, Bool, E_M, Polynom, Bool, Bool);
925     scilab_fill_comparisonequal(PolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
926
927     //poly == []
928     scilab_fill_comparisonequal(Polynom, Empty, M_E, Polynom, Double, Bool);
929     scilab_fill_comparisonequal(PolynomComplex, Empty, M_E, Polynom, Double, Bool);
930
931     //poly == eye
932     scilab_fill_comparisonequal(Polynom, Identity, P_M, Polynom, Double, Bool);
933     scilab_fill_comparisonequal(Polynom, IdentityComplex, P_M, Polynom, Double, Bool);
934     scilab_fill_comparisonequal(PolynomComplex, Identity, P_M, Polynom, Double, Bool);
935     scilab_fill_comparisonequal(PolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
936
937     //scalar poly == poly
938     scilab_fill_comparisonequal(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Bool);
939     scilab_fill_comparisonequal(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
940     scilab_fill_comparisonequal(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
941     scilab_fill_comparisonequal(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
942
943     //scalar poly == scalar poly
944     scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
945     scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
946     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
947     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
948
949     //scalar poly == double
950     scilab_fill_comparisonequal(ScalarPolynom, Double, P_M, Polynom, Double, Bool);
951     scilab_fill_comparisonequal(ScalarPolynom, DoubleComplex, P_M, Polynom, Double, Bool);
952     scilab_fill_comparisonequal(ScalarPolynomComplex, Double, P_M, Polynom, Double, Bool);
953     scilab_fill_comparisonequal(ScalarPolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
954
955     //scalar poly == scalar double
956     scilab_fill_comparisonequal(ScalarPolynom, ScalarDouble, P_M, Polynom, Double, Bool);
957     scilab_fill_comparisonequal(ScalarPolynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
958     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
959     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
960
961     //poly == Bool
962     scilab_fill_comparisonequal(ScalarPolynom, Bool, E_M, Polynom, Bool, Bool);
963     scilab_fill_comparisonequal(ScalarPolynom, ScalarBool, E_M, Polynom, Bool, Bool);
964     scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, E_M, Polynom, Bool, Bool);
965     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
966
967     //scalar poly == []
968     scilab_fill_comparisonequal(ScalarPolynom, Empty, M_E, Polynom, Double, Bool);
969     scilab_fill_comparisonequal(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Bool);
970
971     //scalar poly == eye
972     scilab_fill_comparisonequal(ScalarPolynom, Identity, P_M, Polynom, Double, Bool);
973     scilab_fill_comparisonequal(ScalarPolynom, IdentityComplex, P_M, Polynom, Double, Bool);
974     scilab_fill_comparisonequal(ScalarPolynomComplex, Identity, P_M, Polynom, Double, Bool);
975     scilab_fill_comparisonequal(ScalarPolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
976
977     //poly == Int8
978     scilab_fill_comparisonequal(Polynom, Int8, P_M, Polynom, Int8, Bool);
979     scilab_fill_comparisonequal(Polynom, UInt8, P_M, Polynom, UInt8, Bool);
980     scilab_fill_comparisonequal(PolynomComplex, Int8, P_M, Polynom, Int8, Bool);
981     scilab_fill_comparisonequal(PolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
982
983     scilab_fill_comparisonequal(Int8, Polynom, M_P, Int8, Polynom, Bool);
984     scilab_fill_comparisonequal(UInt8, Polynom, M_P, UInt8, Polynom, Bool);
985     scilab_fill_comparisonequal(Int8, PolynomComplex, M_P, Int8, Polynom, Bool);
986     scilab_fill_comparisonequal(UInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
987
988     scilab_fill_comparisonequal(ScalarPolynom, Int8, P_M, Polynom, Int8, Bool);
989     scilab_fill_comparisonequal(ScalarPolynom, UInt8, P_M, Polynom, UInt8, Bool);
990     scilab_fill_comparisonequal(ScalarPolynomComplex, Int8, P_M, Polynom, Int8, Bool);
991     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
992
993     scilab_fill_comparisonequal(Int8, ScalarPolynom, M_P, Int8, Polynom, Bool);
994     scilab_fill_comparisonequal(UInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
995     scilab_fill_comparisonequal(Int8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
996     scilab_fill_comparisonequal(UInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
997
998     //poly == Int16
999     scilab_fill_comparisonequal(Polynom, Int16, P_M, Polynom, Int16, Bool);
1000     scilab_fill_comparisonequal(Polynom, UInt16, P_M, Polynom, UInt16, Bool);
1001     scilab_fill_comparisonequal(PolynomComplex, Int16, P_M, Polynom, Int16, Bool);
1002     scilab_fill_comparisonequal(PolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
1003
1004     scilab_fill_comparisonequal(Int16, Polynom, M_P, Int16, Polynom, Bool);
1005     scilab_fill_comparisonequal(UInt16, Polynom, M_P, UInt16, Polynom, Bool);
1006     scilab_fill_comparisonequal(Int16, PolynomComplex, M_P, Int16, Polynom, Bool);
1007     scilab_fill_comparisonequal(UInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
1008
1009     scilab_fill_comparisonequal(ScalarPolynom, Int16, P_M, Polynom, Int16, Bool);
1010     scilab_fill_comparisonequal(ScalarPolynom, UInt16, P_M, Polynom, UInt16, Bool);
1011     scilab_fill_comparisonequal(ScalarPolynomComplex, Int16, P_M, Polynom, Int16, Bool);
1012     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
1013
1014     scilab_fill_comparisonequal(Int16, ScalarPolynom, M_P, Int16, Polynom, Bool);
1015     scilab_fill_comparisonequal(UInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
1016     scilab_fill_comparisonequal(Int16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
1017     scilab_fill_comparisonequal(UInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
1018
1019     //poly == Int32
1020     scilab_fill_comparisonequal(Polynom, Int32, P_M, Polynom, Int32, Bool);
1021     scilab_fill_comparisonequal(Polynom, UInt32, P_M, Polynom, UInt32, Bool);
1022     scilab_fill_comparisonequal(PolynomComplex, Int32, P_M, Polynom, Int32, Bool);
1023     scilab_fill_comparisonequal(PolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
1024
1025     scilab_fill_comparisonequal(Int32, Polynom, M_P, Int32, Polynom, Bool);
1026     scilab_fill_comparisonequal(UInt32, Polynom, M_P, UInt32, Polynom, Bool);
1027     scilab_fill_comparisonequal(Int32, PolynomComplex, M_P, Int32, Polynom, Bool);
1028     scilab_fill_comparisonequal(UInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
1029
1030     scilab_fill_comparisonequal(ScalarPolynom, Int32, P_M, Polynom, Int32, Bool);
1031     scilab_fill_comparisonequal(ScalarPolynom, UInt32, P_M, Polynom, UInt32, Bool);
1032     scilab_fill_comparisonequal(ScalarPolynomComplex, Int32, P_M, Polynom, Int32, Bool);
1033     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
1034
1035     scilab_fill_comparisonequal(Int32, ScalarPolynom, M_P, Int32, Polynom, Bool);
1036     scilab_fill_comparisonequal(UInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
1037     scilab_fill_comparisonequal(Int32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
1038     scilab_fill_comparisonequal(UInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
1039
1040     //poly == Int64
1041     scilab_fill_comparisonequal(Polynom, Int64, P_M, Polynom, Int64, Bool);
1042     scilab_fill_comparisonequal(Polynom, UInt64, P_M, Polynom, UInt64, Bool);
1043     scilab_fill_comparisonequal(PolynomComplex, Int64, P_M, Polynom, Int64, Bool);
1044     scilab_fill_comparisonequal(PolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
1045
1046     scilab_fill_comparisonequal(Int64, Polynom, M_P, Int64, Polynom, Bool);
1047     scilab_fill_comparisonequal(UInt64, Polynom, M_P, UInt64, Polynom, Bool);
1048     scilab_fill_comparisonequal(Int64, PolynomComplex, M_P, Int64, Polynom, Bool);
1049     scilab_fill_comparisonequal(UInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
1050
1051     scilab_fill_comparisonequal(ScalarPolynom, Int64, P_M, Polynom, Int64, Bool);
1052     scilab_fill_comparisonequal(ScalarPolynom, UInt64, P_M, Polynom, UInt64, Bool);
1053     scilab_fill_comparisonequal(ScalarPolynomComplex, Int64, P_M, Polynom, Int64, Bool);
1054     scilab_fill_comparisonequal(ScalarPolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
1055
1056     scilab_fill_comparisonequal(Int64, ScalarPolynom, M_P, Int64, Polynom, Bool);
1057     scilab_fill_comparisonequal(UInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
1058     scilab_fill_comparisonequal(Int64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
1059     scilab_fill_comparisonequal(UInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
1060
1061     //poly == Int8
1062     scilab_fill_comparisonequal(Polynom, ScalarInt8, P_M, Polynom, Int8, Bool);
1063     scilab_fill_comparisonequal(Polynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1064     scilab_fill_comparisonequal(PolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
1065     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1066
1067     scilab_fill_comparisonequal(ScalarInt8, Polynom, M_P, Int8, Polynom, Bool);
1068     scilab_fill_comparisonequal(ScalarUInt8, Polynom, M_P, UInt8, Polynom, Bool);
1069     scilab_fill_comparisonequal(ScalarInt8, PolynomComplex, M_P, Int8, Polynom, Bool);
1070     scilab_fill_comparisonequal(ScalarUInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
1071
1072     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt8, P_M, Polynom, Int8, Bool);
1073     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1074     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
1075     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
1076
1077     scilab_fill_comparisonequal(ScalarInt8, ScalarPolynom, M_P, Int8, Polynom, Bool);
1078     scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
1079     scilab_fill_comparisonequal(ScalarInt8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
1080     scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
1081
1082     //poly == Int16
1083     scilab_fill_comparisonequal(Polynom, ScalarInt16, P_M, Polynom, Int16, Bool);
1084     scilab_fill_comparisonequal(Polynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1085     scilab_fill_comparisonequal(PolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
1086     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1087
1088     scilab_fill_comparisonequal(ScalarInt16, Polynom, M_P, Polynom, Int16, Bool);
1089     scilab_fill_comparisonequal(ScalarUInt16, Polynom, M_P, Polynom, UInt16, Bool);
1090     scilab_fill_comparisonequal(ScalarInt16, PolynomComplex, M_P, Int16, Polynom, Bool);
1091     scilab_fill_comparisonequal(ScalarUInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
1092
1093     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt16, P_M, Polynom, Int16, Bool);
1094     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1095     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
1096     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
1097
1098     scilab_fill_comparisonequal(ScalarInt16, ScalarPolynom, M_P, Int16, Polynom, Bool);
1099     scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
1100     scilab_fill_comparisonequal(ScalarInt16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
1101     scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
1102
1103     //poly == Int32
1104     scilab_fill_comparisonequal(Polynom, ScalarInt32, P_M, Polynom, Int32, Bool);
1105     scilab_fill_comparisonequal(Polynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1106     scilab_fill_comparisonequal(PolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
1107     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1108
1109     scilab_fill_comparisonequal(ScalarInt32, Polynom, M_P, Int32, Polynom, Bool);
1110     scilab_fill_comparisonequal(ScalarUInt32, Polynom, M_P, UInt32, Polynom, Bool);
1111     scilab_fill_comparisonequal(ScalarInt32, PolynomComplex, M_P, Int32, Polynom, Bool);
1112     scilab_fill_comparisonequal(ScalarUInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
1113
1114     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt32, P_M, Polynom, Int32, Bool);
1115     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1116     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
1117     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
1118
1119     scilab_fill_comparisonequal(ScalarInt32, ScalarPolynom, M_P, Int32, Polynom, Bool);
1120     scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
1121     scilab_fill_comparisonequal(ScalarInt32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
1122     scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
1123
1124     //poly == Int64
1125     scilab_fill_comparisonequal(Polynom, ScalarInt64, P_M, Polynom, Int64, Bool);
1126     scilab_fill_comparisonequal(Polynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1127     scilab_fill_comparisonequal(PolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
1128     scilab_fill_comparisonequal(PolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1129
1130     scilab_fill_comparisonequal(ScalarInt64, Polynom, M_P, Int64, Polynom, Bool);
1131     scilab_fill_comparisonequal(ScalarUInt64, Polynom, M_P, UInt64, Polynom, Bool);
1132     scilab_fill_comparisonequal(ScalarInt64, PolynomComplex, M_P, Int64, Polynom, Bool);
1133     scilab_fill_comparisonequal(ScalarUInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
1134
1135     scilab_fill_comparisonequal(ScalarPolynom, ScalarInt64, P_M, Polynom, Int64, Bool);
1136     scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1137     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
1138     scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
1139
1140     scilab_fill_comparisonequal(ScalarInt64, ScalarPolynom, M_P, Int64, Polynom, Bool);
1141     scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
1142     scilab_fill_comparisonequal(ScalarInt64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
1143     scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
1144
1145     //poly == bool
1146     scilab_fill_comparisonequal(Polynom, Bool, M_E, Polynom, Bool, Bool);
1147     scilab_fill_comparisonequal(PolynomComplex, Bool, M_E, Polynom, Bool, Bool);
1148     scilab_fill_comparisonequal(ScalarPolynom, Bool, M_E, Polynom, Bool, Bool);
1149     scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, M_E, Polynom, Bool, Bool);
1150
1151     scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
1152     scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
1153     scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
1154     scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
1155
1156     //Sparse
1157     scilab_fill_comparisonequal(Sparse, Sparse, M_M, Sparse, Sparse, SparseBool);
1158     scilab_fill_comparisonequal(Sparse, SparseComplex, M_M, Sparse, Sparse, SparseBool);
1159     scilab_fill_comparisonequal(Sparse, Double, SP_M, Sparse, Double, SparseBool);
1160     scilab_fill_comparisonequal(Sparse, DoubleComplex, SP_M, Sparse, Double, SparseBool);
1161     scilab_fill_comparisonequal(Sparse, ScalarDouble, SP_M, Sparse, Double, SparseBool);
1162     scilab_fill_comparisonequal(Sparse, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
1163
1164     scilab_fill_comparisonequal(Sparse, Empty, M_E, Sparse, Double, Bool);
1165     scilab_fill_comparisonequal(Sparse, Identity, M_E, Sparse, Double, SparseBool);
1166     scilab_fill_comparisonequal(Sparse, IdentityComplex, M_E, Sparse, Double, SparseBool);
1167
1168     scilab_fill_comparisonequal(SparseComplex, Sparse, M_M, Sparse, Sparse, SparseBool);
1169     scilab_fill_comparisonequal(SparseComplex, SparseComplex, M_M, Sparse, Sparse, SparseBool);
1170     scilab_fill_comparisonequal(SparseComplex, Double, SP_M, Sparse, Double, SparseBool);
1171     scilab_fill_comparisonequal(SparseComplex, DoubleComplex, SP_M, Sparse, Double, SparseBool);
1172     scilab_fill_comparisonequal(SparseComplex, ScalarDouble, SP_M, Sparse, Double, SparseBool);
1173     scilab_fill_comparisonequal(SparseComplex, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
1174
1175     scilab_fill_comparisonequal(SparseComplex, Empty, M_E, Sparse, Double, Bool);
1176     scilab_fill_comparisonequal(SparseComplex, Identity, M_E, Sparse, Double, SparseBool);
1177     scilab_fill_comparisonequal(SparseComplex, IdentityComplex, M_E, Sparse, Double, SparseBool);
1178
1179     scilab_fill_comparisonequal(Sparse, Bool, M_E, Sparse, Bool, Bool);
1180     scilab_fill_comparisonequal(Sparse, ScalarBool, M_E, Sparse, Bool, Bool);
1181     scilab_fill_comparisonequal(SparseComplex, Bool, M_E, Sparse, Bool, Bool);
1182     scilab_fill_comparisonequal(SparseComplex, ScalarBool, M_E, Sparse, Bool, Bool);
1183
1184     scilab_fill_comparisonequal(Sparse, Int8, SP_M, Sparse, Int8, SparseBool);
1185     scilab_fill_comparisonequal(Int8, Sparse, M_SP, Int8, Sparse, SparseBool);
1186     scilab_fill_comparisonequal(SparseComplex, Int8, SP_M, Sparse, Int8, SparseBool);
1187     scilab_fill_comparisonequal(Int8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
1188
1189     scilab_fill_comparisonequal(Sparse, UInt8, SP_M, Sparse, UInt8, SparseBool);
1190     scilab_fill_comparisonequal(UInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
1191     scilab_fill_comparisonequal(SparseComplex, UInt8, SP_M, Sparse, UInt8, SparseBool);
1192     scilab_fill_comparisonequal(UInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
1193
1194     scilab_fill_comparisonequal(Sparse, Int16, SP_M, Sparse, Int16, SparseBool);
1195     scilab_fill_comparisonequal(Int16, Sparse, M_SP, Int16, Sparse, SparseBool);
1196     scilab_fill_comparisonequal(SparseComplex, Int16, SP_M, Sparse, Int16, SparseBool);
1197     scilab_fill_comparisonequal(Int16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
1198
1199     scilab_fill_comparisonequal(Sparse, UInt16, SP_M, Sparse, UInt16, SparseBool);
1200     scilab_fill_comparisonequal(UInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
1201     scilab_fill_comparisonequal(SparseComplex, UInt16, SP_M, Sparse, UInt16, SparseBool);
1202     scilab_fill_comparisonequal(UInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
1203
1204     scilab_fill_comparisonequal(Sparse, Int32, SP_M, Sparse, Int32, SparseBool);
1205     scilab_fill_comparisonequal(Int32, Sparse, M_SP, Int32, Sparse, SparseBool);
1206     scilab_fill_comparisonequal(SparseComplex, Int32, SP_M, Sparse, Int32, SparseBool);
1207     scilab_fill_comparisonequal(Int32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
1208
1209     scilab_fill_comparisonequal(Sparse, UInt32, SP_M, Sparse, UInt32, SparseBool);
1210     scilab_fill_comparisonequal(UInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
1211     scilab_fill_comparisonequal(SparseComplex, UInt32, SP_M, Sparse, UInt32, SparseBool);
1212     scilab_fill_comparisonequal(UInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
1213
1214     scilab_fill_comparisonequal(Sparse, Int64, SP_M, Sparse, Int64, SparseBool);
1215     scilab_fill_comparisonequal(Int64, Sparse, M_SP, Int64, Sparse, SparseBool);
1216     scilab_fill_comparisonequal(SparseComplex, Int64, SP_M, Sparse, Int64, SparseBool);
1217     scilab_fill_comparisonequal(Int64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
1218
1219     scilab_fill_comparisonequal(Sparse, UInt64, SP_M, Sparse, UInt64, SparseBool);
1220     scilab_fill_comparisonequal(UInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
1221     scilab_fill_comparisonequal(SparseComplex, UInt64, SP_M, Sparse, UInt64, SparseBool);
1222     scilab_fill_comparisonequal(UInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
1223
1224     scilab_fill_comparisonequal(Sparse, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
1225     scilab_fill_comparisonequal(ScalarInt8, Sparse, M_SP, Int8, Sparse, SparseBool);
1226     scilab_fill_comparisonequal(SparseComplex, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
1227     scilab_fill_comparisonequal(ScalarInt8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
1228
1229     scilab_fill_comparisonequal(Sparse, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
1230     scilab_fill_comparisonequal(ScalarUInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
1231     scilab_fill_comparisonequal(SparseComplex, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
1232     scilab_fill_comparisonequal(ScalarUInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
1233
1234     scilab_fill_comparisonequal(Sparse, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
1235     scilab_fill_comparisonequal(ScalarInt16, Sparse, M_SP, Int16, Sparse, SparseBool);
1236     scilab_fill_comparisonequal(SparseComplex, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
1237     scilab_fill_comparisonequal(ScalarInt16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
1238
1239     scilab_fill_comparisonequal(Sparse, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
1240     scilab_fill_comparisonequal(ScalarUInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
1241     scilab_fill_comparisonequal(SparseComplex, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
1242     scilab_fill_comparisonequal(ScalarUInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
1243
1244     scilab_fill_comparisonequal(Sparse, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
1245     scilab_fill_comparisonequal(ScalarInt32, Sparse, M_SP, Int32, Sparse, SparseBool);
1246     scilab_fill_comparisonequal(SparseComplex, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
1247     scilab_fill_comparisonequal(ScalarInt32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
1248
1249     scilab_fill_comparisonequal(Sparse, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
1250     scilab_fill_comparisonequal(ScalarUInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
1251     scilab_fill_comparisonequal(SparseComplex, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
1252     scilab_fill_comparisonequal(ScalarUInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
1253
1254     scilab_fill_comparisonequal(Sparse, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
1255     scilab_fill_comparisonequal(ScalarInt64, Sparse, M_SP, Int64, Sparse, SparseBool);
1256     scilab_fill_comparisonequal(SparseComplex, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
1257     scilab_fill_comparisonequal(ScalarInt64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
1258
1259     scilab_fill_comparisonequal(Sparse, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
1260     scilab_fill_comparisonequal(ScalarUInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
1261     scilab_fill_comparisonequal(SparseComplex, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
1262     scilab_fill_comparisonequal(ScalarUInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
1263
1264
1265     //SparseBool
1266     scilab_fill_comparisonequal(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
1267     scilab_fill_comparisonequal(SparseBool, Bool, M_M, SparseBool, Bool, SparseBool);
1268     scilab_fill_comparisonequal(Bool, SparseBool, M_M, Bool, SparseBool, SparseBool);
1269     scilab_fill_comparisonequal(SparseBool, ScalarBool, M_M, SparseBool, Bool, SparseBool);
1270     scilab_fill_comparisonequal(ScalarBool, SparseBool, M_M, Bool, SparseBool, SparseBool);
1271
1272     scilab_fill_comparisonequal(SparseBool, Double, M_E, SparseBool, Double, Bool);
1273     scilab_fill_comparisonequal(Double, SparseBool, M_E, Double, SparseBool, Bool);
1274     scilab_fill_comparisonequal(SparseBool, DoubleComplex, M_E, SparseBool, Double, Bool);
1275     scilab_fill_comparisonequal(DoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
1276
1277     scilab_fill_comparisonequal(SparseBool, ScalarDouble, M_E, SparseBool, Double, Bool);
1278     scilab_fill_comparisonequal(ScalarDouble, SparseBool, M_E, Double, SparseBool, Bool);
1279     scilab_fill_comparisonequal(SparseBool, ScalarDoubleComplex, M_E, SparseBool, Double, Bool);
1280     scilab_fill_comparisonequal(ScalarDoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
1281
1282     scilab_fill_comparisonequal(SparseBool, Empty, M_E, SparseBool, Double, Bool);
1283     scilab_fill_comparisonequal(Empty, SparseBool, M_E, Double, SparseBool, Bool);
1284     scilab_fill_comparisonequal(SparseBool, Identity, M_E, SparseBool, Double, Bool);
1285     scilab_fill_comparisonequal(Identity, SparseBool, M_E, Double, SparseBool, Bool);
1286     scilab_fill_comparisonequal(SparseBool, IdentityComplex, M_E, SparseBool, Double, Bool);
1287     scilab_fill_comparisonequal(IdentityComplex, SparseBool, M_E, Double, SparseBool, Bool);
1288
1289     scilab_fill_comparisonequal(SparseBool, Int8, M_E, SparseBool, Int8, Bool);
1290     scilab_fill_comparisonequal(Int8, SparseBool, M_E, Int8, SparseBool, Bool);
1291     scilab_fill_comparisonequal(SparseBool, UInt8, M_E, SparseBool, UInt8, Bool);
1292     scilab_fill_comparisonequal(UInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
1293
1294     scilab_fill_comparisonequal(SparseBool, Int16, M_E, SparseBool, Int16, Bool);
1295     scilab_fill_comparisonequal(Int16, SparseBool, M_E, Int16, SparseBool, Bool);
1296     scilab_fill_comparisonequal(SparseBool, UInt16, M_E, SparseBool, UInt16, Bool);
1297     scilab_fill_comparisonequal(UInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
1298
1299     scilab_fill_comparisonequal(SparseBool, Int32, M_E, SparseBool, Int32, Bool);
1300     scilab_fill_comparisonequal(Int32, SparseBool, M_E, Int32, SparseBool, Bool);
1301     scilab_fill_comparisonequal(SparseBool, UInt32, M_E, SparseBool, UInt32, Bool);
1302     scilab_fill_comparisonequal(UInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
1303
1304     scilab_fill_comparisonequal(SparseBool, Int64, M_E, SparseBool, Int64, Bool);
1305     scilab_fill_comparisonequal(Int64, SparseBool, M_E, Int64, SparseBool, Bool);
1306     scilab_fill_comparisonequal(SparseBool, UInt64, M_E, SparseBool, UInt64, Bool);
1307     scilab_fill_comparisonequal(UInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
1308
1309     scilab_fill_comparisonequal(SparseBool, ScalarInt8, M_E, SparseBool, Int8, Bool);
1310     scilab_fill_comparisonequal(ScalarInt8, SparseBool, M_E, Int8, SparseBool, Bool);
1311     scilab_fill_comparisonequal(SparseBool, ScalarUInt8, M_E, SparseBool, UInt8, Bool);
1312     scilab_fill_comparisonequal(ScalarUInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
1313
1314     scilab_fill_comparisonequal(SparseBool, ScalarInt16, M_E, SparseBool, Int16, Bool);
1315     scilab_fill_comparisonequal(ScalarInt16, SparseBool, M_E, Int16, SparseBool, Bool);
1316     scilab_fill_comparisonequal(SparseBool, ScalarUInt16, M_E, SparseBool, UInt16, Bool);
1317     scilab_fill_comparisonequal(ScalarUInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
1318
1319     scilab_fill_comparisonequal(SparseBool, ScalarInt32, M_E, SparseBool, Int32, Bool);
1320     scilab_fill_comparisonequal(ScalarInt32, SparseBool, M_E, Int32, SparseBool, Bool);
1321     scilab_fill_comparisonequal(SparseBool, ScalarUInt32, M_E, SparseBool, UInt32, Bool);
1322     scilab_fill_comparisonequal(ScalarUInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
1323
1324     scilab_fill_comparisonequal(SparseBool, ScalarInt64, M_E, SparseBool, Int64, Bool);
1325     scilab_fill_comparisonequal(ScalarInt64, SparseBool, M_E, Int64, SparseBool, Bool);
1326     scilab_fill_comparisonequal(SparseBool, ScalarUInt64, M_E, SparseBool, UInt64, Bool);
1327     scilab_fill_comparisonequal(ScalarUInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
1328
1329     scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
1330     scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
1331     scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
1332     scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
1333
1334     scilab_fill_comparisonequal(SparseBool, SparseComplex, M_E, SparseBool, Sparse, Bool);
1335     scilab_fill_comparisonequal(SparseComplex, SparseBool, M_E, Sparse, SparseBool, Bool);
1336
1337     scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
1338     scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
1339
1340     scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
1341     scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
1342
1343     //struct
1344     scilab_fill_comparisonequal(Struct, Struct, M_M, Struct, Struct, Bool);
1345
1346     scilab_fill_comparisonequal(Struct, Empty, M_E, Struct, Double, Bool);
1347     scilab_fill_comparisonequal(Empty, Struct, E_M, Double, Struct, Bool);
1348
1349     scilab_fill_comparisonequal(Struct, Double, M_E, Struct, Double, Bool);
1350     scilab_fill_comparisonequal(Double, Struct, M_E, Double, Struct, Bool);
1351     scilab_fill_comparisonequal(Struct, DoubleComplex, M_E, Struct, Double, Bool);
1352     scilab_fill_comparisonequal(DoubleComplex, Struct, M_E, Double, Struct, Bool);
1353
1354     scilab_fill_comparisonequal(Struct, ScalarDouble, M_E, Struct, Double, Bool);
1355     scilab_fill_comparisonequal(ScalarDouble, Struct, M_E, Double, Struct, Bool);
1356     scilab_fill_comparisonequal(Struct, ScalarDoubleComplex, M_E, Struct, Double, Bool);
1357     scilab_fill_comparisonequal(ScalarDoubleComplex, Struct, M_E, Double, Struct, Bool);
1358
1359     scilab_fill_comparisonequal(Struct, Identity, M_E, Struct, Double, Bool);
1360     scilab_fill_comparisonequal(Identity, Struct, M_E, Double, Struct, Bool);
1361     scilab_fill_comparisonequal(Struct, IdentityComplex, M_E, Struct, Double, Bool);
1362     scilab_fill_comparisonequal(IdentityComplex, Struct, M_E, Double, Struct, Bool);
1363
1364     scilab_fill_comparisonequal(Struct, Int8, M_E, Struct, Int8, Bool);
1365     scilab_fill_comparisonequal(Int8, Struct, M_E, Int8, Struct, Bool);
1366     scilab_fill_comparisonequal(Struct, UInt8, M_E, Struct, UInt8, Bool);
1367     scilab_fill_comparisonequal(UInt8, Struct, M_E, UInt8, Struct, Bool);
1368
1369     scilab_fill_comparisonequal(Struct, Int16, M_E, Struct, Int16, Bool);
1370     scilab_fill_comparisonequal(Int16, Struct, M_E, Int16, Struct, Bool);
1371     scilab_fill_comparisonequal(Struct, UInt16, M_E, Struct, UInt16, Bool);
1372     scilab_fill_comparisonequal(UInt16, Struct, M_E, UInt16, Struct, Bool);
1373
1374     scilab_fill_comparisonequal(Struct, Int32, M_E, Struct, Int32, Bool);
1375     scilab_fill_comparisonequal(Int32, Struct, M_E, Int32, Struct, Bool);
1376     scilab_fill_comparisonequal(Struct, UInt32, M_E, Struct, UInt32, Bool);
1377     scilab_fill_comparisonequal(UInt32, Struct, M_E, UInt32, Struct, Bool);
1378
1379     scilab_fill_comparisonequal(Struct, Int64, M_E, Struct, Int64, Bool);
1380     scilab_fill_comparisonequal(Int64, Struct, M_E, Int64, Struct, Bool);
1381     scilab_fill_comparisonequal(Struct, UInt64, M_E, Struct, UInt64, Bool);
1382     scilab_fill_comparisonequal(UInt64, Struct, M_E, UInt64, Struct, Bool);
1383
1384     scilab_fill_comparisonequal(Struct, ScalarInt8, M_E, Struct, Int8, Bool);
1385     scilab_fill_comparisonequal(ScalarInt8, Struct, M_E, Int8, Struct, Bool);
1386     scilab_fill_comparisonequal(Struct, ScalarUInt8, M_E, Struct, UInt8, Bool);
1387     scilab_fill_comparisonequal(ScalarUInt8, Struct, M_E, UInt8, Struct, Bool);
1388
1389     scilab_fill_comparisonequal(Struct, ScalarInt16, M_E, Struct, Int16, Bool);
1390     scilab_fill_comparisonequal(ScalarInt16, Struct, M_E, Int16, Struct, Bool);
1391     scilab_fill_comparisonequal(Struct, ScalarUInt16, M_E, Struct, UInt16, Bool);
1392     scilab_fill_comparisonequal(ScalarUInt16, Struct, M_E, UInt16, Struct, Bool);
1393
1394     scilab_fill_comparisonequal(Struct, ScalarInt32, M_E, Struct, Int32, Bool);
1395     scilab_fill_comparisonequal(ScalarInt32, Struct, M_E, Int32, Struct, Bool);
1396     scilab_fill_comparisonequal(Struct, ScalarUInt32, M_E, Struct, UInt32, Bool);
1397     scilab_fill_comparisonequal(ScalarUInt32, Struct, M_E, UInt32, Struct, Bool);
1398
1399     scilab_fill_comparisonequal(Struct, ScalarInt64, M_E, Struct, Int64, Bool);
1400     scilab_fill_comparisonequal(ScalarInt64, Struct, M_E, Int64, Struct, Bool);
1401     scilab_fill_comparisonequal(Struct, ScalarUInt64, M_E, Struct, UInt64, Bool);
1402     scilab_fill_comparisonequal(ScalarUInt64, Struct, M_E, UInt64, Struct, Bool);
1403
1404     scilab_fill_comparisonequal(Struct, String, M_E, Struct, String, Bool);
1405     scilab_fill_comparisonequal(String, Struct, M_E, String, Struct, Bool);
1406     scilab_fill_comparisonequal(Struct, ScalarString, M_E, Struct, String, Bool);
1407     scilab_fill_comparisonequal(ScalarString, Struct, M_E, String, Struct, Bool);
1408
1409     scilab_fill_comparisonequal(Struct, SparseComplex, M_E, Struct, Sparse, Bool);
1410     scilab_fill_comparisonequal(SparseComplex, Struct, M_E, Sparse, Struct, Bool);
1411
1412     scilab_fill_comparisonequal(Struct, Sparse, M_E, Struct, Sparse, Bool);
1413     scilab_fill_comparisonequal(Sparse, Struct, M_E, Sparse, Struct, Bool);
1414
1415     scilab_fill_comparisonequal(Struct, SparseBool, M_E, Struct, SparseBool, Bool);
1416     scilab_fill_comparisonequal(SparseBool, Struct, M_E, SparseBool, Struct, Bool);
1417
1418     //List, TList, MList
1419     scilab_fill_comparisonequal(List, List, LT_LT, List, List, Bool);
1420     scilab_fill_comparisonequal(MList, MList, LT_LT, MList, MList, Bool);
1421     scilab_fill_comparisonequal(TList, TList, LT_LT, TList, TList, Bool);
1422
1423     scilab_fill_comparisonequal(List, TList, LT_LT, List, TList, Bool);
1424     scilab_fill_comparisonequal(TList, List, LT_LT, TList, List, Bool);
1425     scilab_fill_comparisonequal(List, MList, LT_LT, List, MList, Bool);
1426     scilab_fill_comparisonequal(MList, List, LT_LT, MList, List, Bool);
1427
1428     scilab_fill_comparisonequal(TList, MList, LT_LT, TList, MList, Bool);
1429     scilab_fill_comparisonequal(MList, TList, LT_LT, MList, TList, Bool);
1430
1431     scilab_fill_comparisonequal(List, Empty, M_E, List, Double, Bool);
1432     scilab_fill_comparisonequal(TList, Empty, M_E, MList, Double, Bool);
1433     scilab_fill_comparisonequal(MList, Empty, M_E, TList, Double, Bool);
1434     scilab_fill_comparisonequal(Empty, List, E_M, Double, List, Bool);
1435     scilab_fill_comparisonequal(Empty, TList, E_M, Double, TList, Bool);
1436     scilab_fill_comparisonequal(Empty, MList, E_M, Double, MList, Bool);
1437
1438     scilab_fill_comparisonequal(List, Double, M_E, List, Double, Bool);
1439     scilab_fill_comparisonequal(Double, List, M_E, Double, List, Bool);
1440     scilab_fill_comparisonequal(List, DoubleComplex, M_E, List, Double, Bool);
1441     scilab_fill_comparisonequal(DoubleComplex, List, M_E, Double, List, Bool);
1442
1443     scilab_fill_comparisonequal(List, ScalarDouble, M_E, List, Double, Bool);
1444     scilab_fill_comparisonequal(ScalarDouble, List, M_E, Double, List, Bool);
1445     scilab_fill_comparisonequal(List, ScalarDoubleComplex, M_E, List, Double, Bool);
1446     scilab_fill_comparisonequal(ScalarDoubleComplex, List, M_E, Double, List, Bool);
1447
1448     scilab_fill_comparisonequal(List, Identity, M_E, List, Double, Bool);
1449     scilab_fill_comparisonequal(Identity, List, M_E, Double, List, Bool);
1450     scilab_fill_comparisonequal(List, IdentityComplex, M_E, List, Double, Bool);
1451     scilab_fill_comparisonequal(IdentityComplex, List, M_E, Double, List, Bool);
1452
1453     scilab_fill_comparisonequal(List, Int8, M_E, List, Int8, Bool);
1454     scilab_fill_comparisonequal(Int8, List, M_E, Int8, List, Bool);
1455     scilab_fill_comparisonequal(List, UInt8, M_E, List, UInt8, Bool);
1456     scilab_fill_comparisonequal(UInt8, List, M_E, UInt8, List, Bool);
1457
1458     scilab_fill_comparisonequal(List, Int16, M_E, List, Int16, Bool);
1459     scilab_fill_comparisonequal(Int16, List, M_E, Int16, List, Bool);
1460     scilab_fill_comparisonequal(List, UInt16, M_E, List, UInt16, Bool);
1461     scilab_fill_comparisonequal(UInt16, List, M_E, UInt16, List, Bool);
1462
1463     scilab_fill_comparisonequal(List, Int32, M_E, List, Int32, Bool);
1464     scilab_fill_comparisonequal(Int32, List, M_E, Int32, List, Bool);
1465     scilab_fill_comparisonequal(List, UInt32, M_E, List, UInt32, Bool);
1466     scilab_fill_comparisonequal(UInt32, List, M_E, UInt32, List, Bool);
1467
1468     scilab_fill_comparisonequal(List, Int64, M_E, List, Int64, Bool);
1469     scilab_fill_comparisonequal(Int64, List, M_E, Int64, List, Bool);
1470     scilab_fill_comparisonequal(List, UInt64, M_E, List, UInt64, Bool);
1471     scilab_fill_comparisonequal(UInt64, List, M_E, UInt64, List, Bool);
1472
1473     scilab_fill_comparisonequal(List, ScalarInt8, M_E, List, Int8, Bool);
1474     scilab_fill_comparisonequal(ScalarInt8, List, M_E, Int8, List, Bool);
1475     scilab_fill_comparisonequal(List, ScalarUInt8, M_E, List, UInt8, Bool);
1476     scilab_fill_comparisonequal(ScalarUInt8, List, M_E, UInt8, List, Bool);
1477
1478     scilab_fill_comparisonequal(List, ScalarInt16, M_E, List, Int16, Bool);
1479     scilab_fill_comparisonequal(ScalarInt16, List, M_E, Int16, List, Bool);
1480     scilab_fill_comparisonequal(List, ScalarUInt16, M_E, List, UInt16, Bool);
1481     scilab_fill_comparisonequal(ScalarUInt16, List, M_E, UInt16, List, Bool);
1482
1483     scilab_fill_comparisonequal(List, ScalarInt32, M_E, List, Int32, Bool);
1484     scilab_fill_comparisonequal(ScalarInt32, List, M_E, Int32, List, Bool);
1485     scilab_fill_comparisonequal(List, ScalarUInt32, M_E, List, UInt32, Bool);
1486     scilab_fill_comparisonequal(ScalarUInt32, List, M_E, UInt32, List, Bool);
1487
1488     scilab_fill_comparisonequal(List, ScalarInt64, M_E, List, Int64, Bool);
1489     scilab_fill_comparisonequal(ScalarInt64, List, M_E, Int64, List, Bool);
1490     scilab_fill_comparisonequal(List, ScalarUInt64, M_E, List, UInt64, Bool);
1491     scilab_fill_comparisonequal(ScalarUInt64, List, M_E, UInt64, List, Bool);
1492
1493     scilab_fill_comparisonequal(List, String, M_E, List, String, Bool);
1494     scilab_fill_comparisonequal(String, List, M_E, String, List, Bool);
1495     scilab_fill_comparisonequal(List, ScalarString, M_E, List, String, Bool);
1496     scilab_fill_comparisonequal(ScalarString, List, M_E, String, List, Bool);
1497
1498     scilab_fill_comparisonequal(List, SparseComplex, M_E, List, Sparse, Bool);
1499     scilab_fill_comparisonequal(SparseComplex, List, M_E, Sparse, List, Bool);
1500
1501     scilab_fill_comparisonequal(List, Sparse, M_E, List, Sparse, Bool);
1502     scilab_fill_comparisonequal(Sparse, List, M_E, Sparse, List, Bool);
1503
1504     scilab_fill_comparisonequal(List, SparseBool, M_E, List, SparseBool, Bool);
1505     scilab_fill_comparisonequal(SparseBool, List, M_E, SparseBool, List, Bool);
1506
1507     scilab_fill_comparisonequal(List, Struct, M_E, List, Struct, Bool);
1508     scilab_fill_comparisonequal(Struct, List, M_E, Struct, List, Bool);
1509
1510     scilab_fill_comparisonequal(TList, Double, M_E, TList, Double, Bool);
1511     scilab_fill_comparisonequal(Double, TList, M_E, Double, TList, Bool);
1512     scilab_fill_comparisonequal(TList, DoubleComplex, M_E, TList, Double, Bool);
1513     scilab_fill_comparisonequal(DoubleComplex, TList, M_E, Double, TList, Bool);
1514
1515     scilab_fill_comparisonequal(TList, ScalarDouble, M_E, TList, Double, Bool);
1516     scilab_fill_comparisonequal(ScalarDouble, TList, M_E, Double, TList, Bool);
1517     scilab_fill_comparisonequal(TList, ScalarDoubleComplex, M_E, TList, Double, Bool);
1518     scilab_fill_comparisonequal(ScalarDoubleComplex, TList, M_E, Double, TList, Bool);
1519
1520     scilab_fill_comparisonequal(TList, Identity, M_E, TList, Double, Bool);
1521     scilab_fill_comparisonequal(Identity, TList, M_E, Double, TList, Bool);
1522     scilab_fill_comparisonequal(TList, IdentityComplex, M_E, TList, Double, Bool);
1523     scilab_fill_comparisonequal(IdentityComplex, TList, M_E, Double, TList, Bool);
1524
1525     scilab_fill_comparisonequal(TList, Int8, M_E, TList, Int8, Bool);
1526     scilab_fill_comparisonequal(Int8, TList, M_E, Int8, TList, Bool);
1527     scilab_fill_comparisonequal(TList, UInt8, M_E, TList, UInt8, Bool);
1528     scilab_fill_comparisonequal(UInt8, TList, M_E, UInt8, TList, Bool);
1529
1530     scilab_fill_comparisonequal(TList, Int16, M_E, TList, Int16, Bool);
1531     scilab_fill_comparisonequal(Int16, TList, M_E, Int16, TList, Bool);
1532     scilab_fill_comparisonequal(TList, UInt16, M_E, TList, UInt16, Bool);
1533     scilab_fill_comparisonequal(UInt16, TList, M_E, UInt16, TList, Bool);
1534
1535     scilab_fill_comparisonequal(TList, Int32, M_E, TList, Int32, Bool);
1536     scilab_fill_comparisonequal(Int32, TList, M_E, Int32, TList, Bool);
1537     scilab_fill_comparisonequal(TList, UInt32, M_E, TList, UInt32, Bool);
1538     scilab_fill_comparisonequal(UInt32, TList, M_E, UInt32, TList, Bool);
1539
1540     scilab_fill_comparisonequal(TList, Int64, M_E, TList, Int64, Bool);
1541     scilab_fill_comparisonequal(Int64, TList, M_E, Int64, TList, Bool);
1542     scilab_fill_comparisonequal(TList, UInt64, M_E, TList, UInt64, Bool);
1543     scilab_fill_comparisonequal(UInt64, TList, M_E, UInt64, TList, Bool);
1544
1545     scilab_fill_comparisonequal(TList, ScalarInt8, M_E, TList, Int8, Bool);
1546     scilab_fill_comparisonequal(ScalarInt8, TList, M_E, Int8, TList, Bool);
1547     scilab_fill_comparisonequal(TList, ScalarUInt8, M_E, TList, UInt8, Bool);
1548     scilab_fill_comparisonequal(ScalarUInt8, TList, M_E, UInt8, TList, Bool);
1549
1550     scilab_fill_comparisonequal(TList, ScalarInt16, M_E, TList, Int16, Bool);
1551     scilab_fill_comparisonequal(ScalarInt16, TList, M_E, Int16, TList, Bool);
1552     scilab_fill_comparisonequal(TList, ScalarUInt16, M_E, TList, UInt16, Bool);
1553     scilab_fill_comparisonequal(ScalarUInt16, TList, M_E, UInt16, TList, Bool);
1554
1555     scilab_fill_comparisonequal(TList, ScalarInt32, M_E, TList, Int32, Bool);
1556     scilab_fill_comparisonequal(ScalarInt32, TList, M_E, Int32, TList, Bool);
1557     scilab_fill_comparisonequal(TList, ScalarUInt32, M_E, TList, UInt32, Bool);
1558     scilab_fill_comparisonequal(ScalarUInt32, TList, M_E, UInt32, TList, Bool);
1559
1560     scilab_fill_comparisonequal(TList, ScalarInt64, M_E, TList, Int64, Bool);
1561     scilab_fill_comparisonequal(ScalarInt64, TList, M_E, Int64, TList, Bool);
1562     scilab_fill_comparisonequal(TList, ScalarUInt64, M_E, TList, UInt64, Bool);
1563     scilab_fill_comparisonequal(ScalarUInt64, TList, M_E, UInt64, TList, Bool);
1564
1565     scilab_fill_comparisonequal(TList, String, M_E, TList, String, Bool);
1566     scilab_fill_comparisonequal(String, TList, M_E, String, TList, Bool);
1567     scilab_fill_comparisonequal(TList, ScalarString, M_E, TList, String, Bool);
1568     scilab_fill_comparisonequal(ScalarString, TList, M_E, String, TList, Bool);
1569
1570     scilab_fill_comparisonequal(TList, SparseComplex, M_E, TList, Sparse, Bool);
1571     scilab_fill_comparisonequal(SparseComplex, TList, M_E, Sparse, TList, Bool);
1572
1573     scilab_fill_comparisonequal(TList, Sparse, M_E, TList, Sparse, Bool);
1574     scilab_fill_comparisonequal(Sparse, TList, M_E, Sparse, TList, Bool);
1575
1576     scilab_fill_comparisonequal(TList, SparseBool, M_E, TList, SparseBool, Bool);
1577     scilab_fill_comparisonequal(SparseBool, TList, M_E, SparseBool, TList, Bool);
1578
1579     scilab_fill_comparisonequal(TList, Struct, M_E, TList, Struct, Bool);
1580     scilab_fill_comparisonequal(Struct, TList, M_E, Struct, TList, Bool);
1581
1582     scilab_fill_comparisonequal(MList, Double, M_E, MList, Double, Bool);
1583     scilab_fill_comparisonequal(Double, MList, M_E, Double, MList, Bool);
1584     scilab_fill_comparisonequal(MList, DoubleComplex, M_E, MList, Double, Bool);
1585     scilab_fill_comparisonequal(DoubleComplex, MList, M_E, Double, MList, Bool);
1586
1587     scilab_fill_comparisonequal(MList, ScalarDouble, M_E, MList, Double, Bool);
1588     scilab_fill_comparisonequal(ScalarDouble, MList, M_E, Double, MList, Bool);
1589     scilab_fill_comparisonequal(MList, ScalarDoubleComplex, M_E, MList, Double, Bool);
1590     scilab_fill_comparisonequal(ScalarDoubleComplex, MList, M_E, Double, MList, Bool);
1591
1592     scilab_fill_comparisonequal(MList, Identity, M_E, MList, Double, Bool);
1593     scilab_fill_comparisonequal(Identity, MList, M_E, Double, MList, Bool);
1594     scilab_fill_comparisonequal(MList, IdentityComplex, M_E, MList, Double, Bool);
1595     scilab_fill_comparisonequal(IdentityComplex, MList, M_E, Double, MList, Bool);
1596
1597     scilab_fill_comparisonequal(MList, Int8, M_E, MList, Int8, Bool);
1598     scilab_fill_comparisonequal(Int8, MList, M_E, Int8, MList, Bool);
1599     scilab_fill_comparisonequal(MList, UInt8, M_E, MList, UInt8, Bool);
1600     scilab_fill_comparisonequal(UInt8, MList, M_E, UInt8, MList, Bool);
1601
1602     scilab_fill_comparisonequal(MList, Int16, M_E, MList, Int16, Bool);
1603     scilab_fill_comparisonequal(Int16, MList, M_E, Int16, MList, Bool);
1604     scilab_fill_comparisonequal(MList, UInt16, M_E, MList, UInt16, Bool);
1605     scilab_fill_comparisonequal(UInt16, MList, M_E, UInt16, MList, Bool);
1606
1607     scilab_fill_comparisonequal(MList, Int32, M_E, MList, Int32, Bool);
1608     scilab_fill_comparisonequal(Int32, MList, M_E, Int32, MList, Bool);
1609     scilab_fill_comparisonequal(MList, UInt32, M_E, MList, UInt32, Bool);
1610     scilab_fill_comparisonequal(UInt32, MList, M_E, UInt32, MList, Bool);
1611
1612     scilab_fill_comparisonequal(MList, Int64, M_E, MList, Int64, Bool);
1613     scilab_fill_comparisonequal(Int64, MList, M_E, Int64, MList, Bool);
1614     scilab_fill_comparisonequal(MList, UInt64, M_E, MList, UInt64, Bool);
1615     scilab_fill_comparisonequal(UInt64, MList, M_E, UInt64, MList, Bool);
1616
1617     scilab_fill_comparisonequal(MList, ScalarInt8, M_E, MList, Int8, Bool);
1618     scilab_fill_comparisonequal(ScalarInt8, MList, M_E, Int8, MList, Bool);
1619     scilab_fill_comparisonequal(MList, ScalarUInt8, M_E, MList, UInt8, Bool);
1620     scilab_fill_comparisonequal(ScalarUInt8, MList, M_E, UInt8, MList, Bool);
1621
1622     scilab_fill_comparisonequal(MList, ScalarInt16, M_E, MList, Int16, Bool);
1623     scilab_fill_comparisonequal(ScalarInt16, MList, M_E, Int16, MList, Bool);
1624     scilab_fill_comparisonequal(MList, ScalarUInt16, M_E, MList, UInt16, Bool);
1625     scilab_fill_comparisonequal(ScalarUInt16, MList, M_E, UInt16, MList, Bool);
1626
1627     scilab_fill_comparisonequal(MList, ScalarInt32, M_E, MList, Int32, Bool);
1628     scilab_fill_comparisonequal(ScalarInt32, MList, M_E, Int32, MList, Bool);
1629     scilab_fill_comparisonequal(MList, ScalarUInt32, M_E, MList, UInt32, Bool);
1630     scilab_fill_comparisonequal(ScalarUInt32, MList, M_E, UInt32, MList, Bool);
1631
1632     scilab_fill_comparisonequal(MList, ScalarInt64, M_E, MList, Int64, Bool);
1633     scilab_fill_comparisonequal(ScalarInt64, MList, M_E, Int64, MList, Bool);
1634     scilab_fill_comparisonequal(MList, ScalarUInt64, M_E, MList, UInt64, Bool);
1635     scilab_fill_comparisonequal(ScalarUInt64, MList, M_E, UInt64, MList, Bool);
1636
1637     scilab_fill_comparisonequal(MList, String, M_E, MList, String, Bool);
1638     scilab_fill_comparisonequal(String, MList, M_E, String, MList, Bool);
1639     scilab_fill_comparisonequal(MList, ScalarString, M_E, MList, String, Bool);
1640     scilab_fill_comparisonequal(ScalarString, MList, M_E, String, MList, Bool);
1641
1642     scilab_fill_comparisonequal(MList, SparseComplex, M_E, MList, Sparse, Bool);
1643     scilab_fill_comparisonequal(SparseComplex, MList, M_E, Sparse, MList, Bool);
1644
1645     scilab_fill_comparisonequal(MList, Sparse, M_E, MList, Sparse, Bool);
1646     scilab_fill_comparisonequal(Sparse, MList, M_E, Sparse, MList, Bool);
1647
1648     scilab_fill_comparisonequal(MList, SparseBool, M_E, MList, SparseBool, Bool);
1649     scilab_fill_comparisonequal(SparseBool, MList, M_E, SparseBool, MList, Bool);
1650
1651     scilab_fill_comparisonequal(MList, Struct, M_E, MList, Struct, Bool);
1652     scilab_fill_comparisonequal(Struct, MList, M_E, Struct, MList, Bool);
1653
1654     //Cell
1655     scilab_fill_comparisonequal(Cell, Cell, M_M, Cell, Cell, Bool);
1656
1657     scilab_fill_comparisonequal(Cell, Empty, M_E, Cell, Double, Bool);
1658     scilab_fill_comparisonequal(Empty, Cell, E_M, Double, Cell, Bool);
1659
1660     scilab_fill_comparisonequal(Cell, Double, M_E, Cell, Double, Bool);
1661     scilab_fill_comparisonequal(Double, Cell, M_E, Double, Cell, Bool);
1662     scilab_fill_comparisonequal(Cell, DoubleComplex, M_E, Cell, Double, Bool);
1663     scilab_fill_comparisonequal(DoubleComplex, Cell, M_E, Double, Cell, Bool);
1664
1665     scilab_fill_comparisonequal(Cell, ScalarDouble, M_E, Cell, Double, Bool);
1666     scilab_fill_comparisonequal(ScalarDouble, Cell, M_E, Double, Cell, Bool);
1667     scilab_fill_comparisonequal(Cell, ScalarDoubleComplex, M_E, Cell, Double, Bool);
1668     scilab_fill_comparisonequal(ScalarDoubleComplex, Cell, M_E, Double, Cell, Bool);
1669
1670     scilab_fill_comparisonequal(Cell, Empty, M_E, Cell, Double, Bool);
1671     scilab_fill_comparisonequal(Empty, Cell, M_E, Double, Cell, Bool);
1672     scilab_fill_comparisonequal(Cell, Identity, M_E, Cell, Double, Bool);
1673     scilab_fill_comparisonequal(Identity, Cell, M_E, Double, Cell, Bool);
1674     scilab_fill_comparisonequal(Cell, IdentityComplex, M_E, Cell, Double, Bool);
1675     scilab_fill_comparisonequal(IdentityComplex, Cell, M_E, Double, Cell, Bool);
1676
1677     scilab_fill_comparisonequal(Cell, Int8, M_E, Cell, Int8, Bool);
1678     scilab_fill_comparisonequal(Int8, Cell, M_E, Int8, Cell, Bool);
1679     scilab_fill_comparisonequal(Cell, UInt8, M_E, Cell, UInt8, Bool);
1680     scilab_fill_comparisonequal(UInt8, Cell, M_E, UInt8, Cell, Bool);
1681
1682     scilab_fill_comparisonequal(Cell, Int16, M_E, Cell, Int16, Bool);
1683     scilab_fill_comparisonequal(Int16, Cell, M_E, Int16, Cell, Bool);
1684     scilab_fill_comparisonequal(Cell, UInt16, M_E, Cell, UInt16, Bool);
1685     scilab_fill_comparisonequal(UInt16, Cell, M_E, UInt16, Cell, Bool);
1686
1687     scilab_fill_comparisonequal(Cell, Int32, M_E, Cell, Int32, Bool);
1688     scilab_fill_comparisonequal(Int32, Cell, M_E, Int32, Cell, Bool);
1689     scilab_fill_comparisonequal(Cell, UInt32, M_E, Cell, UInt32, Bool);
1690     scilab_fill_comparisonequal(UInt32, Cell, M_E, UInt32, Cell, Bool);
1691
1692     scilab_fill_comparisonequal(Cell, Int64, M_E, Cell, Int64, Bool);
1693     scilab_fill_comparisonequal(Int64, Cell, M_E, Int64, Cell, Bool);
1694     scilab_fill_comparisonequal(Cell, UInt64, M_E, Cell, UInt64, Bool);
1695     scilab_fill_comparisonequal(UInt64, Cell, M_E, UInt64, Cell, Bool);
1696
1697     scilab_fill_comparisonequal(Cell, ScalarInt8, M_E, Cell, Int8, Bool);
1698     scilab_fill_comparisonequal(ScalarInt8, Cell, M_E, Int8, Cell, Bool);
1699     scilab_fill_comparisonequal(Cell, ScalarUInt8, M_E, Cell, UInt8, Bool);
1700     scilab_fill_comparisonequal(ScalarUInt8, Cell, M_E, UInt8, Cell, Bool);
1701
1702     scilab_fill_comparisonequal(Cell, ScalarInt16, M_E, Cell, Int16, Bool);
1703     scilab_fill_comparisonequal(ScalarInt16, Cell, M_E, Int16, Cell, Bool);
1704     scilab_fill_comparisonequal(Cell, ScalarUInt16, M_E, Cell, UInt16, Bool);
1705     scilab_fill_comparisonequal(ScalarUInt16, Cell, M_E, UInt16, Cell, Bool);
1706
1707     scilab_fill_comparisonequal(Cell, ScalarInt32, M_E, Cell, Int32, Bool);
1708     scilab_fill_comparisonequal(ScalarInt32, Cell, M_E, Int32, Cell, Bool);
1709     scilab_fill_comparisonequal(Cell, ScalarUInt32, M_E, Cell, UInt32, Bool);
1710     scilab_fill_comparisonequal(ScalarUInt32, Cell, M_E, UInt32, Cell, Bool);
1711
1712     scilab_fill_comparisonequal(Cell, ScalarInt64, M_E, Cell, Int64, Bool);
1713     scilab_fill_comparisonequal(ScalarInt64, Cell, M_E, Int64, Cell, Bool);
1714     scilab_fill_comparisonequal(Cell, ScalarUInt64, M_E, Cell, UInt64, Bool);
1715     scilab_fill_comparisonequal(ScalarUInt64, Cell, M_E, UInt64, Cell, Bool);
1716
1717     scilab_fill_comparisonequal(Cell, String, M_E, Cell, String, Bool);
1718     scilab_fill_comparisonequal(String, Cell, M_E, String, Cell, Bool);
1719     scilab_fill_comparisonequal(Cell, ScalarString, M_E, Cell, String, Bool);
1720     scilab_fill_comparisonequal(ScalarString, Cell, M_E, String, Cell, Bool);
1721
1722     scilab_fill_comparisonequal(Cell, SparseComplex, M_E, Cell, Sparse, Bool);
1723     scilab_fill_comparisonequal(SparseComplex, Cell, M_E, Sparse, Cell, Bool);
1724
1725     scilab_fill_comparisonequal(Cell, Sparse, M_E, Cell, Sparse, Bool);
1726     scilab_fill_comparisonequal(Sparse, Cell, M_E, Sparse, Cell, Bool);
1727
1728     scilab_fill_comparisonequal(Cell, SparseBool, M_E, Cell, SparseBool, Bool);
1729     scilab_fill_comparisonequal(SparseBool, Cell, M_E, SparseBool, Cell, Bool);
1730
1731     scilab_fill_comparisonequal(Cell, Struct, M_E, Cell, Struct, Bool);
1732     scilab_fill_comparisonequal(Struct, Cell, M_E, Struct, Cell, Bool);
1733
1734     scilab_fill_comparisonequal(Cell, List, M_E, Cell, List, Bool);
1735     scilab_fill_comparisonequal(List, Cell, M_E, List, Cell, Bool);
1736
1737     scilab_fill_comparisonequal(Cell, TList, M_E, Cell, TList, Bool);
1738     scilab_fill_comparisonequal(TList, Cell, M_E, TList, Cell, Bool);
1739
1740     scilab_fill_comparisonequal(Cell, MList, M_E, Cell, MList, Bool);
1741     scilab_fill_comparisonequal(MList, Cell, M_E, MList, Cell, Bool);
1742
1743     //Handle
1744     scilab_fill_comparisonequal(Handle, Handle, M_M, GraphicHandle, GraphicHandle, Bool);
1745
1746     scilab_fill_comparisonequal(Handle, Empty, M_E, GraphicHandle, Double, Bool);
1747     scilab_fill_comparisonequal(Empty, Handle, E_M, Double, GraphicHandle, Bool);
1748
1749     scilab_fill_comparisonequal(Handle, Double, M_E, GraphicHandle, Double, Bool);
1750     scilab_fill_comparisonequal(Double, Handle, M_E, Double, GraphicHandle, Bool);
1751     scilab_fill_comparisonequal(Handle, DoubleComplex, M_E, GraphicHandle, Double, Bool);
1752     scilab_fill_comparisonequal(DoubleComplex, Handle, M_E, Double, GraphicHandle, Bool);
1753
1754     scilab_fill_comparisonequal(Handle, ScalarDouble, M_E, GraphicHandle, Double, Bool);
1755     scilab_fill_comparisonequal(ScalarDouble, Handle, M_E, Double, GraphicHandle, Bool);
1756     scilab_fill_comparisonequal(Handle, ScalarDoubleComplex, M_E, GraphicHandle, Double, Bool);
1757     scilab_fill_comparisonequal(ScalarDoubleComplex, Handle, M_E, Double, GraphicHandle, Bool);
1758
1759     scilab_fill_comparisonequal(Handle, Empty, M_E, GraphicHandle, Double, Bool);
1760     scilab_fill_comparisonequal(Empty, Handle, M_E, Double, GraphicHandle, Bool);
1761     scilab_fill_comparisonequal(Handle, Identity, M_E, GraphicHandle, Double, Bool);
1762     scilab_fill_comparisonequal(Identity, Handle, M_E, Double, GraphicHandle, Bool);
1763     scilab_fill_comparisonequal(Handle, IdentityComplex, M_E, GraphicHandle, Double, Bool);
1764     scilab_fill_comparisonequal(IdentityComplex, Handle, M_E, Double, GraphicHandle, Bool);
1765
1766     scilab_fill_comparisonequal(Handle, Int8, M_E, GraphicHandle, Int8, Bool);
1767     scilab_fill_comparisonequal(Int8, Handle, M_E, Int8, GraphicHandle, Bool);
1768     scilab_fill_comparisonequal(Handle, UInt8, M_E, GraphicHandle, UInt8, Bool);
1769     scilab_fill_comparisonequal(UInt8, Handle, M_E, UInt8, GraphicHandle, Bool);
1770
1771     scilab_fill_comparisonequal(Handle, Int16, M_E, GraphicHandle, Int16, Bool);
1772     scilab_fill_comparisonequal(Int16, Handle, M_E, Int16, GraphicHandle, Bool);
1773     scilab_fill_comparisonequal(Handle, UInt16, M_E, GraphicHandle, UInt16, Bool);
1774     scilab_fill_comparisonequal(UInt16, Handle, M_E, UInt16, GraphicHandle, Bool);
1775
1776     scilab_fill_comparisonequal(Handle, Int32, M_E, GraphicHandle, Int32, Bool);
1777     scilab_fill_comparisonequal(Int32, Handle, M_E, Int32, GraphicHandle, Bool);
1778     scilab_fill_comparisonequal(Handle, UInt32, M_E, GraphicHandle, UInt32, Bool);
1779     scilab_fill_comparisonequal(UInt32, Handle, M_E, UInt32, GraphicHandle, Bool);
1780
1781     scilab_fill_comparisonequal(Handle, Int64, M_E, GraphicHandle, Int64, Bool);
1782     scilab_fill_comparisonequal(Int64, Handle, M_E, Int64, GraphicHandle, Bool);
1783     scilab_fill_comparisonequal(Handle, UInt64, M_E, GraphicHandle, UInt64, Bool);
1784     scilab_fill_comparisonequal(UInt64, Handle, M_E, UInt64, GraphicHandle, Bool);
1785
1786     scilab_fill_comparisonequal(Handle, ScalarInt8, M_E, GraphicHandle, Int8, Bool);
1787     scilab_fill_comparisonequal(ScalarInt8, Handle, M_E, Int8, GraphicHandle, Bool);
1788     scilab_fill_comparisonequal(Handle, ScalarUInt8, M_E, GraphicHandle, UInt8, Bool);
1789     scilab_fill_comparisonequal(ScalarUInt8, Handle, M_E, UInt8, GraphicHandle, Bool);
1790
1791     scilab_fill_comparisonequal(Handle, ScalarInt16, M_E, GraphicHandle, Int16, Bool);
1792     scilab_fill_comparisonequal(ScalarInt16, Handle, M_E, Int16, GraphicHandle, Bool);
1793     scilab_fill_comparisonequal(Handle, ScalarUInt16, M_E, GraphicHandle, UInt16, Bool);
1794     scilab_fill_comparisonequal(ScalarUInt16, Handle, M_E, UInt16, GraphicHandle, Bool);
1795
1796     scilab_fill_comparisonequal(Handle, ScalarInt32, M_E, GraphicHandle, Int32, Bool);
1797     scilab_fill_comparisonequal(ScalarInt32, Handle, M_E, Int32, GraphicHandle, Bool);
1798     scilab_fill_comparisonequal(Handle, ScalarUInt32, M_E, GraphicHandle, UInt32, Bool);
1799     scilab_fill_comparisonequal(ScalarUInt32, Handle, M_E, UInt32, GraphicHandle, Bool);
1800
1801     scilab_fill_comparisonequal(Handle, ScalarInt64, M_E, GraphicHandle, Int64, Bool);
1802     scilab_fill_comparisonequal(ScalarInt64, Handle, M_E, Int64, GraphicHandle, Bool);
1803     scilab_fill_comparisonequal(Handle, ScalarUInt64, M_E, GraphicHandle, UInt64, Bool);
1804     scilab_fill_comparisonequal(ScalarUInt64, Handle, M_E, UInt64, GraphicHandle, Bool);
1805
1806     scilab_fill_comparisonequal(Handle, String, M_E, GraphicHandle, String, Bool);
1807     scilab_fill_comparisonequal(String, Handle, M_E, String, GraphicHandle, Bool);
1808     scilab_fill_comparisonequal(Handle, ScalarString, M_E, GraphicHandle, String, Bool);
1809     scilab_fill_comparisonequal(ScalarString, Handle, M_E, String, GraphicHandle, Bool);
1810
1811     scilab_fill_comparisonequal(Handle, SparseComplex, M_E, GraphicHandle, Sparse, Bool);
1812     scilab_fill_comparisonequal(SparseComplex, Handle, M_E, Sparse, GraphicHandle, Bool);
1813
1814     scilab_fill_comparisonequal(Handle, Sparse, M_E, GraphicHandle, Sparse, Bool);
1815     scilab_fill_comparisonequal(Sparse, Handle, M_E, Sparse, GraphicHandle, Bool);
1816
1817     scilab_fill_comparisonequal(Handle, SparseBool, M_E, GraphicHandle, SparseBool, Bool);
1818     scilab_fill_comparisonequal(SparseBool, Handle, M_E, SparseBool, GraphicHandle, Bool);
1819
1820     scilab_fill_comparisonequal(Handle, Struct, M_E, GraphicHandle, Struct, Bool);
1821     scilab_fill_comparisonequal(Struct, Handle, M_E, Struct, GraphicHandle, Bool);
1822
1823     scilab_fill_comparisonequal(Handle, List, M_E, GraphicHandle, List, Bool);
1824     scilab_fill_comparisonequal(List, Handle, M_E, List, GraphicHandle, Bool);
1825
1826     scilab_fill_comparisonequal(Handle, TList, M_E, GraphicHandle, TList, Bool);
1827     scilab_fill_comparisonequal(TList, Handle, M_E, TList, GraphicHandle, Bool);
1828
1829     scilab_fill_comparisonequal(Handle, MList, M_E, GraphicHandle, MList, Bool);
1830     scilab_fill_comparisonequal(MList, Handle, M_E, MList, GraphicHandle, Bool);
1831
1832     scilab_fill_comparisonequal(Handle, Cell, M_E, GraphicHandle, Cell, Bool);
1833     scilab_fill_comparisonequal(Cell, Handle, M_E, Cell, GraphicHandle, Bool);
1834
1835     //Macro
1836     scilab_fill_comparisonequal(Macro, Macro, MCR_MCR, Macro, Macro, Bool);
1837     scilab_fill_comparisonequal(MacroFile, MacroFile, MCR_MCR, MacroFile, MacroFile, Bool);
1838     scilab_fill_comparisonequal(Macro, MacroFile, MCR_MCR, Macro, MacroFile, Bool);
1839     scilab_fill_comparisonequal(MacroFile, Macro, MCR_MCR, MacroFile, Macro, Bool);
1840
1841     scilab_fill_comparisonequal(Macro, Empty, M_E, Macro, Double, Bool);
1842     scilab_fill_comparisonequal(Empty, Macro, E_M, Double, Macro, Bool);
1843     scilab_fill_comparisonequal(MacroFile, Empty, M_E, MacroFile, Double, Bool);
1844     scilab_fill_comparisonequal(Empty, MacroFile, E_M, Double, MacroFile, Bool);
1845
1846     scilab_fill_comparisonequal(Macro, Double, M_E, Macro, Double, Bool);
1847     scilab_fill_comparisonequal(Double, Macro, M_E, Double, Macro, Bool);
1848     scilab_fill_comparisonequal(Macro, DoubleComplex, M_E, Macro, Double, Bool);
1849     scilab_fill_comparisonequal(DoubleComplex, Macro, M_E, Double, Macro, Bool);
1850
1851     scilab_fill_comparisonequal(Macro, ScalarDouble, M_E, Macro, Double, Bool);
1852     scilab_fill_comparisonequal(ScalarDouble, Macro, M_E, Double, Macro, Bool);
1853     scilab_fill_comparisonequal(Macro, ScalarDoubleComplex, M_E, Macro, Double, Bool);
1854     scilab_fill_comparisonequal(ScalarDoubleComplex, Macro, M_E, Double, Macro, Bool);
1855
1856     scilab_fill_comparisonequal(Macro, Empty, M_E, Macro, Double, Bool);
1857     scilab_fill_comparisonequal(Empty, Macro, M_E, Double, Macro, Bool);
1858     scilab_fill_comparisonequal(Macro, Identity, M_E, Macro, Double, Bool);
1859     scilab_fill_comparisonequal(Identity, Macro, M_E, Double, Macro, Bool);
1860     scilab_fill_comparisonequal(Macro, IdentityComplex, M_E, Macro, Double, Bool);
1861     scilab_fill_comparisonequal(IdentityComplex, Macro, M_E, Double, Macro, Bool);
1862
1863     scilab_fill_comparisonequal(Macro, Int8, M_E, Macro, Int8, Bool);
1864     scilab_fill_comparisonequal(Int8, Macro, M_E, Int8, Macro, Bool);
1865     scilab_fill_comparisonequal(Macro, UInt8, M_E, Macro, UInt8, Bool);
1866     scilab_fill_comparisonequal(UInt8, Macro, M_E, UInt8, Macro, Bool);
1867
1868     scilab_fill_comparisonequal(Macro, Int16, M_E, Macro, Int16, Bool);
1869     scilab_fill_comparisonequal(Int16, Macro, M_E, Int16, Macro, Bool);
1870     scilab_fill_comparisonequal(Macro, UInt16, M_E, Macro, UInt16, Bool);
1871     scilab_fill_comparisonequal(UInt16, Macro, M_E, UInt16, Macro, Bool);
1872
1873     scilab_fill_comparisonequal(Macro, Int32, M_E, Macro, Int32, Bool);
1874     scilab_fill_comparisonequal(Int32, Macro, M_E, Int32, Macro, Bool);
1875     scilab_fill_comparisonequal(Macro, UInt32, M_E, Macro, UInt32, Bool);
1876     scilab_fill_comparisonequal(UInt32, Macro, M_E, UInt32, Macro, Bool);
1877
1878     scilab_fill_comparisonequal(Macro, Int64, M_E, Macro, Int64, Bool);
1879     scilab_fill_comparisonequal(Int64, Macro, M_E, Int64, Macro, Bool);
1880     scilab_fill_comparisonequal(Macro, UInt64, M_E, Macro, UInt64, Bool);
1881     scilab_fill_comparisonequal(UInt64, Macro, M_E, UInt64, Macro, Bool);
1882
1883     scilab_fill_comparisonequal(Macro, ScalarInt8, M_E, Macro, Int8, Bool);
1884     scilab_fill_comparisonequal(ScalarInt8, Macro, M_E, Int8, Macro, Bool);
1885     scilab_fill_comparisonequal(Macro, ScalarUInt8, M_E, Macro, UInt8, Bool);
1886     scilab_fill_comparisonequal(ScalarUInt8, Macro, M_E, UInt8, Macro, Bool);
1887
1888     scilab_fill_comparisonequal(Macro, ScalarInt16, M_E, Macro, Int16, Bool);
1889     scilab_fill_comparisonequal(ScalarInt16, Macro, M_E, Int16, Macro, Bool);
1890     scilab_fill_comparisonequal(Macro, ScalarUInt16, M_E, Macro, UInt16, Bool);
1891     scilab_fill_comparisonequal(ScalarUInt16, Macro, M_E, UInt16, Macro, Bool);
1892
1893     scilab_fill_comparisonequal(Macro, ScalarInt32, M_E, Macro, Int32, Bool);
1894     scilab_fill_comparisonequal(ScalarInt32, Macro, M_E, Int32, Macro, Bool);
1895     scilab_fill_comparisonequal(Macro, ScalarUInt32, M_E, Macro, UInt32, Bool);
1896     scilab_fill_comparisonequal(ScalarUInt32, Macro, M_E, UInt32, Macro, Bool);
1897
1898     scilab_fill_comparisonequal(Macro, ScalarInt64, M_E, Macro, Int64, Bool);
1899     scilab_fill_comparisonequal(ScalarInt64, Macro, M_E, Int64, Macro, Bool);
1900     scilab_fill_comparisonequal(Macro, ScalarUInt64, M_E, Macro, UInt64, Bool);
1901     scilab_fill_comparisonequal(ScalarUInt64, Macro, M_E, UInt64, Macro, Bool);
1902
1903     scilab_fill_comparisonequal(Macro, String, M_E, Macro, String, Bool);
1904     scilab_fill_comparisonequal(String, Macro, M_E, String, Macro, Bool);
1905     scilab_fill_comparisonequal(Macro, ScalarString, M_E, Macro, String, Bool);
1906     scilab_fill_comparisonequal(ScalarString, Macro, M_E, String, Macro, Bool);
1907
1908     scilab_fill_comparisonequal(Macro, SparseComplex, M_E, Macro, Sparse, Bool);
1909     scilab_fill_comparisonequal(SparseComplex, Macro, M_E, Sparse, Macro, Bool);
1910
1911     scilab_fill_comparisonequal(Macro, Sparse, M_E, Macro, Sparse, Bool);
1912     scilab_fill_comparisonequal(Sparse, Macro, M_E, Sparse, Macro, Bool);
1913
1914     scilab_fill_comparisonequal(Macro, SparseBool, M_E, Macro, SparseBool, Bool);
1915     scilab_fill_comparisonequal(SparseBool, Macro, M_E, SparseBool, Macro, Bool);
1916
1917     scilab_fill_comparisonequal(Macro, Struct, M_E, Macro, Struct, Bool);
1918     scilab_fill_comparisonequal(Struct, Macro, M_E, Struct, Macro, Bool);
1919
1920     scilab_fill_comparisonequal(Macro, List, M_E, Macro, List, Bool);
1921     scilab_fill_comparisonequal(List, Macro, M_E, List, Macro, Bool);
1922
1923     scilab_fill_comparisonequal(Macro, TList, M_E, Macro, TList, Bool);
1924     scilab_fill_comparisonequal(TList, Macro, M_E, TList, Macro, Bool);
1925
1926     scilab_fill_comparisonequal(Macro, MList, M_E, Macro, MList, Bool);
1927     scilab_fill_comparisonequal(MList, Macro, M_E, MList, Macro, Bool);
1928
1929     scilab_fill_comparisonequal(Macro, Cell, M_E, Macro, Cell, Bool);
1930     scilab_fill_comparisonequal(Cell, Macro, M_E, Cell, Macro, Bool);
1931
1932     scilab_fill_comparisonequal(Macro, Handle, M_E, Macro, GraphicHandle, Bool);
1933     scilab_fill_comparisonequal(Handle, Macro, M_E, GraphicHandle, Macro, Bool);
1934
1935     scilab_fill_comparisonequal(MacroFile, Double, M_E, MacroFile, Double, Bool);
1936     scilab_fill_comparisonequal(Double, MacroFile, M_E, Double, MacroFile, Bool);
1937     scilab_fill_comparisonequal(MacroFile, DoubleComplex, M_E, MacroFile, Double, Bool);
1938     scilab_fill_comparisonequal(DoubleComplex, MacroFile, M_E, Double, MacroFile, Bool);
1939
1940     scilab_fill_comparisonequal(MacroFile, ScalarDouble, M_E, MacroFile, Double, Bool);
1941     scilab_fill_comparisonequal(ScalarDouble, MacroFile, M_E, Double, MacroFile, Bool);
1942     scilab_fill_comparisonequal(MacroFile, ScalarDoubleComplex, M_E, MacroFile, Double, Bool);
1943     scilab_fill_comparisonequal(ScalarDoubleComplex, MacroFile, M_E, Double, MacroFile, Bool);
1944
1945     scilab_fill_comparisonequal(MacroFile, Empty, M_E, MacroFile, Double, Bool);
1946     scilab_fill_comparisonequal(Empty, MacroFile, M_E, Double, MacroFile, Bool);
1947     scilab_fill_comparisonequal(MacroFile, Identity, M_E, MacroFile, Double, Bool);
1948     scilab_fill_comparisonequal(Identity, MacroFile, M_E, Double, MacroFile, Bool);
1949     scilab_fill_comparisonequal(MacroFile, IdentityComplex, M_E, MacroFile, Double, Bool);
1950     scilab_fill_comparisonequal(IdentityComplex, MacroFile, M_E, Double, MacroFile, Bool);
1951
1952     scilab_fill_comparisonequal(MacroFile, Int8, M_E, MacroFile, Int8, Bool);
1953     scilab_fill_comparisonequal(Int8, MacroFile, M_E, Int8, MacroFile, Bool);
1954     scilab_fill_comparisonequal(MacroFile, UInt8, M_E, MacroFile, UInt8, Bool);
1955     scilab_fill_comparisonequal(UInt8, MacroFile, M_E, UInt8, MacroFile, Bool);
1956
1957     scilab_fill_comparisonequal(MacroFile, Int16, M_E, MacroFile, Int16, Bool);
1958     scilab_fill_comparisonequal(Int16, MacroFile, M_E, Int16, MacroFile, Bool);
1959     scilab_fill_comparisonequal(MacroFile, UInt16, M_E, MacroFile, UInt16, Bool);
1960     scilab_fill_comparisonequal(UInt16, MacroFile, M_E, UInt16, MacroFile, Bool);
1961
1962     scilab_fill_comparisonequal(MacroFile, Int32, M_E, MacroFile, Int32, Bool);
1963     scilab_fill_comparisonequal(Int32, MacroFile, M_E, Int32, MacroFile, Bool);
1964     scilab_fill_comparisonequal(MacroFile, UInt32, M_E, MacroFile, UInt32, Bool);
1965     scilab_fill_comparisonequal(UInt32, MacroFile, M_E, UInt32, MacroFile, Bool);
1966
1967     scilab_fill_comparisonequal(MacroFile, Int64, M_E, MacroFile, Int64, Bool);
1968     scilab_fill_comparisonequal(Int64, MacroFile, M_E, Int64, MacroFile, Bool);
1969     scilab_fill_comparisonequal(MacroFile, UInt64, M_E, MacroFile, UInt64, Bool);
1970     scilab_fill_comparisonequal(UInt64, MacroFile, M_E, UInt64, MacroFile, Bool);
1971
1972     scilab_fill_comparisonequal(MacroFile, ScalarInt8, M_E, MacroFile, Int8, Bool);
1973     scilab_fill_comparisonequal(ScalarInt8, MacroFile, M_E, Int8, MacroFile, Bool);
1974     scilab_fill_comparisonequal(MacroFile, ScalarUInt8, M_E, MacroFile, UInt8, Bool);
1975     scilab_fill_comparisonequal(ScalarUInt8, MacroFile, M_E, UInt8, MacroFile, Bool);
1976
1977     scilab_fill_comparisonequal(MacroFile, ScalarInt16, M_E, MacroFile, Int16, Bool);
1978     scilab_fill_comparisonequal(ScalarInt16, MacroFile, M_E, Int16, MacroFile, Bool);
1979     scilab_fill_comparisonequal(MacroFile, ScalarUInt16, M_E, MacroFile, UInt16, Bool);
1980     scilab_fill_comparisonequal(ScalarUInt16, MacroFile, M_E, UInt16, MacroFile, Bool);
1981
1982     scilab_fill_comparisonequal(MacroFile, ScalarInt32, M_E, MacroFile, Int32, Bool);
1983     scilab_fill_comparisonequal(ScalarInt32, MacroFile, M_E, Int32, MacroFile, Bool);
1984     scilab_fill_comparisonequal(MacroFile, ScalarUInt32, M_E, MacroFile, UInt32, Bool);
1985     scilab_fill_comparisonequal(ScalarUInt32, MacroFile, M_E, UInt32, MacroFile, Bool);
1986
1987     scilab_fill_comparisonequal(MacroFile, ScalarInt64, M_E, MacroFile, Int64, Bool);
1988     scilab_fill_comparisonequal(ScalarInt64, MacroFile, M_E, Int64, MacroFile, Bool);
1989     scilab_fill_comparisonequal(MacroFile, ScalarUInt64, M_E, MacroFile, UInt64, Bool);
1990     scilab_fill_comparisonequal(ScalarUInt64, MacroFile, M_E, UInt64, MacroFile, Bool);
1991
1992     scilab_fill_comparisonequal(MacroFile, String, M_E, MacroFile, String, Bool);
1993     scilab_fill_comparisonequal(String, MacroFile, M_E, String, MacroFile, Bool);
1994     scilab_fill_comparisonequal(MacroFile, ScalarString, M_E, MacroFile, String, Bool);
1995     scilab_fill_comparisonequal(ScalarString, MacroFile, M_E, String, MacroFile, Bool);
1996
1997     scilab_fill_comparisonequal(MacroFile, SparseComplex, M_E, MacroFile, Sparse, Bool);
1998     scilab_fill_comparisonequal(SparseComplex, MacroFile, M_E, Sparse, MacroFile, Bool);
1999
2000     scilab_fill_comparisonequal(MacroFile, Sparse, M_E, MacroFile, Sparse, Bool);
2001     scilab_fill_comparisonequal(Sparse, MacroFile, M_E, Sparse, MacroFile, Bool);
2002
2003     scilab_fill_comparisonequal(MacroFile, SparseBool, M_E, MacroFile, SparseBool, Bool);
2004     scilab_fill_comparisonequal(SparseBool, MacroFile, M_E, SparseBool, MacroFile, Bool);
2005
2006     scilab_fill_comparisonequal(MacroFile, Struct, M_E, MacroFile, Struct, Bool);
2007     scilab_fill_comparisonequal(Struct, MacroFile, M_E, Struct, MacroFile, Bool);
2008
2009     scilab_fill_comparisonequal(MacroFile, List, M_E, MacroFile, List, Bool);
2010     scilab_fill_comparisonequal(List, MacroFile, M_E, List, MacroFile, Bool);
2011
2012     scilab_fill_comparisonequal(MacroFile, TList, M_E, MacroFile, TList, Bool);
2013     scilab_fill_comparisonequal(TList, MacroFile, M_E, TList, MacroFile, Bool);
2014
2015     scilab_fill_comparisonequal(MacroFile, MList, M_E, MacroFile, MList, Bool);
2016     scilab_fill_comparisonequal(MList, MacroFile, M_E, MList, MacroFile, Bool);
2017
2018     scilab_fill_comparisonequal(MacroFile, Cell, M_E, MacroFile, Cell, Bool);
2019     scilab_fill_comparisonequal(Cell, MacroFile, M_E, Cell, MacroFile, Bool);
2020
2021     scilab_fill_comparisonequal(MacroFile, Handle, M_E, MacroFile, GraphicHandle, Bool);
2022     scilab_fill_comparisonequal(Handle, MacroFile, M_E, GraphicHandle, MacroFile, Bool);
2023
2024     //ScalarHandle
2025     scilab_fill_comparisonequal(ScalarHandle, ScalarHandle, M_M, GraphicHandle, GraphicHandle, Bool);
2026     scilab_fill_comparisonequal(Handle, ScalarHandle, M_M, GraphicHandle, GraphicHandle, Bool);
2027     scilab_fill_comparisonequal(ScalarHandle, Handle, M_M, GraphicHandle, GraphicHandle, Bool);
2028
2029     scilab_fill_comparisonequal(ScalarHandle, Empty, M_E, GraphicHandle, Double, Bool);
2030     scilab_fill_comparisonequal(Empty, ScalarHandle, E_M, Double, GraphicHandle, Bool);
2031
2032     scilab_fill_comparisonequal(ScalarHandle, Double, M_E, GraphicHandle, Double, Bool);
2033     scilab_fill_comparisonequal(Double, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2034     scilab_fill_comparisonequal(ScalarHandle, DoubleComplex, M_E, GraphicHandle, Double, Bool);
2035     scilab_fill_comparisonequal(DoubleComplex, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2036
2037     scilab_fill_comparisonequal(ScalarHandle, ScalarDouble, M_E, GraphicHandle, Double, Bool);
2038     scilab_fill_comparisonequal(ScalarDouble, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2039     scilab_fill_comparisonequal(ScalarHandle, ScalarDoubleComplex, M_E, GraphicHandle, Double, Bool);
2040     scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2041
2042     scilab_fill_comparisonequal(ScalarHandle, Empty, M_E, GraphicHandle, Double, Bool);
2043     scilab_fill_comparisonequal(Empty, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2044     scilab_fill_comparisonequal(ScalarHandle, Identity, M_E, GraphicHandle, Double, Bool);
2045     scilab_fill_comparisonequal(Identity, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2046     scilab_fill_comparisonequal(ScalarHandle, IdentityComplex, M_E, GraphicHandle, Double, Bool);
2047     scilab_fill_comparisonequal(IdentityComplex, ScalarHandle, M_E, Double, GraphicHandle, Bool);
2048
2049     scilab_fill_comparisonequal(ScalarHandle, Int8, M_E, GraphicHandle, Int8, Bool);
2050     scilab_fill_comparisonequal(Int8, ScalarHandle, M_E, Int8, GraphicHandle, Bool);
2051     scilab_fill_comparisonequal(ScalarHandle, UInt8, M_E, GraphicHandle, UInt8, Bool);
2052     scilab_fill_comparisonequal(UInt8, ScalarHandle, M_E, UInt8, GraphicHandle, Bool);
2053
2054     scilab_fill_comparisonequal(ScalarHandle, Int16, M_E, GraphicHandle, Int16, Bool);
2055     scilab_fill_comparisonequal(Int16, ScalarHandle, M_E, Int16, GraphicHandle, Bool);
2056     scilab_fill_comparisonequal(ScalarHandle, UInt16, M_E, GraphicHandle, UInt16, Bool);
2057     scilab_fill_comparisonequal(UInt16, ScalarHandle, M_E, UInt16, GraphicHandle, Bool);
2058
2059     scilab_fill_comparisonequal(ScalarHandle, Int32, M_E, GraphicHandle, Int32, Bool);
2060     scilab_fill_comparisonequal(Int32, ScalarHandle, M_E, Int32, GraphicHandle, Bool);
2061     scilab_fill_comparisonequal(ScalarHandle, UInt32, M_E, GraphicHandle, UInt32, Bool);
2062     scilab_fill_comparisonequal(UInt32, ScalarHandle, M_E, UInt32, GraphicHandle, Bool);
2063
2064     scilab_fill_comparisonequal(ScalarHandle, Int64, M_E, GraphicHandle, Int64, Bool);
2065     scilab_fill_comparisonequal(Int64, ScalarHandle, M_E, Int64, GraphicHandle, Bool);
2066     scilab_fill_comparisonequal(ScalarHandle, UInt64, M_E, GraphicHandle, UInt64, Bool);
2067     scilab_fill_comparisonequal(UInt64, ScalarHandle, M_E, UInt64, GraphicHandle, Bool);
2068
2069     scilab_fill_comparisonequal(ScalarHandle, ScalarInt8, M_E, GraphicHandle, Int8, Bool);
2070     scilab_fill_comparisonequal(ScalarInt8, ScalarHandle, M_E, Int8, GraphicHandle, Bool);
2071     scilab_fill_comparisonequal(ScalarHandle, ScalarUInt8, M_E, GraphicHandle, UInt8, Bool);
2072     scilab_fill_comparisonequal(ScalarUInt8, ScalarHandle, M_E, UInt8, GraphicHandle, Bool);
2073
2074     scilab_fill_comparisonequal(ScalarHandle, ScalarInt16, M_E, GraphicHandle, Int16, Bool);
2075     scilab_fill_comparisonequal(ScalarInt16, ScalarHandle, M_E, Int16, GraphicHandle, Bool);
2076     scilab_fill_comparisonequal(ScalarHandle, ScalarUInt16, M_E, GraphicHandle, UInt16, Bool);
2077     scilab_fill_comparisonequal(ScalarUInt16, ScalarHandle, M_E, UInt16, GraphicHandle, Bool);
2078
2079     scilab_fill_comparisonequal(ScalarHandle, ScalarInt32, M_E, GraphicHandle, Int32, Bool);
2080     scilab_fill_comparisonequal(ScalarInt32, ScalarHandle, M_E, Int32, GraphicHandle, Bool);
2081     scilab_fill_comparisonequal(ScalarHandle, ScalarUInt32, M_E, GraphicHandle, UInt32, Bool);
2082     scilab_fill_comparisonequal(ScalarUInt32, ScalarHandle, M_E, UInt32, GraphicHandle, Bool);
2083
2084     scilab_fill_comparisonequal(ScalarHandle, ScalarInt64, M_E, GraphicHandle, Int64, Bool);
2085     scilab_fill_comparisonequal(ScalarInt64, ScalarHandle, M_E, Int64, GraphicHandle, Bool);
2086     scilab_fill_comparisonequal(ScalarHandle, ScalarUInt64, M_E, GraphicHandle, UInt64, Bool);
2087     scilab_fill_comparisonequal(ScalarUInt64, ScalarHandle, M_E, UInt64, GraphicHandle, Bool);
2088
2089     scilab_fill_comparisonequal(ScalarHandle, String, M_E, GraphicHandle, String, Bool);
2090     scilab_fill_comparisonequal(String, ScalarHandle, M_E, String, GraphicHandle, Bool);
2091     scilab_fill_comparisonequal(ScalarHandle, ScalarString, M_E, GraphicHandle, String, Bool);
2092     scilab_fill_comparisonequal(ScalarString, ScalarHandle, M_E, String, GraphicHandle, Bool);
2093
2094     scilab_fill_comparisonequal(ScalarHandle, SparseComplex, M_E, GraphicHandle, Sparse, Bool);
2095     scilab_fill_comparisonequal(SparseComplex, ScalarHandle, M_E, Sparse, GraphicHandle, Bool);
2096
2097     scilab_fill_comparisonequal(ScalarHandle, Sparse, M_E, GraphicHandle, Sparse, Bool);
2098     scilab_fill_comparisonequal(Sparse, ScalarHandle, M_E, Sparse, GraphicHandle, Bool);
2099
2100     scilab_fill_comparisonequal(ScalarHandle, SparseBool, M_E, GraphicHandle, SparseBool, Bool);
2101     scilab_fill_comparisonequal(SparseBool, ScalarHandle, M_E, SparseBool, GraphicHandle, Bool);
2102
2103     scilab_fill_comparisonequal(ScalarHandle, Struct, M_E, GraphicHandle, Struct, Bool);
2104     scilab_fill_comparisonequal(Struct, ScalarHandle, M_E, Struct, GraphicHandle, Bool);
2105
2106     scilab_fill_comparisonequal(ScalarHandle, List, M_E, GraphicHandle, List, Bool);
2107     scilab_fill_comparisonequal(List, ScalarHandle, M_E, List, GraphicHandle, Bool);
2108
2109     scilab_fill_comparisonequal(ScalarHandle, TList, M_E, GraphicHandle, TList, Bool);
2110     scilab_fill_comparisonequal(TList, ScalarHandle, M_E, TList, GraphicHandle, Bool);
2111
2112     scilab_fill_comparisonequal(ScalarHandle, MList, M_E, GraphicHandle, MList, Bool);
2113     scilab_fill_comparisonequal(MList, ScalarHandle, M_E, MList, GraphicHandle, Bool);
2114
2115     scilab_fill_comparisonequal(ScalarHandle, Cell, M_E, GraphicHandle, Cell, Bool);
2116     scilab_fill_comparisonequal(Cell, ScalarHandle, M_E, Cell, GraphicHandle, Bool);
2117
2118     scilab_fill_comparisonequal(ScalarHandle, Macro, M_E, GraphicHandle, Macro, Bool);
2119     scilab_fill_comparisonequal(Macro, ScalarHandle, M_E, Macro, GraphicHandle, Bool);
2120     scilab_fill_comparisonequal(ScalarHandle, MacroFile, M_E, GraphicHandle, MacroFile, Bool);
2121     scilab_fill_comparisonequal(MacroFile, ScalarHandle, M_E, MacroFile, GraphicHandle, Bool);
2122
2123     //UserType
2124     scilab_fill_comparisonequal(UserType, UserType, UT_UT, UserType, UserType, Bool);
2125
2126 #undef scilab_fill_comparisonequal
2127
2128 }
2129
2130 InternalType *GenericComparisonEqual(InternalType *_pLeftOperand, InternalType *_pRightOperand)
2131 {
2132     InternalType *pResult = NULL;
2133
2134     compequal_function compequal = pComparisonEqualfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
2135     if (compequal)
2136     {
2137         pResult = compequal(_pLeftOperand, _pRightOperand);
2138         if (pResult)
2139         {
2140             return pResult;
2141         }
2142     }
2143
2144     /*
2145     ** Default case : Return NULL will Call Overloading.
2146     */
2147     return NULL;
2148 }
2149
2150
2151 //Matrix == x
2152 template<class T, class U, class O>
2153 InternalType* compequal_M_M(T *_pL, U *_pR)
2154 {
2155     //check dims
2156     int iDimsL = _pL->getDims();
2157     int iDimsR = _pR->getDims();
2158
2159     if (iDimsL != iDimsR)
2160     {
2161         return new Bool(false);
2162     }
2163
2164     int* piDimsL = _pL->getDimsArray();
2165     int* piDimsR = _pR->getDimsArray();
2166
2167     for (int i = 0; i < iDimsL; ++i)
2168     {
2169         if (piDimsL[i] != piDimsR[i])
2170         {
2171             return new Bool(false);
2172         }
2173     }
2174
2175     O* pOut = new O(iDimsL, piDimsL);
2176     int iSize = pOut->getSize();
2177
2178     compequal(_pL->get(), iSize, _pR->get(), pOut->get());
2179     return pOut;
2180 }
2181
2182 template<class T, class U, class O>
2183 InternalType* compequal_M_MC(T *_pL, U *_pR)
2184 {
2185     //check dims
2186     int iDimsL = _pL->getDims();
2187     int iDimsR = _pR->getDims();
2188
2189     if (iDimsL != iDimsR)
2190     {
2191         return new Bool(false);
2192     }
2193
2194     int* piDimsL = _pL->getDimsArray();
2195     int* piDimsR = _pR->getDimsArray();
2196
2197     for (int i = 0; i < iDimsL; ++i)
2198     {
2199         if (piDimsL[i] != piDimsR[i])
2200         {
2201             return new Bool(false);
2202         }
2203     }
2204
2205     O* pOut = new O(iDimsL, piDimsL);
2206     int iSize = pOut->getSize();
2207
2208     compequal(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get());
2209     return pOut;
2210 }
2211
2212 template<class T, class U, class O>
2213 InternalType* compequal_M_S(T *_pL, U *_pR)
2214 {
2215     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2216     compequal(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
2217     return pOut;
2218 }
2219
2220 template<class T, class U, class O>
2221 InternalType* compequal_M_SC(T *_pL, U *_pR)
2222 {
2223     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2224     compequal(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
2225     return pOut;
2226 }
2227
2228 template<class T, class U, class O>
2229 InternalType* compequal_M_I(T *_pL, U *_pR)
2230 {
2231     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2232     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
2233     compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
2234     delete pIdentity;
2235     return pOut;
2236 }
2237
2238 template<class T, class U, class O>
2239 InternalType* compequal_M_IC(T *_pL, U *_pR)
2240 {
2241     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2242     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
2243     compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
2244     delete pIdentity;
2245     return pOut;
2246 }
2247
2248 template<class T, class U, class O>
2249 InternalType* compequal_M_E(T *_pL, U *_pR)
2250 {
2251     return new Bool(false);
2252 }
2253
2254 template<class T, class U, class O>
2255 InternalType* compequal_E_M(T *_pL, U *_pR)
2256 {
2257     return new Bool(false);
2258 }
2259
2260 template<class T, class U, class O>
2261 InternalType* compequal_E_E(T *_pL, U *_pR)
2262 {
2263     return new Bool(true);
2264 }
2265
2266 //B == x
2267 template<class T, class U, class O>
2268 InternalType* compequal_B_M(T *_pL, U *_pR)
2269 {
2270     //check dims
2271     int iDimsL = _pL->getDims();
2272     int iDimsR = _pR->getDims();
2273     int* piDimsR = _pR->getDimsArray();
2274
2275     if (_pL->isScalar() == false)
2276     {
2277         if (iDimsL != iDimsR)
2278         {
2279             return new Bool(false);
2280         }
2281
2282         int* piDimsL = _pL->getDimsArray();
2283
2284         for (int i = 0; i < iDimsL; ++i)
2285         {
2286             if (piDimsL[i] != piDimsR[i])
2287             {
2288                 return new Bool(false);
2289             }
2290         }
2291     }
2292
2293     O* pOut = new O(iDimsR, piDimsR);
2294
2295     pOut->setFalse();
2296
2297     return pOut;
2298 }
2299
2300 template<class T, class U, class O>
2301 InternalType* compequal_M_B(T *_pL, U *_pR)
2302 {
2303     //check dims
2304     int iDimsL = _pL->getDims();
2305     int iDimsR = _pR->getDims();
2306     int* piDimsL = _pL->getDimsArray();
2307
2308     if (_pR->isScalar() == false)
2309     {
2310         if (iDimsL != iDimsR)
2311         {
2312             return new Bool(false);
2313         }
2314
2315         int* piDimsR = _pR->getDimsArray();
2316
2317         for (int i = 0; i < iDimsL; ++i)
2318         {
2319             if (piDimsL[i] != piDimsR[i])
2320             {
2321                 return new Bool(false);
2322             }
2323         }
2324     }
2325
2326     O* pOut = new O(iDimsL, piDimsL);
2327
2328     pOut->setFalse();
2329
2330     return pOut;
2331 }
2332
2333 //B == x
2334 template<class T, class U, class O>
2335 InternalType* compequal_B_S(T *_pL, U *_pR)
2336 {
2337
2338     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2339
2340     pOut->setFalse();
2341
2342     return pOut;
2343 }
2344
2345 template<class T, class U, class O>
2346 InternalType* compequal_S_B(T *_pL, U *_pR)
2347 {
2348
2349     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
2350
2351     pOut->setFalse();
2352
2353     return pOut;
2354 }
2355
2356
2357
2358 //Matrix complex == x
2359 template<class T, class U, class O>
2360 InternalType* compequal_MC_M(T *_pL, U *_pR)
2361 {
2362     //check dims
2363     int iDimsL = _pL->getDims();
2364     int iDimsR = _pR->getDims();
2365
2366     if (iDimsL != iDimsR)
2367     {
2368         return new Bool(false);
2369     }
2370
2371     int* piDimsL = _pL->getDimsArray();
2372     int* piDimsR = _pR->getDimsArray();
2373
2374     for (int i = 0; i < iDimsL; ++i)
2375     {
2376         if (piDimsL[i] != piDimsR[i])
2377         {
2378             return new Bool(false);
2379         }
2380     }
2381
2382     O* pOut = new O(iDimsL, piDimsL);
2383     int iSize = pOut->getSize();
2384
2385     compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get());
2386     return pOut;
2387 }
2388
2389 template<class T, class U, class O>
2390 InternalType* compequal_MC_MC(T *_pL, U *_pR)
2391 {
2392     //check dims
2393     int iDimsL = _pL->getDims();
2394     int iDimsR = _pR->getDims();
2395
2396     if (iDimsL != iDimsR)
2397     {
2398         return new Bool(false);
2399     }
2400
2401     int* piDimsL = _pL->getDimsArray();
2402     int* piDimsR = _pR->getDimsArray();
2403
2404     for (int i = 0; i < iDimsL; ++i)
2405     {
2406         if (piDimsL[i] != piDimsR[i])
2407         {
2408             return new Bool(false);
2409         }
2410     }
2411
2412     O* pOut = new O(iDimsL, piDimsL);
2413     int iSize = pOut->getSize();
2414
2415     compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get());
2416     return pOut;
2417 }
2418
2419 template<class T, class U, class O>
2420 InternalType* compequal_MC_S(T *_pL, U *_pR)
2421 {
2422     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2423     compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get());
2424     return pOut;
2425 }
2426
2427 template<class T, class U, class O>
2428 InternalType* compequal_MC_SC(T *_pL, U *_pR)
2429 {
2430     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2431     compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
2432     return pOut;
2433 }
2434
2435 template<class T, class U, class O>
2436 InternalType* compequal_MC_I(T *_pL, U *_pR)
2437 {
2438     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2439     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
2440     compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
2441     delete pIdentity;
2442     return pOut;
2443 }
2444
2445 template<class T, class U, class O>
2446 InternalType* compequal_MC_IC(T *_pL, U *_pR)
2447 {
2448     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
2449     Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
2450     compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
2451     delete pIdentity;
2452     return pOut;
2453 }
2454
2455 //Scalar == x
2456 template<class T, class U, class O>
2457 InternalType* compequal_S_M(T *_pL, U *_pR)
2458 {
2459     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
2460     compequal(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
2461     return pOut;
2462 }
2463
2464 template<class T, class U, class O>
2465 InternalType* compequal_S_MC(T *_pL, U *_pR)
2466 {
2467     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
2468     compequal(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
2469     return pOut;
2470 }
2471
2472 template<class T, class U, class O>
2473 InternalType* compequal_S_S(T *_pL, U *_pR)
2474 {
2475     O* pOut = new O(1, 1);
2476     compequal(_pL->get(0), _pR->get(0), pOut->get());
2477     return pOut;
2478 }
2479
2480 template<class T, class U, class O>
2481 InternalType* compequal_S_SC(T *_pL, U *_pR)
2482 {
2483     O* pOut = new O(1, 1);
2484     compequal(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get());
2485     return pOut;
2486 }
2487
2488 template<class T, class U, class O>
2489 InternalType* compequal_S_I(T *_pL, U *_pR)
2490 {
2491     O* pOut = new O(1, 1);
2492     compequal(_pL->get(0), _pR->get(0), pOut->get());
2493     return pOut;
2494 }
2495
2496 template<class T, class U, class O>
2497 InternalType* compequal_S_IC(T *_pL, U *_pR)
2498 {
2499
2500     O* pOut = new  Bool(false);
2501     compequal(_pL->get(0), 1, _pR->get(), _pR->getImg(), pOut->get());
2502     return pOut;
2503 }
2504 //Scalar complex == x
2505 template<class T, class U, class O>
2506 InternalType* compequal_SC_M(T *_pL, U *_pR)
2507 {
2508     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
2509     compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), pOut->get());
2510     return pOut;
2511 }
2512
2513 template<class T, class U, class O>
2514 InternalType* compequal_SC_MC(T *_pL, U *_pR)
2515 {
2516     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
2517     compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
2518     return pOut;
2519 }
2520
2521 template<class T, class U, class O>
2522 InternalType* compequal_SC_S(T *_pL, U *_pR)
2523 {
2524     O* pOut = new O(false);
2525     if (_pL->getImg(0) == 0)
2526     {
2527         compequal(_pL->get(0), _pR->get(0), pOut->get());
2528     }
2529     return pOut;
2530 }
2531
2532 template<class T, class U, class O>
2533 InternalType* compequal_SC_SC(T *_pL, U *_pR)
2534 {
2535     O* pOut = new O(true);
2536     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
2537     return pOut;
2538 }
2539
2540 template<class T, class U, class O>
2541 InternalType* compequal_SC_I(T *_pL, U *_pR)
2542 {
2543     O* pOut = new Bool(false);
2544     if (_pL->getImg(0) == 0)
2545     {
2546         compequal(_pL->get(0), _pR->get(0), pOut->get());
2547     }
2548     return pOut;
2549 }
2550
2551 template<class T, class U, class O>
2552 InternalType* compequal_SC_IC(T *_pL, U *_pR)
2553 {
2554     O* pOut = new Bool(false);
2555     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
2556     return pOut;
2557 }
2558
2559 //Identity == x
2560 template<class T, class U, class O>
2561 InternalType* compequal_I_M(T *_pL, U *_pR)
2562 {
2563     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2564     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
2565     compequal(pIdentity->get(), pOut->getSize(), _pR->get(), pOut->get());
2566     delete pIdentity;
2567     return pOut;
2568 }
2569
2570 template<class T, class U, class O>
2571 InternalType* compequal_I_MC(T *_pL, U *_pR)
2572 {
2573     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2574     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
2575     compequal(pIdentity->get(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
2576     delete pIdentity;
2577     return pOut;
2578 }
2579
2580 template<class T, class U, class O>
2581 InternalType* compequal_I_S(T *_pL, U *_pR)
2582 {
2583     O* pOut = new Bool(1, 1);
2584     compequal(_pL->get(0), _pR->get(0), pOut->get());
2585     return pOut;
2586 }
2587
2588 template<class T, class U, class O>
2589 InternalType* compequal_I_SC(T *_pL, U *_pR)
2590 {
2591     return compequal_SC_I<U, T, O>(_pR, _pL);
2592 }
2593
2594 template<class T, class U, class O>
2595 InternalType* compequal_I_I(T *_pL, U *_pR)
2596 {
2597     O* pOut = new Bool(1, 1);
2598     compequal(_pL->get(0), _pR->get(0), pOut->get());
2599     return pOut;
2600 }
2601
2602 template<class T, class U, class O>
2603 InternalType* compequal_I_IC(T *_pL, U *_pR)
2604 {
2605     O* pOut = new Bool(false);
2606     if (_pR->getImg(0) == 0)
2607     {
2608         compequal(_pL->get(0), _pR->get(0), pOut->get());
2609     }
2610     return pOut;
2611 }
2612
2613 //Identity complex == x
2614 template<class T, class U, class O>
2615 InternalType* compequal_IC_M(T *_pL, U *_pR)
2616 {
2617     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2618     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
2619     compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), pOut->get());
2620     delete pIdentity;
2621     return pOut;
2622 }
2623
2624 template<class T, class U, class O>
2625 InternalType* compequal_IC_MC(T *_pL, U *_pR)
2626 {
2627     O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
2628     Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
2629     compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
2630     delete pIdentity;
2631     return pOut;
2632 }
2633
2634 template<class T, class U, class O>
2635 InternalType* compequal_IC_S(T *_pL, U *_pR)
2636 {
2637     O* pOut = new Bool(false);
2638     if (_pL->getImg(0) == 0)
2639     {
2640         compequal(_pL->get(0), _pR->get(0), pOut->get());
2641     }
2642     return pOut;
2643 }
2644
2645 template<class T, class U, class O>
2646 InternalType* compequal_IC_SC(T *_pL, U *_pR)
2647 {
2648     O* pOut = new Bool(1, 1);
2649     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
2650     return pOut;
2651 }
2652
2653 template<class T, class U, class O>
2654 InternalType* compequal_IC_I(T *_pL, U *_pR)
2655 {
2656     O* pOut = new Bool(false);
2657     if (_pL->getImg(0) == 0)
2658     {
2659         compequal(_pL->get(0), _pR->get(0), pOut->get());
2660     }
2661     return pOut;
2662 }
2663
2664 template<class T, class U, class O>
2665 InternalType* compequal_IC_IC(T *_pL, U *_pR)
2666 {
2667     O* pOut = new Bool(1, 1);
2668     compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
2669     return pOut;
2670 }
2671
2672 template<>
2673 InternalType* compequal_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
2674 {
2675     //pending changes
2676     if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
2677     {
2678         return new Bool(false);
2679     }
2680
2681     return _pR->newEqualTo(*_pL);
2682 }
2683
2684 template<>
2685 InternalType* compequal_M_M<Sparse, Sparse, SparseBool>(Sparse* _pL, Sparse* _pR)
2686 {
2687     //pending changes
2688     if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
2689     {
2690         return new Bool(false);
2691     }
2692
2693     //int nnzL = static_cast<int>(_pL->nonZeros());
2694     //int rowL = _pL->getRows();
2695     //int colL = _pL->getCols();
2696     //std::vector<int> rowcolL(nnzL * 2, 0);
2697     //_pL->outputRowCol(rowcolL.data());
2698
2699     //int nnzR = static_cast<int>(_pR->nonZeros());
2700     //int rowR = _pR->getRows();
2701     //int colR = _pR->getCols();
2702     //std::vector<int> rowcolR(nnzR * 2, 0);
2703     //_pR->outputRowCol(rowcolR.data());
2704
2705     //int row = std::max(rowL, rowR);
2706     //int col = std::max(colL, colR);
2707
2708     ////create a boolean sparse matrix with dims of sparses
2709     //types::SparseBool* ret = new types::SparseBool(row, col);
2710     //ret->setTrue(false);
2711
2712     ////set %f in each pL values
2713     //for (int i = 0; i < nnzL; ++i)
2714     //{
2715     //    ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, false, false);
2716     //}
2717
2718     ////set _pR[i] == _pL[i] for each _pR values
2719     //if(_pL->isComplex() || _pR->isComplex())
2720     //{
2721     //    for (int i = 0; i < nnzR; ++i)
2722     //    {
2723     //        std::complex<double> l = _pL->getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
2724     //        std::complex<double> r = _pR->getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
2725     //        ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
2726     //    }
2727     //}
2728     //else
2729     //{
2730     //    for (int i = 0; i < nnzR; ++i)
2731     //    {
2732     //        double l = _pL->get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
2733     //        double r = _pR->get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
2734     //        ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
2735     //    }
2736     //}
2737
2738     //ret->finalize();
2739     //return ret;
2740
2741
2742     return _pR->newEqualTo(*_pL);
2743 }
2744
2745 //[] == SP
2746 template<>
2747 InternalType* compequal_M_M<Double, Sparse, Bool>(Double* _pL, Sparse* _pR)
2748 {
2749     return new Bool(false);
2750 }
2751
2752 //SP == []
2753 template<>
2754 InternalType* compequal_M_M<Sparse, Double, Bool>(Sparse* _pL, Double* _pR)
2755 {
2756     return new Bool(false);
2757 }
2758
2759 //sparse
2760 template<class T, class U, class O>
2761 InternalType* compequal_M_SP(T* _pL, U* _pR)
2762 {
2763     //pending changes
2764
2765     //D -> SP == SP
2766     Sparse* pspConvert = NULL;
2767     types::SparseBool* pOut = NULL;
2768
2769
2770     if (_pL->isScalar())
2771     {
2772         int iSizeOut = _pR->getSize();
2773         if (_pL->isComplex())
2774         {
2775             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
2776             std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
2777             for (int i = 0; i < iSizeOut; i++)
2778             {
2779                 pspConvert->set(i, stComplex);
2780             }
2781         }
2782         else
2783         {
2784             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
2785             for (int i = 0; i < iSizeOut; i++)
2786             {
2787                 pspConvert->set(i, (double)_pL->get(0));
2788             }
2789         }
2790     }
2791     else
2792     {
2793         //check dimensions
2794         if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2795         {
2796             return new Bool(false);
2797         }
2798
2799         int iSizeOut = _pR->getSize();
2800         if (_pL->isComplex())
2801         {
2802             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
2803
2804             for (int i = 0; i < iSizeOut; i++)
2805             {
2806                 std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
2807                 pspConvert->set(i, stComplex);
2808             }
2809         }
2810         else
2811         {
2812             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
2813             for (int i = 0; i < iSizeOut; i++)
2814             {
2815                 pspConvert->set(i, (double)_pL->get(i));
2816             }
2817         }
2818     }
2819
2820     pOut = _pR->newEqualTo(*pspConvert);
2821     delete pspConvert;
2822     return pOut;
2823 }
2824
2825 template<class T, class U, class O>
2826 InternalType* compequal_SP_M(T* _pL, U* _pR)
2827 {
2828     //pending changes
2829
2830     Sparse* pspConvert = NULL;
2831     types::SparseBool* pOut = NULL;
2832
2833     if (_pR->isScalar())
2834     {
2835         int iSizeOut = _pL->getSize();
2836         if (_pR->isComplex())
2837         {
2838             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
2839             std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
2840             for (int i = 0; i < iSizeOut; i++)
2841             {
2842                 pspConvert->set(i, stComplex);
2843             }
2844         }
2845         else
2846         {
2847             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
2848             for (int i = 0; i < iSizeOut; i++)
2849             {
2850                 pspConvert->set(i, (double)_pR->get(0));
2851             }
2852         }
2853     }
2854     else
2855     {
2856         //check dimensions
2857         if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
2858         {
2859             return new Bool(false);
2860         }
2861
2862         int iSizeOut = _pL->getSize();
2863         if (_pR->isComplex())
2864         {
2865             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
2866
2867             for (int i = 0; i < iSizeOut; i++)
2868             {
2869                 std::complex<double> stComplex((double)_pR->get(i), (double)_pR->getImg(i));
2870                 pspConvert->set(i, stComplex);
2871             }
2872         }
2873         else
2874         {
2875             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
2876             for (int i = 0; i < iSizeOut; i++)
2877             {
2878                 pspConvert->set(i, (double)_pR->get(i));
2879
2880             }
2881         }
2882     }
2883
2884     pOut = _pL->newEqualTo(*pspConvert);
2885     delete pspConvert;
2886     return pOut;
2887
2888 }
2889
2890 //sparsebool
2891 template<>
2892 InternalType* compequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
2893 {
2894     //pending changes
2895
2896     //D -> SP == SP
2897     SparseBool* pspConvert = NULL;
2898     types::SparseBool* pOut = NULL;
2899
2900
2901     if (_pL->isScalar())
2902     {
2903         int iSizeOut = _pR->getSize();
2904
2905         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
2906         for (int i = 0; i < iSizeOut; i++)
2907         {
2908             pspConvert->set(i, _pL->get(0) == 1);
2909         }
2910
2911     }
2912     else
2913     {
2914         //check dimensions
2915         if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2916         {
2917             return new Bool(false);
2918         }
2919
2920         int iSizeOut = _pR->getSize();
2921
2922         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
2923         for (int i = 0; i < iSizeOut; i++)
2924         {
2925             pspConvert->set(i, _pL->get(i) == 1);
2926         }
2927     }
2928
2929     pOut = _pR->newEqualTo(*pspConvert);
2930     delete pspConvert;
2931     return pOut;
2932 }
2933
2934 template<>
2935 InternalType* compequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
2936 {
2937     //pending changes
2938
2939     SparseBool* pspConvert = NULL;
2940     types::SparseBool* pOut = NULL;
2941
2942     if (_pR->isScalar())
2943     {
2944         int iSizeOut = _pL->getSize();
2945
2946         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
2947         for (int i = 0; i < iSizeOut; i++)
2948         {
2949             pspConvert->set(i, _pR->get(0) == 1);
2950         }
2951
2952     }
2953     else
2954     {
2955         //check dimensions
2956         if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
2957         {
2958             return new Bool(false);
2959         }
2960
2961         int iSizeOut = _pL->getSize();
2962
2963         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
2964         for (int i = 0; i < iSizeOut; i++)
2965         {
2966             pspConvert->set(i, _pR->get(i) == 1);
2967         }
2968     }
2969
2970     pOut = _pL->newEqualTo(*pspConvert);
2971     delete pspConvert;
2972     return pOut;
2973
2974 }
2975
2976 //Polynom
2977 template<>
2978 InternalType* compequal_M_M<Polynom, Polynom, Bool>(Polynom* _pL, Polynom* _pR)
2979 {
2980     Bool* pbOut = NULL;
2981     bool bPoise = true;
2982
2983     SinglePoly** pSPL = _pL->get();
2984     SinglePoly** pSPR = _pR->get();
2985
2986     if (_pR->isScalar())
2987     {
2988         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
2989         int iSize = pbOut->getSize();
2990
2991         if (_pL->isComplex())
2992         {
2993             if (_pR->isComplex())
2994             {
2995                 for (int i = 0; i < iSize; i++)
2996                 {
2997                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
2998                     {
2999                         bPoise = false;
3000                     }
3001                     else
3002                     {
3003                         bPoise = true;
3004                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3005                         {
3006                             compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
3007                         }
3008                     }
3009                     pbOut->set(i, bPoise);
3010
3011                 }
3012             }
3013             else
3014             {
3015                 for (int i = 0; i < iSize; i++)
3016                 {
3017                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
3018                     {
3019                         bPoise = false;
3020                     }
3021                     else
3022                     {
3023                         bPoise = true;
3024                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3025                         {
3026                             compequal(pSPR[0]->get(j), (double)0, pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
3027                         }
3028                     }
3029                     pbOut->set(i, bPoise);
3030                 }
3031             }
3032         }
3033         else
3034         {
3035             if (_pR->isComplex())
3036             {
3037                 for (int i = 0; i < iSize; i++)
3038                 {
3039                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
3040                     {
3041                         bPoise = false;
3042                     }
3043                     else
3044                     {
3045                         bPoise = true;
3046                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3047                         {
3048                             compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
3049                         }
3050                     }
3051                     pbOut->set(i, bPoise);
3052                 }
3053             }
3054             else
3055             {
3056                 for (int i = 0; i < iSize; i++)
3057                 {
3058                     if (pSPL[i]->getSize() != pSPR[0]->getSize())
3059                     {
3060                         bPoise = false;
3061                     }
3062                     else
3063                     {
3064                         bPoise = true;
3065                         for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3066                         {
3067                             compequal(pSPR[0]->get(j), pSPL[i]->get(j), &bPoise);
3068                         }
3069                     }
3070                     pbOut->set(i, bPoise);
3071                 }
3072             }
3073         }
3074     }
3075     else if (_pL->isScalar())
3076     {
3077         pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
3078         int iSize = pbOut->getSize();
3079
3080         if (pSPR[0]->getSize() != 1)
3081         {
3082             if (_pL->isComplex())
3083             {
3084                 if (_pR->isComplex())
3085                 {
3086                     for (int i = 0; i < iSize; i++)
3087                     {
3088                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
3089                         {
3090                             bPoise = false;
3091                         }
3092                         else
3093                         {
3094                             bPoise = true;
3095                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3096                             {
3097                                 compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), pSPR[i]->getImg(j), &bPoise);
3098                             }
3099                         }
3100                         pbOut->set(i, bPoise);
3101                     }
3102                 }
3103                 else
3104                 {
3105                     for (int i = 0; i < iSize; i++)
3106                     {
3107                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
3108                         {
3109                             bPoise = false;
3110                         }
3111                         else
3112                         {
3113                             bPoise = true;
3114                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3115                             {
3116                                 compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
3117                             }
3118                         }
3119                         pbOut->set(i, bPoise);
3120                     }
3121                 }
3122             }
3123             else
3124             {
3125
3126                 if (_pR->isComplex())
3127                 {
3128                     for (int i = 0; i < iSize; i++)
3129                     {
3130                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
3131                         {
3132                             bPoise = false;
3133                         }
3134                         else
3135                         {
3136                             bPoise = true;
3137                             for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
3138                             {
3139                                 compequal(pSPL[0]->get(j), (double)0, pSPR[i]->get(j), pSPR[i]->get(j), &bPoise);
3140                             }
3141                         }
3142                         pbOut->set(i, bPoise);
3143                     }
3144                 }
3145                 else
3146                 {
3147                     for (int i = 0; i < iSize; i++)
3148                     {
3149                         if (pSPL[0]->getSize() != pSPR[i]->getSize())
3150                         {
3151                             bPoise = false;
3152                         }
3153                         else
3154                         {
3155                             bPoise = true;
3156                             for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
3157                             {
3158                                 compequal(pSPL[0]->get(j), pSPR[i]->get(j), &bPoise);
3159                             }
3160                         }
3161                         pbOut->set(i, bPoise);
3162                     }
3163                 }
3164
3165             }
3166         }
3167     }
3168     else
3169     {
3170         //check dimensions
3171         if (_pL->getDims() != _pR->getDims())
3172         {
3173             return new Bool(false);
3174         }
3175
3176         for (int i = 0; i < _pL->getDims(); i++)
3177         {
3178             if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
3179             {
3180                 return new Bool(false);
3181             }
3182         }
3183
3184         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3185         int iSize = pbOut->getSize();
3186
3187         if (_pL->isComplex())
3188         {
3189             if (_pR->isComplex())
3190             {
3191                 for (int i = 0; i < iSize; i++)
3192                 {
3193                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
3194                     {
3195                         bPoise = false;
3196                     }
3197                     else
3198                     {
3199                         bPoise = true;
3200                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
3201                         {
3202                             compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
3203                         }
3204                     }
3205                     pbOut->set(i, bPoise);
3206                 }
3207             }
3208             else
3209             {
3210                 for (int i = 0; i < iSize; i++)
3211                 {
3212                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
3213                     {
3214                         bPoise = false;
3215                     }
3216                     else
3217                     {
3218                         bPoise = true;
3219                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
3220                         {
3221                             compequal(pSPL[i]->get(j), pSPL[i]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
3222                         }
3223                     }
3224                     pbOut->set(i, bPoise);
3225                 }
3226             }
3227         }
3228         else
3229         {
3230             if (_pR->isComplex())
3231             {
3232                 for (int i = 0; i < iSize; i++)
3233                 {
3234                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
3235                     {
3236                         bPoise = false;
3237                     }
3238                     else
3239                     {
3240                         bPoise = true;
3241                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
3242                         {
3243                             compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
3244                         }
3245                     }
3246                     pbOut->set(i, bPoise);
3247                 }
3248             }
3249             else
3250             {
3251                 for (int i = 0; i < iSize; i++)
3252                 {
3253                     if (pSPL[i]->getSize() != pSPR[i]->getSize())
3254                     {
3255                         bPoise = false;
3256                     }
3257                     else
3258                     {
3259                         bPoise = true;
3260                         for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
3261                         {
3262                             compequal(pSPR[i]->get(j), pSPL[i]->get(j), &bPoise);
3263                         }
3264                     }
3265                     pbOut->set(i, bPoise);
3266                 }
3267             }
3268         }
3269     }
3270
3271     return pbOut;
3272 }
3273
3274 template<class T, class U, class O>
3275 InternalType* compequal_P_M(T *_pL, U *_pR)
3276 {
3277     Bool* pbOut = NULL;
3278
3279     SinglePoly** pSPR = _pL->get();
3280
3281     if (_pR->isIdentity())
3282     {
3283         Double* pdblEye = NULL;
3284         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3285         int iSize = pbOut->getSize();
3286
3287         if (_pL->isComplex())
3288         {
3289             if (_pR->isComplex())
3290             {
3291                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
3292                 for (int i = 0; i < iSize; i++)
3293                 {
3294                     if (pSPR[i]->getSize() != 1)
3295                     {
3296                         pbOut->set(i, false);
3297                     }
3298                     else
3299                     {
3300                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
3301                     }
3302                 }
3303             }
3304             else
3305             {
3306                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
3307                 for (int i = 0; i < iSize; i++)
3308                 {
3309                     if (pSPR[i]->getSize() != 1)
3310                     {
3311                         pbOut->set(i, false);
3312                     }
3313                     else
3314                     {
3315                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)0, &(pbOut->get()[i]));
3316                     }
3317                 }
3318             }
3319         }
3320         else
3321         {
3322             if (_pR->isComplex())
3323             {
3324                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
3325                 for (int i = 0; i < iSize; i++)
3326                 {
3327                     if (pSPR[i]->getSize() != 1)
3328                     {
3329                         pbOut->set(i, false);
3330                     }
3331                     else
3332                     {
3333                         compequal((double)pSPR[i]->get(0), (double)0, (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
3334                     }
3335                 }
3336             }
3337             else
3338             {
3339                 pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
3340                 for (int i = 0; i < iSize; i++)
3341                 {
3342                     if (pSPR[i]->getSize() != 1)
3343                     {
3344                         pbOut->set(i, false);
3345                     }
3346                     else
3347                     {
3348                         compequal((double)pSPR[i]->get(0), (double)pdblEye->get(i), &(pbOut->get()[i]));
3349                     }
3350                 }
3351             }
3352         }
3353         delete pdblEye;
3354     }
3355     else if (_pR->isScalar())
3356     {
3357         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3358         int iSize = pbOut->getSize();
3359
3360         if (_pL->isComplex())
3361         {
3362             if (_pR->isComplex())
3363             {
3364                 for (int i = 0; i < iSize; i++)
3365                 {
3366                     if (pSPR[i]->getSize() != 1)
3367                     {
3368                         pbOut->set(i, false);
3369                     }
3370                     else
3371                     {
3372                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
3373                     }
3374                 }
3375             }
3376             else
3377             {
3378                 for (int i = 0; i < iSize; i++)
3379                 {
3380                     if (pSPR[i]->getSize() != 1)
3381                     {
3382                         pbOut->set(i, false);
3383                     }
3384                     else
3385                     {
3386                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)0, &(pbOut->get()[i]));
3387                     }
3388                 }
3389             }
3390         }
3391         else
3392         {
3393             if (_pR->isComplex())
3394             {
3395                 for (int i = 0; i < iSize; i++)
3396                 {
3397                     if (pSPR[i]->getSize() != 1)
3398                     {
3399                         pbOut->set(i, false);
3400                     }
3401                     else
3402                     {
3403                         compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
3404                     }
3405                 }
3406             }
3407             else
3408             {
3409                 for (int i = 0; i < iSize; i++)
3410                 {
3411                     if (pSPR[i]->getSize() != 1)
3412                     {
3413                         pbOut->set(i, false);
3414                     }
3415                     else
3416                     {
3417                         compequal((double)pSPR[i]->get(0), (double)_pR->get(0), &(pbOut->get()[i]));
3418                     }
3419                 }
3420             }
3421         }
3422     }
3423     else if (_pL->isScalar())
3424     {
3425         pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
3426         int iSize = pbOut->getSize();
3427
3428         if (pSPR[0]->getSize() == 1)
3429         {
3430             if (_pL->isComplex())
3431             {
3432                 if (_pR->isComplex())
3433                 {
3434                     for (int i = 0; i < iSize; i++)
3435                     {
3436                         compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
3437                     }
3438                 }
3439                 else
3440                 {
3441                     for (int i = 0; i < iSize; i++)
3442                     {
3443                         compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
3444                     }
3445                 }
3446             }
3447             else
3448             {
3449                 if (_pR->isComplex())
3450                 {
3451                     for (int i = 0; i < iSize; i++)
3452                     {
3453                         compequal((double)pSPR[0]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
3454                     }
3455                 }
3456                 else
3457                 {
3458                     for (int i = 0; i < iSize; i++)
3459                     {
3460                         compequal((double)pSPR[0]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
3461                     }
3462                 }
3463
3464             }
3465         }
3466         else
3467         {
3468             pbOut->setFalse();
3469         }
3470
3471     }
3472     else
3473     {
3474         //check dimensions
3475         if (_pL->getDims() != _pR->getDims())
3476         {
3477             return new Bool(false);
3478         }
3479
3480         for (int i = 0; i < _pL->getDims(); i++)
3481         {
3482             if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
3483             {
3484                 return new Bool(false);
3485             }
3486         }
3487
3488         pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3489         int iSize = pbOut->getSize();
3490
3491         if (_pL->isComplex())
3492         {
3493             if (_pR->isComplex())
3494             {
3495                 for (int i = 0; i < iSize; i++)
3496                 {
3497                     if (pSPR[i]->getSize() != 1)
3498                     {
3499                         pbOut->set(i, false);
3500                     }
3501                     else
3502                     {
3503                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
3504                     }
3505                 }
3506             }
3507             else
3508             {
3509                 for (int i = 0; i < iSize; i++)
3510                 {
3511                     if (pSPR[i]->getSize() != 1)
3512                     {
3513                         pbOut->set(i, false);
3514                     }
3515                     else
3516                     {
3517                         compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
3518                     }
3519                 }
3520             }
3521         }
3522         else
3523         {
3524             if (_pR->isComplex())
3525             {
3526                 for (int i = 0; i < iSize; i++)
3527                 {
3528                     if (pSPR[i]->getSize() != 1)
3529                     {
3530                         pbOut->set(i, false);
3531                     }
3532                     else
3533                     {
3534                         compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
3535                     }
3536                 }
3537             }
3538             else
3539             {
3540                 for (int i = 0; i < iSize; i++)
3541                 {
3542                     if (pSPR[i]->getSize() != 1)
3543                     {
3544                         pbOut->set(i, false);
3545                     }
3546                     else
3547                     {
3548                         compequal((double)pSPR[i]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
3549                     }
3550                 }
3551             }
3552         }
3553     }
3554
3555     return pbOut;
3556 }
3557
3558 template<class T, class U, class O>
3559 InternalType* compequal_M_P(T *_pL, U *_pR)
3560 {
3561     return GenericComparisonEqual(_pR, _pL);
3562 }
3563
3564 template<>
3565 InternalType* compequal_M_M<String, String, Bool>(String* _pL, String* _pR)
3566 {
3567
3568     if (_pL->isScalar())
3569     {
3570         Bool*  pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
3571         for (int i = 0; i < _pR->getSize(); i++)
3572         {
3573             pOut->set(i, wcscmp(_pL->get(0), _pR->get(i)) == 0);
3574         }
3575         return pOut;
3576     }
3577
3578     if (_pR->isScalar())
3579     {
3580         Bool*  pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3581         for (int i = 0; i < _pL->getSize(); i++)
3582         {
3583             pOut->set(i, wcscmp(_pL->get(i), _pR->get(0)) == 0);
3584         }
3585         return pOut;
3586     }
3587
3588     int iDimsL = _pL->getDims();
3589     int iDimsR = _pR->getDims();
3590
3591     int* piDimsL = _pL->getDimsArray();
3592     int* piDimsR = _pR->getDimsArray();
3593
3594
3595     if (iDimsL != iDimsR)
3596     {
3597         return new Bool(false);
3598     }
3599
3600
3601     for (int i = 0; i < iDimsL; ++i)
3602     {
3603         if (piDimsL[i] != piDimsR[i])
3604         {
3605             return new Bool(false);
3606         }
3607     }
3608
3609
3610     if (_pL->getSize() == _pR->getSize())
3611     {
3612         Bool*  pOut = new Bool(iDimsL, piDimsL);
3613
3614         for (int i = 0; i < _pL->getSize(); i++)
3615         {
3616             pOut->set(i, wcscmp(_pL->get(i), _pR->get(i)) == 0);
3617         }
3618         return pOut;
3619     }
3620     return NULL;
3621 }
3622
3623 template<>
3624 types::InternalType* compequal_M_M<Struct, Struct, Bool>(types::Struct* _pL, types::Struct* _pR)
3625 {
3626     /* check dimension*/
3627     if (_pL->getDims() != _pR->getDims())
3628     {
3629         return new Bool(false);
3630     }
3631
3632     int* piDimsL = _pL->getDimsArray();
3633     int* piDimsR = _pR->getDimsArray();
3634
3635     for (int i = 0; i < _pL->getDims(); i++)
3636     {
3637         if (piDimsL[i] != piDimsR[i])
3638         {
3639             return new Bool(false);
3640         }
3641     }
3642
3643     if (_pL->getSize() == 0)
3644     {
3645         return new Bool(true);
3646     }
3647
3648     Bool *pOut = new Bool(_pL->getDims(), piDimsL);
3649     for (int i = 0; i < _pL->getSize(); i++)
3650     {
3651         pOut->set(i, *_pL->get(i) == *_pR->get(i));
3652     }
3653     return pOut;
3654 }
3655
3656 //List, TList, MList
3657 template<class T, class U, class O>
3658 InternalType* compequal_LT_LT(T *_pL, U *_pR)
3659 {
3660     if (_pL->getType() != GenericType::ScilabList || _pR->getType() != GenericType::ScilabList)
3661     {
3662         //try to find overload function, if symbol exist, return NULL to let opexep to call it.
3663         //otherwise do a "binary" comparison
3664         types::typed_list in;
3665         in.push_back(_pL);
3666         in.push_back(_pR);
3667         std::wstring overloadName(Overload::buildOverloadName(Overload::getNameFromOper(ast::OpExp::eq), in, 1, true));
3668         types::InternalType* pIT = symbol::Context::getInstance()->get(symbol::Symbol(overloadName));
3669         if (pIT)
3670         {
3671             return NULL;
3672         }
3673     }
3674
3675     if (_pL->getSize() != _pR->getSize())
3676     {
3677         return new Bool(false);
3678     }
3679
3680     if (_pL->getSize() == 0 && _pR->getSize() == 0)
3681     {
3682         return new Bool(true);
3683     }
3684
3685     Bool* pB = new Bool(1, _pL->getSize());
3686     for (int i = 0; i < _pL->getSize(); i++)
3687     {
3688         pB->set(i, ((*_pL->get(i) == *_pR->get(i)) && (_pL->get(i)->getType() != types::InternalType::ScilabVoid)));
3689     }
3690
3691     return pB;
3692 }
3693
3694 template<>
3695 types::InternalType* compequal_M_M<Cell, Cell, Bool>(types::Cell* _pL, types::Cell* _pR)
3696 {
3697     /* check dimension*/
3698     if (_pL->getDims() != _pR->getDims())
3699     {
3700         return new Bool(false);
3701     }
3702
3703     int* piDimsL = _pL->getDimsArray();
3704     int* piDimsR = _pR->getDimsArray();
3705
3706     for (int i = 0; i < _pL->getDims(); i++)
3707     {
3708         if (piDimsL[i] != piDimsR[i])
3709         {
3710             return new Bool(false);
3711         }
3712     }
3713
3714     if (_pL->getSize() == 0)
3715     {
3716         //{} == {} -> return true
3717         return new Bool(true);
3718     }
3719
3720     Bool *pB = new Bool(_pL->getDims(), piDimsL);
3721     for (int i = 0; i < _pL->getSize(); i++)
3722     {
3723         pB->set(i, *_pL->get(i) == *_pR->get(i));
3724     }
3725
3726     return pB;
3727 }
3728
3729 template<>
3730 types::InternalType* compequal_M_M<GraphicHandle, GraphicHandle, Bool>(GraphicHandle* _pL, GraphicHandle* _pR)
3731 {
3732     if (_pL->isScalar())
3733     {
3734         Bool* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
3735         compequal(_pL->get(0), _pR->getSize(), _pR->get(), pOut->get());
3736         return pOut;
3737     }
3738
3739     if (_pR->isScalar())
3740     {
3741         Bool* pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
3742         compequal(_pR->get(0), _pL->getSize(), _pL->get(), pOut->get());
3743         return pOut;
3744     }
3745
3746     /* check dimension*/
3747     if (_pL->getDims() != _pR->getDims())
3748     {
3749         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
3750     }
3751
3752     int* piDimsL = _pL->getDimsArray();
3753     int* piDimsR = _pR->getDimsArray();
3754
3755     for (int i = 0; i < _pL->getDims(); i++)
3756     {
3757         if (piDimsL[i] != piDimsR[i])
3758         {
3759             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
3760         }
3761     }
3762
3763     Bool* pOut = new Bool(_pL->getDims(), piDimsL);
3764     int iSize = pOut->getSize();
3765
3766     compequal(_pL->get(), iSize, _pR->get(), pOut->get());
3767     return pOut;
3768 }
3769
3770 template<class T, class U, class O>
3771 InternalType* compequal_MCR_MCR(T *_pL, U *_pR)
3772 {
3773     bool ret = false;
3774     if (_pL->getType() == GenericType::ScilabMacroFile)
3775     {
3776         types::InternalType* pIT = ((InternalType *) _pL);
3777         types::MacroFile* pL = pIT->getAs<types::MacroFile>();
3778         ret = *pL == *_pR;
3779     }
3780     else if (_pL->getType() == GenericType::ScilabMacro)
3781     {
3782         types::InternalType* pIT = ((InternalType *) _pL);
3783         types::Macro* pL = pIT->getAs<types::Macro>();
3784         if (_pR->getType() == GenericType::ScilabMacroFile)
3785         {
3786             types::InternalType* pIT = ((InternalType *) _pR);
3787             types::MacroFile* pR = pIT->getAs<types::MacroFile>();
3788             ret = *pR == *pL;
3789         }
3790         else
3791         {
3792             ret = *pL == *_pR;
3793         }
3794     }
3795
3796     return new Bool(ret);
3797 }
3798
3799 //UserType
3800 template<class T, class U, class O>
3801 InternalType* compequal_UT_UT(T *_pL, U *_pR)
3802 {
3803     return _pL->equal(_pR);
3804 }