comparison equal and no equal 13/15913/14
Sylvain GENIN [Thu, 5 Feb 2015 13:27:24 +0000 (14:27 +0100)]
test_run("ast","comparisonequal",["no_check_error_output" ]);
test_run("ast","comparisonnonequal",["no_check_error_output" ]);

Change-Id: I0db55a4eb86a1982332a2ddc9aa45f937fe972ac

scilab/modules/ast/includes/operations/types_comparison_eq.hxx
scilab/modules/ast/includes/operations/types_comparison_ne.hxx
scilab/modules/ast/includes/types/double.hxx
scilab/modules/ast/src/cpp/operations/operations.cpp
scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp
scilab/modules/ast/src/cpp/operations/types_comparison_ne.cpp
scilab/modules/ast/src/cpp/types/double.cpp
scilab/modules/ast/tests/unit_tests/comparisonequal.dia.ref [new file with mode: 0644]
scilab/modules/ast/tests/unit_tests/comparisonequal.tst [new file with mode: 0644]
scilab/modules/ast/tests/unit_tests/comparisonnonequal.dia.ref [new file with mode: 0644]
scilab/modules/ast/tests/unit_tests/comparisonnonequal.tst [new file with mode: 0644]

index da9ed0d..35e5a5f 100644 (file)
@@ -1,6 +1,7 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
+ *  Copyright (C) 2015 - Scilab Enterprises - Sylvain GENIN
  *
  *  This file must be used under the terms of the CeCILL.
  *  This source file is licensed as described in the file COPYING, which
 #include "internal.hxx"
 #include "double.hxx"
 #include "sparse.hxx"
+#include "polynom.hxx"
+#include "string.hxx"
+#include "struct.hxx"
+#include "cell.hxx"
+#include "graphichandle.hxx"
+#include "macrofile.hxx"
 
-int EqualToDoubleAndDouble(types::Double* _pDouble1, types::Double* _pDouble2, types::GenericType** _pOut);
-int EqualToSparseAndSparse(types::Sparse* _pSparse1, types::Sparse* _pSarse2, types::GenericType** _pOut);
-int EqualToDoubleAndSparse(types::Double* _pDouble, types::Sparse* _pSarse, types::GenericType** _pOut);
-int EqualToSparseAndDouble(types::Sparse* _pSparse, types::Double* _pDouble, types::GenericType** _pOut);
-int EqualToSparseBoolAndSparseBool(types::SparseBool* _pSB1, types::SparseBool* _pSB2, types::GenericType** _pOut);
-int EqualToSparseBoolAndBool(types::SparseBool* _pSB1, types::Bool* _pB2, types::GenericType** _pOut);
-int EqualToBoolAndSparseBool(types::Bool* _pB1, types::SparseBool* _pSB2, types::GenericType** _pOut);
+void fillComparisonEqualFunction();
 
-int EqualToIntAndInt(types::InternalType* _pI1, types::InternalType*  _pI2, types::GenericType** _pOut);
+//define arrays on operation functions
+typedef types::InternalType*(*compequal_function)(types::InternalType*, types::InternalType*);
+
+#define DECLARE_COMPARISON_EQUAL_PROTO(x) template<class T, class U, class O> types::InternalType* x(T *_pL, U *_pR)
+
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_E);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_IC);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MC_IC);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_IC);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SC_IC);
+
+//[]
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_E_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_E_E);
+
+//eye
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_I_IC);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_MC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_SC);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_I);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_IC_IC);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_P_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_P);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_SP_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_SP);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_B_M);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_M_B);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_B_S);
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_S_B);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_LT_LT);
+
+DECLARE_COMPARISON_EQUAL_PROTO(compequal_MCR_MCR);
+
+
+#undef DECLARE_COMPARISON_EQUAL_PROTO
+
+template<> types::InternalType* compequal_M_M<types::Sparse, types::Sparse, types::SparseBool>(types::Sparse* _pL, types::Sparse* _pR);
+
+template<> types::InternalType* compequal_M_M<types::Polynom, types::Polynom, types::Bool>(types::Polynom* _pL, types::Polynom* _pR);
+
+template<> types::InternalType* compequal_M_M<types::String, types::String, types::Bool>(types::String* _pL, types::String* _pR);
+
+template<> types::InternalType* compequal_M_M<types::Struct, types::Struct, types::Bool>(types::Struct* _pL, types::Struct* _pR);
+
+template<> types::InternalType* compequal_M_M<types::Cell, types::Cell, types::Bool>(types::Cell* _pL, types::Cell* _pR);
+
+template<> types::InternalType* compequal_M_M<types::GraphicHandle, types::GraphicHandle, types::Bool>(types::GraphicHandle* _pL, types::GraphicHandle* _pR);
+
+template<> types::InternalType* compequal_M_M<types::SparseBool, types::SparseBool, types::SparseBool>(types::SparseBool* _pL, types::SparseBool* _pR);
+template<> types::InternalType* compequal_M_M<types::Bool, types::SparseBool, types::SparseBool>(types::Bool* _pL, types::SparseBool* _pR);
+template<> types::InternalType* compequal_M_M<types::SparseBool, types::Bool, types::SparseBool>(types::SparseBool* _pL, types::Bool* _pR);
+
+//x1 == x1
+template<typename T, typename U, typename O> inline static void compequal(T l, U r, O* o)
+{
+    *o = ((T)l == (U)r);
+}
+
+//X == X
+template<typename T, typename U, typename O> inline static void compequal(T* l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (U)r[i], &o[i]);
+    }
+}
+
+//x == X
+template<typename T, typename U, typename O> inline static void compequal(T l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l, (U)r[i], &o[i]);
+    }
+}
+
+//X == x
+template<typename T, typename U, typename O> inline static void compequal(T* l, size_t size, U r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (U)r, &o[i]);
+    }
+}
+
+//x1c == x1c
+template<typename T, typename U, typename O> inline static void compequal(T l, T lc, U r, U rc, O* o)
+{
+    *o = (((T)l == (U)r) && ((T)lc == (U)rc));
+}
+
+//X1c == X1c
+template<typename T, typename U, typename O> inline static void compequal(T* l, T* lc, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)lc[i], (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1c == x1c
+template<typename T, typename U, typename O> inline static void compequal(T* l, T* lc, size_t size, U r, U rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)lc[i], (U)r, (U)rc, &o[i]);
+    }
+}
+
+//x1c == X1c
+template<typename T, typename U, typename O> inline static void compequal(T l, T lc, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l, (T)lc, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1 == X1c
+template<typename T, typename U, typename O> inline static void compequal(T* l, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)0, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1 == x1c
+template<typename T, typename U, typename O> inline static void compequal(T* l, size_t size, U r, U rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)0, (U)r, (U)rc, &o[i]);
+    }
+}
+
+//x1 == X1c
+template<typename T, typename U, typename O> inline static void compequal(T l, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l, (T)0, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1c == X1
+template<typename T, typename U, typename O> inline static void compequal(T* l, T* lc, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)lc[i], (U)r[i], (U)0, &o[i]);
+    }
+}
+
+//X1c == x1
+template<typename T, typename U, typename O> inline static void compequal(T* l, T* lc, size_t size, U r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l[i], (T)lc[i], (U)r, (U)0, &o[i]);
+    }
+}
+
+//x1c == X1
+template<typename T, typename U, typename O> inline static void compequal(T l, T lc, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compequal((T)l, (T)lc, (U)r[i], (U)0, &o[i]);
+    }
+}
 
 #endif /* !__TYPES_COMPARISON_EQUAL_HXX__ */
index 2040720..263a07f 100644 (file)
 /*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011 - DIGITEO - Antoine ELIAS
- *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-#ifndef __TYPES_COMPARISON_NON_EQUAL_HXX__
-#define __TYPES_COMPARISON_NON_EQUAL_HXX__
+*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+*  Copyright (C) 2011 - DIGITEO - Antoine ELIAS
+*  Copyright (C) 2015 - Scilab Enterprises - Sylvain GENIN
+*
+*  This file must be used under the terms of the CeCILL.
+*  This source file is licensed as described in the file COPYING, which
+*  you should have received as part of this distribution.  The terms
+*  are also available at
+*  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
+
+#ifndef __TYPES_COMPARISON_NO_EQUAL_HXX__
+#define __TYPES_COMPARISON_NO_EQUAL_HXX__
 
 #include "generic_operations.hxx"
+#include "internal.hxx"
+#include "double.hxx"
 #include "sparse.hxx"
+#include "polynom.hxx"
+#include "string.hxx"
+#include "struct.hxx"
+#include "cell.hxx"
+#include "graphichandle.hxx"
+#include "macrofile.hxx"
+
+void fillComparisonNoEqualFunction();
+
+//define arrays on operation functions
+typedef types::InternalType*(*compnoequal_function)(types::InternalType*, types::InternalType*);
+
+#define DECLARE_COMPARISON_NO_EQUAL_PROTO(x) template<class T, class U, class O> types::InternalType* x(T *_pL, U *_pR)
+
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_E);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_IC);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MC_IC);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_IC);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SC_IC);
+
+//[]
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_E_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_E_E);
+
+//eye
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_I_IC);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_MC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_SC);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_I);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_IC_IC);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_P_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_P);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_SP_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_SP);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_B_M);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_M_B);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_B_S);
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_S_B);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_LT_LT);
+
+DECLARE_COMPARISON_NO_EQUAL_PROTO(compnoequal_MCR_MCR);
+
+
+#undef DECLARE_COMPARISON_NO_EQUAL_PROTO
+
+template<> types::InternalType* compnoequal_M_M<types::Sparse, types::Sparse, types::SparseBool>(types::Sparse* _pL, types::Sparse* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::Polynom, types::Polynom, types::Bool>(types::Polynom* _pL, types::Polynom* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::String, types::String, types::Bool>(types::String* _pL, types::String* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::Struct, types::Struct, types::Bool>(types::Struct* _pL, types::Struct* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::Cell, types::Cell, types::Bool>(types::Cell* _pL, types::Cell* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::GraphicHandle, types::GraphicHandle, types::Bool>(types::GraphicHandle* _pL, types::GraphicHandle* _pR);
+
+template<> types::InternalType* compnoequal_M_M<types::SparseBool, types::SparseBool, types::SparseBool>(types::SparseBool* _pL, types::SparseBool* _pR);
+template<> types::InternalType* compnoequal_M_M<types::Bool, types::SparseBool, types::SparseBool>(types::Bool* _pL, types::SparseBool* _pR);
+template<> types::InternalType* compnoequal_M_M<types::SparseBool, types::Bool, types::SparseBool>(types::SparseBool* _pL, types::Bool* _pR);
+
+//x1 != x1
+template<typename T, typename U, typename O> inline static void compnoequal(T l, U r, O* o)
+{
+    *o = ((T)l != (U)r);
+}
+
+//X != X
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (U)r[i], &o[i]);
+    }
+}
+
+//x != X
+template<typename T, typename U, typename O> inline static void compnoequal(T l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l, (U)r[i], &o[i]);
+    }
+}
+
+//X != x
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, size_t size, U r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (U)r, &o[i]);
+    }
+}
+
+//x1c != x1c
+template<typename T, typename U, typename O> inline static void compnoequal(T l, T lc, U r, U rc, O* o)
+{
+    *o = (((T)l != (U)r) || ((T)lc != (U)rc));
+}
+
+//X1c != X1c
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, T* lc, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)lc[i], (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1c != x1c
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, T* lc, size_t size, U r, U rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)lc[i], (U)r, (U)rc, &o[i]);
+    }
+}
+
+//x1c != X1c
+template<typename T, typename U, typename O> inline static void compnoequal(T l, T lc, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l, (T)lc, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1 != X1c
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)0, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1 != x1c
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, size_t size, U r, U rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)0, (U)r, (U)rc, &o[i]);
+    }
+}
+
+//x1 != X1c
+template<typename T, typename U, typename O> inline static void compnoequal(T l, size_t size, U* r, U* rc, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l, (T)0, (U)r[i], (U)rc[i], &o[i]);
+    }
+}
+
+//X1c != X1
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, T* lc, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)lc[i], (U)r[i], (U)0, &o[i]);
+    }
+}
+
+//X1c != x1
+template<typename T, typename U, typename O> inline static void compnoequal(T* l, T* lc, size_t size, U r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l[i], (T)lc[i], (U)r, (U)0, &o[i]);
+    }
+}
 
-int NotEqualToSparseAndSparse(types::Sparse* _pSparse1, types::Sparse* _pSarse2, types::GenericType** _pOut);
+//x1c != X1
+template<typename T, typename U, typename O> inline static void compnoequal(T l, T lc, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        compnoequal((T)l, (T)lc, (U)r[i], (U)0, &o[i]);
+    }
+}
 
-#endif /* !__TYPES_COMPARISON_NON_EQUAL_HXX__ */
+#endif /* !__TYPES_COMPARISON_NO_EQUAL_HXX__ */
index 223ede3..9730adf 100644 (file)
@@ -44,6 +44,8 @@ public :
     static Double*              Empty();
     static Double*              Identity(int _iRows, int _iCols);
     static Double*              Identity(int _iDims, int* _piDims);
+    static Double*              Identity(int _iDims, int* _piDims, double _dblReal);
+    static Double*              Identity(int _iDims, int* _piDims, double _dblReal, double _dblImg);
 
 
     /*data management*/
@@ -142,10 +144,10 @@ public :
     inline ScilabId             getId(void)
     {
         return isIdentity() ? isComplex() ? IdIdentityComplex : IdIdentity
-       : isEmpty() ? IdEmpty
+               : isEmpty() ? IdEmpty
                : isComplex() ? isScalar() ? IdScalarDoubleComplex
                : IdDoubleComplex
-       : isScalar() ? IdScalarDouble
+               : isScalar() ? IdScalarDouble
                : IdDouble;
     }
 
index 0c15fe1..17adbab 100644 (file)
@@ -9,6 +9,8 @@
 #include "types_dotdivide.hxx"
 #include "types_and.hxx"
 #include "types_or.hxx"
+#include "types_comparison_eq.hxx"
+#include "types_comparison_ne.hxx"
 
 void initOperationArray()
 {
@@ -19,4 +21,6 @@ void initOperationArray()
     fillDotDivFunction();
     fillAndFunction();
     fillOrFunction();
+    fillComparisonEqualFunction();
+    fillComparisonNoEqualFunction();
 }
index bbed83d..ebcda27 100644 (file)
@@ -1,6 +1,7 @@
 /*
  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  *  Copyright (C) 2012 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2015 - Scilab Enterprises - Sylvain GENIN
  *
  *  This file must be used under the terms of the CeCILL.
  *  This source file is licensed as described in the file COPYING, which
 
 using namespace types;
 
-static void clearAlloc(bool _bAllocL, InternalType* _pIL, bool _bAllocR, InternalType* _pIR);
-template <class T> static int EqualToArrayAndArray(T* _pL, T* _pR, GenericType** _pOut);
+//define arrays on operation functions
+static compequal_function pComparisonEqualfunction[types::InternalType::IdLast][types::InternalType::IdLast] = { NULL };
 
-InternalType *GenericComparisonEqual(InternalType *_pLeftOperand, InternalType *_pRightOperand)
+
+void fillComparisonEqualFunction()
 {
-    GenericType::ScilabType TypeL = _pLeftOperand->getType();
-    GenericType::ScilabType TypeR = _pRightOperand->getType();
+#define scilab_fill_comparisonequal(id1, id2, func, typeIn1, typeIn2, typeOut) \
+    pComparisonEqualfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (compequal_function)&compequal_##func<typeIn1, typeIn2, typeOut>
+
+    //String == String
+    scilab_fill_comparisonequal(String, String, M_M, String, String, Bool);
+    scilab_fill_comparisonequal(String, ScalarString, M_M, String, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarString, M_M, String, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, String, M_M, String, String, Bool);
+    //String == Empty
+    scilab_fill_comparisonequal(Empty, ScalarString, E_M, String, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Empty, M_E, String, String, Bool);
+    scilab_fill_comparisonequal(String, Empty, M_E, String, String, Bool);
+    scilab_fill_comparisonequal(Empty, String, E_M, String, String, Bool);
+    //String == Double
+    scilab_fill_comparisonequal(Double, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Double, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, Double, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(Double, String, M_E, Double, String, Bool);
+    //String == ScalarDouble
+    scilab_fill_comparisonequal(ScalarDouble, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarDouble, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, ScalarDouble, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, String, M_E, Double, String, Bool);
+    //String == Int8
+    scilab_fill_comparisonequal(Int8, ScalarString, M_E, Int8, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Int8, M_E, String, Int8, Bool);
+    scilab_fill_comparisonequal(String, Int8, M_E, String, Int8, Bool);
+    scilab_fill_comparisonequal(Int8, String, M_E, Int8, String, Bool);
+    //String == UInt8
+    scilab_fill_comparisonequal(UInt8, ScalarString, M_E, UInt8, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, UInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparisonequal(String, UInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt8, String, M_E, UInt8, String, Bool);
+    //String == Int16
+    scilab_fill_comparisonequal(Int16, ScalarString, M_E, Int16, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Int16, M_E, String, Int16, Bool);
+    scilab_fill_comparisonequal(String, Int16, M_E, String, Int16, Bool);
+    scilab_fill_comparisonequal(Int16, String, M_E, Int16, String, Bool);
+    //String == UInt16
+    scilab_fill_comparisonequal(UInt16, ScalarString, M_E, UInt16, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, UInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparisonequal(String, UInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt16, String, M_E, UInt16, String, Bool);
+    //String == Int32
+    scilab_fill_comparisonequal(Int32, ScalarString, M_E, Int32, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Int32, M_E, String, Int32, Bool);
+    scilab_fill_comparisonequal(String, Int32, M_E, String, Int32, Bool);
+    scilab_fill_comparisonequal(Int32, String, M_E, Int32, String, Bool);
+    //String == UInt32
+    scilab_fill_comparisonequal(UInt32, ScalarString, M_E, UInt32, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, UInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparisonequal(String, UInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt32, String, M_E, UInt32, String, Bool);
+    //String == Int64
+    scilab_fill_comparisonequal(Int64, ScalarString, M_E, Int64, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Int64, M_E, String, Int64, Bool);
+    scilab_fill_comparisonequal(String, Int64, M_E, String, Int64, Bool);
+    scilab_fill_comparisonequal(Int64, String, M_E, Int64, String, Bool);
+    //String == UInt64
+    scilab_fill_comparisonequal(UInt64, ScalarString, M_E, UInt64, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, UInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparisonequal(String, UInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt64, String, M_E, UInt64, String, Bool);
+    //String == Bool
+    scilab_fill_comparisonequal(Bool, ScalarString, M_E, Bool, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Bool, M_E, String, Bool, Bool);
+    scilab_fill_comparisonequal(String, Bool, M_E, String, Bool, Bool);
+    scilab_fill_comparisonequal(Bool, String, M_E, Bool, String, Bool);
+    //String == Polynom
+    scilab_fill_comparisonequal(Polynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Polynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, Polynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(Polynom, String, M_E, Polynom, String, Bool);
+    //String == PolynomComplex
+    scilab_fill_comparisonequal(PolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, PolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, PolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, String, M_E, Polynom, String, Bool);
+    //String == ScalarPolynom
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
+    //String == ScalarPolynomComplex
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
+    //String == Sparse
+    scilab_fill_comparisonequal(Sparse, ScalarString, M_E, Sparse, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Sparse, M_E, String, Sparse, Bool);
+    scilab_fill_comparisonequal(String, Sparse, M_E, String, Sparse, Bool);
+    scilab_fill_comparisonequal(Sparse, String, M_E, Sparse, String, Bool);
+    //String == SparseBool
+    scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
+    //String == ScalarInt8
+    scilab_fill_comparisonequal(ScalarInt8, ScalarString, M_E, Int8, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarInt8, M_E, String, Int8, Bool);
+    scilab_fill_comparisonequal(String, ScalarInt8, M_E, String, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, String, M_E, Int8, String, Bool);
+    //String == ScalarUInt8
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarString, M_E, UInt8, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarUInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparisonequal(String, ScalarUInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, String, M_E, UInt8, String, Bool);
+    //String == ScalarInt16
+    scilab_fill_comparisonequal(ScalarInt16, ScalarString, M_E, Int16, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarInt16, M_E, String, Int16, Bool);
+    scilab_fill_comparisonequal(String, ScalarInt16, M_E, String, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, String, M_E, Int16, String, Bool);
+    //String == ScalarUInt16
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarString, M_E, UInt16, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarUInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparisonequal(String, ScalarUInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, String, M_E, UInt16, String, Bool);
+    //String == ScalarInt32
+    scilab_fill_comparisonequal(ScalarInt32, ScalarString, M_E, Int32, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarInt32, M_E, String, Int32, Bool);
+    scilab_fill_comparisonequal(String, ScalarInt32, M_E, String, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, String, M_E, Int32, String, Bool);
+    //String == ScalarUInt32
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarString, M_E, UInt32, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarUInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparisonequal(String, ScalarUInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, String, M_E, UInt32, String, Bool);
+    //String == ScalarInt64
+    scilab_fill_comparisonequal(ScalarInt64, ScalarString, M_E, Int64, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarInt64, M_E, String, Int64, Bool);
+    scilab_fill_comparisonequal(String, ScalarInt64, M_E, String, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, String, M_E, Int64, String, Bool);
+    //String == ScalarUInt64
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarString, M_E, UInt64, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarUInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparisonequal(String, ScalarUInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, String, M_E, UInt64, String, Bool);
+    //String == ScalarBool
+    scilab_fill_comparisonequal(ScalarBool, ScalarString, M_E, Bool, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarBool, M_E, String, Bool, Bool);
+    scilab_fill_comparisonequal(String, ScalarBool, M_E, String, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarBool, String, M_E, Bool, String, Bool);
+    //String == ScalarPolynom
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, String, M_E, Polynom, String, Bool);
+    //String == ScalarDoubleComplex
+    scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarDoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, ScalarDoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, String, M_E, Double, String, Bool);
+    //String == DoubleComplex
+    scilab_fill_comparisonequal(DoubleComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, DoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, DoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, String, M_E, Double, String, Bool);
+    //String == ScalarPolynomComplex
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
+    //String == SparseComplex
+    scilab_fill_comparisonequal(SparseComplex, ScalarString, M_E, Sparse, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, SparseComplex, M_E, String, Sparse, Bool);
+    scilab_fill_comparisonequal(String, SparseComplex, M_E, String, Sparse, Bool);
+    scilab_fill_comparisonequal(SparseComplex, String, M_E, Sparse, String, Bool);
+    //String == Identity
+    scilab_fill_comparisonequal(Identity, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, Identity, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, Identity, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(Identity, String, M_E, Double, String, Bool);
+    //String == IdentityComplex
+    scilab_fill_comparisonequal(IdentityComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, IdentityComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(String, IdentityComplex, M_E, String, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, String, M_E, Double, String, Bool);
+
+    //Double
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Double, Double, M_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Double, Int8, M_M, Double, Int8, Bool);
+    scilab_fill_comparisonequal(Double, UInt8, M_M, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(Double, Int16, M_M, Double, Int16, Bool);
+    scilab_fill_comparisonequal(Double, UInt16, M_M, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(Double, Int32, M_M, Double, Int32, Bool);
+    scilab_fill_comparisonequal(Double, UInt32, M_M, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(Double, Int64, M_M, Double, Int64, Bool);
+    scilab_fill_comparisonequal(Double, UInt64, M_M, Double, UInt64, Bool);
+    scilab_fill_comparisonequal(Double, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(Double, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Double, Sparse, M_SP, Double, Sparse, SparseBool);
+
+    //Matrix == Matrix Complex
+    scilab_fill_comparisonequal(Double, DoubleComplex, M_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(Double, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Double, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Double, ScalarDouble, M_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(Double, ScalarInt8, M_S, Double, Int8, Bool);
+    scilab_fill_comparisonequal(Double, ScalarUInt8, M_S, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(Double, ScalarInt16, M_S, Double, Int16, Bool);
+    scilab_fill_comparisonequal(Double, ScalarUInt16, M_S, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(Double, ScalarInt32, M_S, Double, Int32, Bool);
+    scilab_fill_comparisonequal(Double, ScalarUInt32, M_S, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(Double, ScalarInt64, M_S, Double, Int64, Bool);
+    scilab_fill_comparisonequal(Double, ScalarUInt64, M_S, Double, UInt64, Bool);
+    scilab_fill_comparisonequal(Double, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(Double, ScalarPolynom, M_P, Double, Polynom, Bool);
+
+    //Matrix == Scalar Complex
+    scilab_fill_comparisonequal(Double, ScalarDoubleComplex, M_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(Double, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+
+    //Matrix == Empty
+    scilab_fill_comparisonequal(Double, Empty, M_E, Double, Double, Bool);
+
+
+    //Matrix Complex == Matrix
+    scilab_fill_comparisonequal(DoubleComplex, Double, MC_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, ScalarDouble, MC_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, Empty, M_E, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
+    scilab_fill_comparisonequal(DoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarDouble, Double, S_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Int8, S_M, Double, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, UInt8, S_M, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Int16, S_M, Double, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, UInt16, S_M, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Int32, S_M, Double, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, UInt32, S_M, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Int64, S_M, Double, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, UInt64, S_M, Double, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Sparse, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar == Matrix Complex
+    scilab_fill_comparisonequal(ScalarDouble, DoubleComplex, S_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarDouble, ScalarDouble, S_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarInt8, S_S, Double, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarInt16, S_S, Double, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarInt32, S_S, Double, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarInt64, S_S, Double, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarPolynom, M_P, Double, Polynom, Bool);
+
+    //Scalar == Scalar Complex
+    scilab_fill_comparisonequal(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+
+    //Scalar == Empty
+    scilab_fill_comparisonequal(ScalarDouble, Empty, M_E, Double, Double, Bool);
+
+    //Scalar Complex == Matrix
+    scilab_fill_comparisonequal(ScalarDoubleComplex, Double, SC_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
+    //Scalar Complex == Matrix Complex
+    scilab_fill_comparisonequal(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
+    //Scalar Complex == Scalar
+    scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    //Scalar Complex == Scalar Complex
+    scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    //Scalar Complex == Empty
+    scilab_fill_comparisonequal(ScalarDoubleComplex, Empty, M_E, Double, Double, Bool);
+
+    //Empty == Matrix
+    scilab_fill_comparisonequal(Empty, Double, E_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Empty, Int8, E_M, Double, Int8, Bool);
+    scilab_fill_comparisonequal(Empty, UInt8, E_M, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(Empty, Int16, E_M, Double, Int16, Bool);
+    scilab_fill_comparisonequal(Empty, UInt16, E_M, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(Empty, Int32, E_M, Double, Int32, Bool);
+    scilab_fill_comparisonequal(Empty, UInt32, E_M, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(Empty, Int64, E_M, Double, Int64, Bool);
+    scilab_fill_comparisonequal(Empty, UInt64, E_M, Double, UInt64, Bool);
+
+    scilab_fill_comparisonequal(Empty, Polynom, E_M, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Empty, PolynomComplex, E_M, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Empty, Sparse, E_M, Double, Sparse, Bool);
+    scilab_fill_comparisonequal(Empty, SparseComplex, E_M, Double, Sparse, Bool);
+
+    //Empty == Matrix Complex
+    scilab_fill_comparisonequal(Empty, DoubleComplex, E_M, Double, Double, Bool);
+    //Empty == Scalar
+    scilab_fill_comparisonequal(Empty, ScalarDouble, E_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarInt8, E_M, Double, Int8, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarUInt8, E_M, Double, UInt8, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarInt16, E_M, Double, Int16, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarUInt16, E_M, Double, UInt16, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarInt32, E_M, Double, Int32, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarUInt32, E_M, Double, UInt32, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarInt64, E_M, Double, Int64, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarUInt64, E_M, Double, UInt64, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarBool, E_M, Double, Bool, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarPolynom, E_M, Double, Polynom, Bool);
+
+    //Empty == Scalar Complex
+    scilab_fill_comparisonequal(Empty, ScalarDoubleComplex, E_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Bool);
+    //Empty == Empty
+    scilab_fill_comparisonequal(Empty, Empty, E_E, Double, Double, Bool);
+    //Empty == eye
+    scilab_fill_comparisonequal(Empty, Identity, E_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Empty, IdentityComplex, E_M, Double, Double, Bool);
+
+    //Matrix == Identity
+    scilab_fill_comparisonequal(Double, Identity, M_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(Double, IdentityComplex, M_IC, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, Identity, MC_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, Identity, S_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, IdentityComplex, S_IC, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, Identity, SC_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Bool);
+
+    //Int8
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Int8, Double, M_M, Int8, Double, Bool);
+    scilab_fill_comparisonequal(Int8, Int8, M_M, Int8, Int8, Bool);
+    scilab_fill_comparisonequal(Int8, UInt8, M_M, Int8, UInt8, Bool);
+    scilab_fill_comparisonequal(Int8, Int16, M_M, Int8, Int16, Bool);
+    scilab_fill_comparisonequal(Int8, UInt16, M_M, Int8, UInt16, Bool);
+    scilab_fill_comparisonequal(Int8, Int32, M_M, Int8, Int32, Bool);
+    scilab_fill_comparisonequal(Int8, UInt32, M_M, Int8, UInt32, Bool);
+    scilab_fill_comparisonequal(Int8, Int64, M_M, Int8, Int64, Bool);
+    scilab_fill_comparisonequal(Int8, UInt64, M_M, Int8, UInt64, Bool);
+    scilab_fill_comparisonequal(Int8, Bool, M_B, Int8, Bool, Bool);
+    scilab_fill_comparisonequal(Int8, Empty, M_E, Int8, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Int8, ScalarDouble, M_S, Int8, Double, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarInt8, M_S, Int8, Int8, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarUInt8, M_S, Int8, UInt8, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarInt16, M_S, Int8, Int16, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarUInt16, M_S, Int8, UInt16, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarInt32, M_S, Int8, Int32, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarUInt32, M_S, Int8, UInt32, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarInt64, M_S, Int8, Int64, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarUInt64, M_S, Int8, UInt64, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarBool, M_B, Int8, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarInt8, Double, S_M, Int8, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Int8, S_M, Int8, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, UInt8, S_M, Int8, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Int16, S_M, Int8, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, UInt16, S_M, Int8, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Int32, S_M, Int8, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, UInt32, S_M, Int8, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Int64, S_M, Int8, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, UInt64, S_M, Int8, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Bool, S_B, Int8, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, Empty, M_E, Int8, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarInt8, ScalarDouble, S_S, Int8, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarBool, M_E, Int8, Bool, Bool);
+
+    //UInt8
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(UInt8, Double, M_M, UInt8, Double, Bool);
+    scilab_fill_comparisonequal(UInt8, Int8, M_M, UInt8, Int8, Bool);
+    scilab_fill_comparisonequal(UInt8, UInt8, M_M, UInt8, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt8, Int16, M_M, UInt8, Int16, Bool);
+    scilab_fill_comparisonequal(UInt8, UInt16, M_M, UInt8, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt8, Int32, M_M, UInt8, Int32, Bool);
+    scilab_fill_comparisonequal(UInt8, UInt32, M_M, UInt8, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt8, Int64, M_M, UInt8, Int64, Bool);
+    scilab_fill_comparisonequal(UInt8, UInt64, M_M, UInt8, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt8, Bool, M_B, UInt8, Bool, Bool);
+    scilab_fill_comparisonequal(UInt8, Empty, M_E, UInt8, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(UInt8, ScalarDouble, M_S, UInt8, Double, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarInt8, M_S, UInt8, Int8, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarUInt8, M_S, UInt8, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarInt16, M_S, UInt8, Int16, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarUInt16, M_S, UInt8, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarInt32, M_S, UInt8, Int32, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarUInt32, M_S, UInt8, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarInt64, M_S, UInt8, Int64, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarUInt64, M_S, UInt8, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarBool, M_B, UInt8, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarUInt8, Double, S_M, UInt8, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Int8, S_M, UInt8, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, UInt8, S_M, UInt8, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Int16, S_M, UInt8, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, UInt16, S_M, UInt8, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Int32, S_M, UInt8, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, UInt32, S_M, UInt8, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Int64, S_M, UInt8, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, UInt64, S_M, UInt8, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Bool, S_B, UInt8, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Empty, M_E, UInt8, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarBool, M_E, UInt8, Bool, Bool);
+
+    //Int16
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Int16, Double, M_M, Int16, Double, Bool);
+    scilab_fill_comparisonequal(Int16, Int8, M_M, Int16, Int8, Bool);
+    scilab_fill_comparisonequal(Int16, UInt8, M_M, Int16, UInt8, Bool);
+    scilab_fill_comparisonequal(Int16, Int16, M_M, Int16, Int16, Bool);
+    scilab_fill_comparisonequal(Int16, UInt16, M_M, Int16, UInt16, Bool);
+    scilab_fill_comparisonequal(Int16, Int32, M_M, Int16, Int32, Bool);
+    scilab_fill_comparisonequal(Int16, UInt32, M_M, Int16, UInt32, Bool);
+    scilab_fill_comparisonequal(Int16, Int64, M_M, Int16, Int64, Bool);
+    scilab_fill_comparisonequal(Int16, UInt64, M_M, Int16, UInt64, Bool);
+    scilab_fill_comparisonequal(Int16, Bool, M_B, Int16, Bool, Bool);
+    scilab_fill_comparisonequal(Int16, Empty, M_E, Int16, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Int16, ScalarDouble, M_S, Int16, Double, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarInt8, M_S, Int16, Int8, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarUInt8, M_S, Int16, UInt8, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarInt16, M_S, Int16, Int16, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarUInt16, M_S, Int16, UInt16, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarInt32, M_S, Int16, Int32, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarUInt32, M_S, Int16, UInt32, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarInt64, M_S, Int16, Int64, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarUInt64, M_S, Int16, UInt64, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarBool, M_B, Int16, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarInt16, Double, S_M, Int16, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Int8, S_M, Int16, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, UInt8, S_M, Int16, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Int16, S_M, Int16, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, UInt16, S_M, Int16, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Int32, S_M, Int16, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, UInt32, S_M, Int16, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Int64, S_M, Int16, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, UInt64, S_M, Int16, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Bool, S_B, Int16, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, Empty, M_E, Int16, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarInt16, ScalarDouble, S_S, Int16, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarBool, M_E, Int16, Bool, Bool);
+
+    //UInt16
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(UInt16, Double, M_M, UInt16, Double, Bool);
+    scilab_fill_comparisonequal(UInt16, Int8, M_M, UInt16, Int8, Bool);
+    scilab_fill_comparisonequal(UInt16, UInt8, M_M, UInt16, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt16, Int16, M_M, UInt16, Int16, Bool);
+    scilab_fill_comparisonequal(UInt16, UInt16, M_M, UInt16, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt16, Int32, M_M, UInt16, Int32, Bool);
+    scilab_fill_comparisonequal(UInt16, UInt32, M_M, UInt16, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt16, Int64, M_M, UInt16, Int64, Bool);
+    scilab_fill_comparisonequal(UInt16, UInt64, M_M, UInt16, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt16, Bool, M_B, UInt16, Bool, Bool);
+    scilab_fill_comparisonequal(UInt16, Empty, M_E, UInt16, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(UInt16, ScalarDouble, M_S, UInt16, Double, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarInt8, M_S, UInt16, Int8, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarUInt8, M_S, UInt16, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarInt16, M_S, UInt16, Int16, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarUInt16, M_S, UInt16, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarInt32, M_S, UInt16, Int32, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarUInt32, M_S, UInt16, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarInt64, M_S, UInt16, Int64, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarUInt64, M_S, UInt16, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarBool, M_B, UInt16, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarUInt16, Double, S_M, UInt16, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Int8, S_M, UInt16, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, UInt8, S_M, UInt16, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Int16, S_M, UInt16, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, UInt16, S_M, UInt16, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Int32, S_M, UInt16, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, UInt32, S_M, UInt16, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Int64, S_M, UInt16, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, UInt64, S_M, UInt16, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Bool, S_B, UInt16, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Empty, M_E, UInt16, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarBool, M_E, UInt16, Bool, Bool);
+
+    //Int32
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Int32, Double, M_M, Int32, Double, Bool);
+    scilab_fill_comparisonequal(Int32, Int8, M_M, Int32, Int8, Bool);
+    scilab_fill_comparisonequal(Int32, UInt8, M_M, Int32, UInt8, Bool);
+    scilab_fill_comparisonequal(Int32, Int16, M_M, Int32, Int16, Bool);
+    scilab_fill_comparisonequal(Int32, UInt16, M_M, Int32, UInt16, Bool);
+    scilab_fill_comparisonequal(Int32, Int32, M_M, Int32, Int32, Bool);
+    scilab_fill_comparisonequal(Int32, UInt32, M_M, Int32, UInt32, Bool);
+    scilab_fill_comparisonequal(Int32, Int64, M_M, Int32, Int64, Bool);
+    scilab_fill_comparisonequal(Int32, UInt64, M_M, Int32, UInt64, Bool);
+    scilab_fill_comparisonequal(Int32, Bool, M_B, Int32, Bool, Bool);
+    scilab_fill_comparisonequal(Int32, Empty, M_E, Int32, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Int32, ScalarDouble, M_S, Int32, Double, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarInt8, M_S, Int32, Int8, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarUInt8, M_S, Int32, UInt8, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarInt16, M_S, Int32, Int16, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarUInt16, M_S, Int32, UInt16, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarInt32, M_S, Int32, Int32, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarUInt32, M_S, Int32, UInt32, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarInt64, M_S, Int32, Int64, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarUInt64, M_S, Int32, UInt64, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarBool, M_B, Int32, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarInt32, Double, S_M, Int32, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Int8, S_M, Int32, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, UInt8, S_M, Int32, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Int16, S_M, Int32, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, UInt16, S_M, Int32, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Int32, S_M, Int32, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, UInt32, S_M, Int32, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Int64, S_M, Int32, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, UInt64, S_M, Int32, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Bool, S_B, Int32, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, Empty, M_E, Int32, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarInt32, ScalarDouble, S_S, Int32, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarBool, M_E, Int32, Bool, Bool);
+
+    //UInt32
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(UInt32, Double, M_M, UInt32, Double, Bool);
+    scilab_fill_comparisonequal(UInt32, Int8, M_M, UInt32, Int8, Bool);
+    scilab_fill_comparisonequal(UInt32, UInt8, M_M, UInt32, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt32, Int16, M_M, UInt32, Int16, Bool);
+    scilab_fill_comparisonequal(UInt32, UInt16, M_M, UInt32, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt32, Int32, M_M, UInt32, Int32, Bool);
+    scilab_fill_comparisonequal(UInt32, UInt32, M_M, UInt32, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt32, Int64, M_M, UInt32, Int64, Bool);
+    scilab_fill_comparisonequal(UInt32, UInt64, M_M, UInt32, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt32, Bool, M_B, UInt32, Bool, Bool);
+    scilab_fill_comparisonequal(UInt32, Empty, M_E, UInt32, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(UInt32, ScalarDouble, M_S, UInt32, Double, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarInt8, M_S, UInt32, Int8, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarUInt8, M_S, UInt32, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarInt16, M_S, UInt32, Int16, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarUInt16, M_S, UInt32, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarInt32, M_S, UInt32, Int32, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarUInt32, M_S, UInt32, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarInt64, M_S, UInt32, Int64, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarUInt64, M_S, UInt32, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarBool, M_B, UInt32, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarUInt32, Double, S_M, UInt32, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Int8, S_M, UInt32, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, UInt8, S_M, UInt32, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Int16, S_M, UInt32, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, UInt16, S_M, UInt32, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Int32, S_M, UInt32, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, UInt32, S_M, UInt32, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Int64, S_M, UInt32, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, UInt64, S_M, UInt32, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Bool, S_B, UInt32, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Empty, M_E, UInt32, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarBool, M_E, UInt32, Bool, Bool);
+
+    //Int64
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Int64, Double, M_M, Int64, Double, Bool);
+    scilab_fill_comparisonequal(Int64, Int8, M_M, Int64, Int8, Bool);
+    scilab_fill_comparisonequal(Int64, UInt8, M_M, Int64, UInt8, Bool);
+    scilab_fill_comparisonequal(Int64, Int16, M_M, Int64, Int16, Bool);
+    scilab_fill_comparisonequal(Int64, UInt16, M_M, Int64, UInt16, Bool);
+    scilab_fill_comparisonequal(Int64, Int32, M_M, Int64, Int32, Bool);
+    scilab_fill_comparisonequal(Int64, UInt32, M_M, Int64, UInt32, Bool);
+    scilab_fill_comparisonequal(Int64, Int64, M_M, Int64, Int64, Bool);
+    scilab_fill_comparisonequal(Int64, UInt64, M_M, Int64, UInt64, Bool);
+    scilab_fill_comparisonequal(Int64, Bool, M_B, Int64, Bool, Bool);
+    scilab_fill_comparisonequal(Int64, Empty, M_E, Int64, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Int64, ScalarDouble, M_S, Int64, Double, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarInt8, M_S, Int64, Int8, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarUInt8, M_S, Int64, UInt8, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarInt16, M_S, Int64, Int16, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarUInt16, M_S, Int64, UInt16, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarInt32, M_S, Int64, Int32, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarUInt32, M_S, Int64, UInt32, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarInt64, M_S, Int64, Int64, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarUInt64, M_S, Int64, UInt64, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarBool, M_B, Int64, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarInt64, Double, S_M, Int64, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Int8, S_M, Int64, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, UInt8, S_M, Int64, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Int16, S_M, Int64, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, UInt16, S_M, Int64, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Int32, S_M, Int64, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, UInt32, S_M, Int64, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Int64, S_M, Int64, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, UInt64, S_M, Int64, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Bool, S_B, Int64, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, Empty, M_E, Int64, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarInt64, ScalarDouble, S_S, Int64, Double, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarBool, M_E, Int64, Bool, Bool);
+
+    //UInt64
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(UInt64, Double, M_M, UInt64, Double, Bool);
+    scilab_fill_comparisonequal(UInt64, Int8, M_M, UInt64, Int8, Bool);
+    scilab_fill_comparisonequal(UInt64, UInt8, M_M, UInt64, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt64, Int16, M_M, UInt64, Int16, Bool);
+    scilab_fill_comparisonequal(UInt64, UInt16, M_M, UInt64, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt64, Int32, M_M, UInt64, Int32, Bool);
+    scilab_fill_comparisonequal(UInt64, UInt32, M_M, UInt64, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt64, Int64, M_M, UInt64, Int64, Bool);
+    scilab_fill_comparisonequal(UInt64, UInt64, M_M, UInt64, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt64, Bool, M_B, UInt64, Bool, Bool);
+    scilab_fill_comparisonequal(UInt64, Empty, M_E, UInt64, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(UInt64, ScalarDouble, M_S, UInt64, Double, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarInt8, M_S, UInt64, Int8, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarUInt8, M_S, UInt64, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarInt16, M_S, UInt64, Int16, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarUInt16, M_S, UInt64, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarInt32, M_S, UInt64, Int32, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarUInt32, M_S, UInt64, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarInt64, M_S, UInt64, Int64, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarUInt64, M_S, UInt64, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarBool, M_B, UInt64, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarUInt64, Double, S_M, UInt64, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Int8, S_M, UInt64, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, UInt8, S_M, UInt64, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Int16, S_M, UInt64, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, UInt16, S_M, UInt64, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Int32, S_M, UInt64, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, UInt32, S_M, UInt64, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Int64, S_M, UInt64, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, UInt64, S_M, UInt64, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Bool, S_B, UInt64, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Empty, M_E, UInt64, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarBool, M_E, UInt64, Bool, Bool);
+
+    //Bool
+    //Matrix == Matrix
+    scilab_fill_comparisonequal(Bool, Double, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(Bool, Int8, B_M, Bool, Int8, Bool);
+    scilab_fill_comparisonequal(Bool, UInt8, B_M, Bool, UInt8, Bool);
+    scilab_fill_comparisonequal(Bool, Int16, B_M, Bool, Int16, Bool);
+    scilab_fill_comparisonequal(Bool, UInt16, B_M, Bool, UInt16, Bool);
+    scilab_fill_comparisonequal(Bool, Int32, B_M, Bool, Int32, Bool);
+    scilab_fill_comparisonequal(Bool, UInt32, B_M, Bool, UInt32, Bool);
+    scilab_fill_comparisonequal(Bool, Int64, B_M, Bool, Int64, Bool);
+    scilab_fill_comparisonequal(Bool, UInt64, B_M, Bool, UInt64, Bool);
+    scilab_fill_comparisonequal(Bool, Bool, M_M, Bool, Bool, Bool);
+    scilab_fill_comparisonequal(Bool, Empty, M_E, Bool, Double, Bool);
+
+    //Matrix == Scalar
+    scilab_fill_comparisonequal(Bool, ScalarDouble, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarInt8, B_S, Bool, Int8, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarUInt8, B_S, Bool, UInt8, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarInt16, B_S, Bool, Int16, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarUInt16, B_S, Bool, UInt16, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarInt32, B_S, Bool, Int32, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarUInt32, B_S, Bool, UInt32, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarInt64, B_S, Bool, Int64, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarUInt64, B_S, Bool, UInt64, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarBool, M_S, Bool, Bool, Bool);
+
+    //Scalar == Matrix
+    scilab_fill_comparisonequal(ScalarBool, Double, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Int8, B_M, Bool, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarBool, UInt8, B_M, Bool, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Int16, B_M, Bool, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarBool, UInt16, B_M, Bool, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Int32, B_M, Bool, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarBool, UInt32, B_M, Bool, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Int64, B_M, Bool, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarBool, UInt64, B_M, Bool, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Bool, S_M, Bool, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Empty, M_E, Bool, Double, Bool);
+
+    //Scalar == Scalar
+    scilab_fill_comparisonequal(ScalarBool, ScalarDouble, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarInt8, M_E, Bool, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarUInt8, M_E, Bool, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarInt16, M_E, Bool, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarUInt16, M_E, Bool, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarInt32, M_E, Bool, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarUInt32, M_E, Bool, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarInt64, M_E, Bool, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarUInt64, M_E, Bool, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
+
+    //Bool == Identity
+    scilab_fill_comparisonequal(Bool, Identity, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(Bool, IdentityComplex, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Identity, M_E, Bool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarBool, IdentityComplex, M_E, Bool, Double, Bool);
+
+    //Bool == Polynom
+    scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarBool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarBool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+
+    //Bool == Sparse
+    scilab_fill_comparisonequal(Bool, Sparse, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparisonequal(Bool, SparseComplex, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparisonequal(ScalarBool, Sparse, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparisonequal(ScalarBool, SparseComplex, M_E, Bool, Sparse, Bool);
+
+    //Identity
+    scilab_fill_comparisonequal(Identity, Double, I_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, DoubleComplex, I_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, ScalarDouble, I_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, ScalarDoubleComplex, I_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, Identity, I_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, IdentityComplex, I_IC, Double, Double, Bool);
+    scilab_fill_comparisonequal(Identity, Empty, M_E, Double, Double, Bool);
+
+    scilab_fill_comparisonequal(Identity, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Identity, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Identity, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Identity, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(Identity, Sparse, M_E, Double, Sparse, SparseBool);
+    scilab_fill_comparisonequal(Identity, SparseComplex, M_E, Double, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(IdentityComplex, Double, IC_M, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, ScalarDouble, IC_S, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, Identity, IC_I, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, Empty, M_E, Double, Double, Bool);
+
+    scilab_fill_comparisonequal(IdentityComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, Sparse, M_E, Double, Sparse, SparseBool);
+    scilab_fill_comparisonequal(IdentityComplex, SparseComplex, M_E, Double, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Identity, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(Identity, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, ScalarBool, M_E, Double, Bool, Bool);
+
+    //Polynom
+
+    //poly == poly
+    scilab_fill_comparisonequal(Polynom, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(Polynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //poly == scalar poly
+    scilab_fill_comparisonequal(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //poly == double
+    scilab_fill_comparisonequal(Polynom, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(Polynom, DoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly == scalar double
+    scilab_fill_comparisonequal(Polynom, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly == Bool
+    scilab_fill_comparisonequal(Polynom, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarBool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
+
+    //poly == []
+    scilab_fill_comparisonequal(Polynom, Empty, M_E, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Empty, M_E, Polynom, Double, Bool);
+
+    //poly == eye
+    scilab_fill_comparisonequal(Polynom, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(Polynom, IdentityComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
+
+    //scalar poly == poly
+    scilab_fill_comparisonequal(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //scalar poly == scalar poly
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //scalar poly == double
+    scilab_fill_comparisonequal(ScalarPolynom, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, DoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
+
+    //scalar poly == scalar double
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly == Bool
+    scilab_fill_comparisonequal(ScalarPolynom, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarBool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
+
+    //scalar poly == []
+    scilab_fill_comparisonequal(ScalarPolynom, Empty, M_E, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Bool);
+
+    //scalar poly == eye
+    scilab_fill_comparisonequal(ScalarPolynom, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, IdentityComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
+
+    //poly == Int8
+    scilab_fill_comparisonequal(Polynom, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(Polynom, UInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparisonequal(Int8, Polynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt8, Polynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparisonequal(Int8, PolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, UInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparisonequal(Int8, ScalarPolynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparisonequal(Int8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    //poly == Int16
+    scilab_fill_comparisonequal(Polynom, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(Polynom, UInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparisonequal(Int16, Polynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt16, Polynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparisonequal(Int16, PolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, UInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparisonequal(Int16, ScalarPolynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparisonequal(Int16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    //poly == Int32
+    scilab_fill_comparisonequal(Polynom, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(Polynom, UInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparisonequal(Int32, Polynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt32, Polynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparisonequal(Int32, PolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, UInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparisonequal(Int32, ScalarPolynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparisonequal(Int32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    //poly == Int64
+    scilab_fill_comparisonequal(Polynom, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(Polynom, UInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparisonequal(Int64, Polynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt64, Polynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparisonequal(Int64, PolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, UInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparisonequal(Int64, ScalarPolynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparisonequal(Int64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(UInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    //poly == Int8
+    scilab_fill_comparisonequal(Polynom, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt8, Polynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, Polynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, PolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt8, ScalarPolynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    //poly == Int16
+    scilab_fill_comparisonequal(Polynom, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt16, Polynom, M_P, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, Polynom, M_P, Polynom, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, PolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt16, ScalarPolynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    //poly == Int32
+    scilab_fill_comparisonequal(Polynom, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt32, Polynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, Polynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, PolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt32, ScalarPolynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    //poly == Int64
+    scilab_fill_comparisonequal(Polynom, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(Polynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt64, Polynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, Polynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, PolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparisonequal(ScalarInt64, ScalarPolynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    //poly == bool
+    scilab_fill_comparisonequal(Polynom, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(PolynomComplex, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarPolynom, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparisonequal(ScalarPolynomComplex, Bool, M_E, Polynom, Bool, Bool);
+
+    scilab_fill_comparisonequal(Bool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparisonequal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+
+    //Sparse
+    scilab_fill_comparisonequal(Sparse, Sparse, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparisonequal(Sparse, SparseComplex, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparisonequal(Sparse, Double, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(Sparse, DoubleComplex, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(Sparse, ScalarDouble, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(Sparse, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, Empty, M_E, Sparse, Double, Bool);
+    scilab_fill_comparisonequal(Sparse, Identity, M_E, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(Sparse, IdentityComplex, M_E, Sparse, Double, SparseBool);
+
+    scilab_fill_comparisonequal(SparseComplex, Sparse, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, SparseComplex, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, Double, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, DoubleComplex, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarDouble, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
+
+    scilab_fill_comparisonequal(SparseComplex, Empty, M_E, Sparse, Double, Bool);
+    scilab_fill_comparisonequal(SparseComplex, Identity, M_E, Sparse, Double, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, IdentityComplex, M_E, Sparse, Double, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, Bool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparisonequal(Sparse, ScalarBool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparisonequal(SparseComplex, Bool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarBool, M_E, Sparse, Bool, Bool);
+
+    scilab_fill_comparisonequal(Sparse, Int8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparisonequal(Int8, Sparse, M_SP, Int8, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, Int8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparisonequal(Int8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, UInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparisonequal(UInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, UInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparisonequal(UInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, Int16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparisonequal(Int16, Sparse, M_SP, Int16, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, Int16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparisonequal(Int16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, UInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparisonequal(UInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, UInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparisonequal(UInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, Int32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparisonequal(Int32, Sparse, M_SP, Int32, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, Int32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparisonequal(Int32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, UInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparisonequal(UInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, UInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparisonequal(UInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, Int64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparisonequal(Int64, Sparse, M_SP, Int64, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, Int64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparisonequal(Int64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, UInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparisonequal(UInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, UInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparisonequal(UInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt8, Sparse, M_SP, Int8, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt16, Sparse, M_SP, Int16, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt32, Sparse, M_SP, Int32, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt64, Sparse, M_SP, Int64, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparisonequal(ScalarInt64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
+
+    scilab_fill_comparisonequal(Sparse, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
+    scilab_fill_comparisonequal(SparseComplex, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparisonequal(ScalarUInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
+
+
+    //SparseBool
+    scilab_fill_comparisonequal(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
+    scilab_fill_comparisonequal(SparseBool, Bool, M_M, SparseBool, Bool, SparseBool);
+    scilab_fill_comparisonequal(Bool, SparseBool, M_M, Bool, SparseBool, SparseBool);
+    scilab_fill_comparisonequal(SparseBool, ScalarBool, M_M, SparseBool, Bool, SparseBool);
+    scilab_fill_comparisonequal(ScalarBool, SparseBool, M_M, Bool, SparseBool, SparseBool);
+
+    scilab_fill_comparisonequal(SparseBool, Double, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(Double, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, DoubleComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(DoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, ScalarDouble, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDouble, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarDoubleComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(ScalarDoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Empty, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(Empty, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, Identity, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(Identity, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, IdentityComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparisonequal(IdentityComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Int8, M_E, SparseBool, Int8, Bool);
+    scilab_fill_comparisonequal(Int8, SparseBool, M_E, Int8, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, UInt8, M_E, SparseBool, UInt8, Bool);
+    scilab_fill_comparisonequal(UInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Int16, M_E, SparseBool, Int16, Bool);
+    scilab_fill_comparisonequal(Int16, SparseBool, M_E, Int16, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, UInt16, M_E, SparseBool, UInt16, Bool);
+    scilab_fill_comparisonequal(UInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Int32, M_E, SparseBool, Int32, Bool);
+    scilab_fill_comparisonequal(Int32, SparseBool, M_E, Int32, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, UInt32, M_E, SparseBool, UInt32, Bool);
+    scilab_fill_comparisonequal(UInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Int64, M_E, SparseBool, Int64, Bool);
+    scilab_fill_comparisonequal(Int64, SparseBool, M_E, Int64, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, UInt64, M_E, SparseBool, UInt64, Bool);
+    scilab_fill_comparisonequal(UInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, ScalarInt8, M_E, SparseBool, Int8, Bool);
+    scilab_fill_comparisonequal(ScalarInt8, SparseBool, M_E, Int8, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarUInt8, M_E, SparseBool, UInt8, Bool);
+    scilab_fill_comparisonequal(ScalarUInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, ScalarInt16, M_E, SparseBool, Int16, Bool);
+    scilab_fill_comparisonequal(ScalarInt16, SparseBool, M_E, Int16, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarUInt16, M_E, SparseBool, UInt16, Bool);
+    scilab_fill_comparisonequal(ScalarUInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, ScalarInt32, M_E, SparseBool, Int32, Bool);
+    scilab_fill_comparisonequal(ScalarInt32, SparseBool, M_E, Int32, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarUInt32, M_E, SparseBool, UInt32, Bool);
+    scilab_fill_comparisonequal(ScalarUInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, ScalarInt64, M_E, SparseBool, Int64, Bool);
+    scilab_fill_comparisonequal(ScalarInt64, SparseBool, M_E, Int64, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarUInt64, M_E, SparseBool, UInt64, Bool);
+    scilab_fill_comparisonequal(ScalarUInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, String, M_E, SparseBool, String, Bool);
+    scilab_fill_comparisonequal(String, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparisonequal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
+    scilab_fill_comparisonequal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, SparseComplex, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparisonequal(SparseComplex, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    scilab_fill_comparisonequal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparisonequal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    //struct
+    scilab_fill_comparisonequal(Struct, Struct, M_M, Struct, Struct, Bool);
+
+    /*    scilab_fill_comparisonequal(Struct, Double, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(Double, Struct, M_E, Double, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, DoubleComplex, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(DoubleComplex, Struct, M_E, Double, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, ScalarDouble, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(ScalarDouble, Struct, M_E, Double, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarDoubleComplex, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(ScalarDoubleComplex, Struct, M_E, Double, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Empty, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(Empty, Struct, M_E, Double, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, Identity, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(Identity, Struct, M_E, Double, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, IdentityComplex, M_E, Struct, Double, Bool);
+        scilab_fill_comparisonequal(IdentityComplex, Struct, M_E, Double, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Int8, M_E, Struct, Int8, Bool);
+        scilab_fill_comparisonequal(Int8, Struct, M_E, Int8, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, UInt8, M_E, Struct, UInt8, Bool);
+        scilab_fill_comparisonequal(UInt8, Struct, M_E, UInt8, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Int16, M_E, Struct, Int16, Bool);
+        scilab_fill_comparisonequal(Int16, Struct, M_E, Int16, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, UInt16, M_E, Struct, UInt16, Bool);
+        scilab_fill_comparisonequal(UInt16, Struct, M_E, UInt16, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Int32, M_E, Struct, Int32, Bool);
+        scilab_fill_comparisonequal(Int32, Struct, M_E, Int32, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, UInt32, M_E, Struct, UInt32, Bool);
+        scilab_fill_comparisonequal(UInt32, Struct, M_E, UInt32, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Int64, M_E, Struct, Int64, Bool);
+        scilab_fill_comparisonequal(Int64, Struct, M_E, Int64, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, UInt64, M_E, Struct, UInt64, Bool);
+        scilab_fill_comparisonequal(UInt64, Struct, M_E, UInt64, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, ScalarInt8, M_E, Struct, Int8, Bool);
+        scilab_fill_comparisonequal(ScalarInt8, Struct, M_E, Int8, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarUInt8, M_E, Struct, UInt8, Bool);
+        scilab_fill_comparisonequal(ScalarUInt8, Struct, M_E, UInt8, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, ScalarInt16, M_E, Struct, Int16, Bool);
+        scilab_fill_comparisonequal(ScalarInt16, Struct, M_E, Int16, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarUInt16, M_E, Struct, UInt16, Bool);
+        scilab_fill_comparisonequal(ScalarUInt16, Struct, M_E, UInt16, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, ScalarInt32, M_E, Struct, Int32, Bool);
+        scilab_fill_comparisonequal(ScalarInt32, Struct, M_E, Int32, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarUInt32, M_E, Struct, UInt32, Bool);
+        scilab_fill_comparisonequal(ScalarUInt32, Struct, M_E, UInt32, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, ScalarInt64, M_E, Struct, Int64, Bool);
+        scilab_fill_comparisonequal(ScalarInt64, Struct, M_E, Int64, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarUInt64, M_E, Struct, UInt64, Bool);
+        scilab_fill_comparisonequal(ScalarUInt64, Struct, M_E, UInt64, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, String, M_E, Struct, String, Bool);
+        scilab_fill_comparisonequal(String, Struct, M_E, String, Struct, Bool);
+        scilab_fill_comparisonequal(Struct, ScalarString, M_E, Struct, String, Bool);
+        scilab_fill_comparisonequal(ScalarString, Struct, M_E, String, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, SparseComplex, M_E, Struct, Sparse, Bool);
+        scilab_fill_comparisonequal(SparseComplex, Struct, M_E, Sparse, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, Sparse, M_E, Struct, Sparse, Bool);
+        scilab_fill_comparisonequal(Sparse, Struct, M_E, Sparse, Struct, Bool);
+
+        scilab_fill_comparisonequal(Struct, SparseBool, M_E, Struct, SparseBool, Bool);
+        scilab_fill_comparisonequal(SparseBool, Struct, M_E, SparseBool, Struct, Bool);*/
+
+    //List, TList, MList
+    scilab_fill_comparisonequal(List, List, LT_LT, List, List, Bool);
+    scilab_fill_comparisonequal(MList, MList, LT_LT, MList, MList, Bool);
+    scilab_fill_comparisonequal(TList, TList, LT_LT, TList, TList, Bool);
+
+    scilab_fill_comparisonequal(List, TList, LT_LT, List, TList, Bool);
+    scilab_fill_comparisonequal(TList, List, LT_LT, TList, List, Bool);
+    scilab_fill_comparisonequal(List, MList, LT_LT, List, MList, Bool);
+    scilab_fill_comparisonequal(MList, List, LT_LT, MList, List, Bool);
+
+    scilab_fill_comparisonequal(TList, MList, LT_LT, TList, MList, Bool);
+    scilab_fill_comparisonequal(MList, TList, LT_LT, MList, TList, Bool);
+
+    //Cell
+    scilab_fill_comparisonequal(Cell, Cell, M_M, Cell, Cell, Bool);
+
+    //Handle
+    scilab_fill_comparisonequal(Handle, Handle, M_M, GraphicHandle, GraphicHandle, Bool);
+
+    //Macro
+    scilab_fill_comparisonequal(Macro, Macro, MCR_MCR, Macro, Macro, Bool);
+    scilab_fill_comparisonequal(MacroFile, MacroFile, MCR_MCR, MacroFile, MacroFile, Bool);
+    scilab_fill_comparisonequal(Macro, MacroFile, MCR_MCR, Macro, MacroFile, Bool);
+    scilab_fill_comparisonequal(MacroFile, Macro, MCR_MCR, MacroFile, Macro, Bool);
 
-    InternalType* pIL = _pLeftOperand;
-    InternalType* pIR = _pRightOperand;
-    bool bAllocL = false;
-    bool bAllocR = false;
 
+#undef scilab_fill_comparisonequal
+
+}
+
+InternalType *GenericComparisonEqual(InternalType *_pLeftOperand, InternalType *_pRightOperand)
+{
     InternalType *pResult = NULL;
 
-    /*
-    ** [] == ??
-    */
-    if (TypeL == GenericType::ScilabDouble && pIL->getAs<Double>()->getSize() == 0)
+    compequal_function compequal = pComparisonEqualfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
+    if (compequal)
     {
-        if (TypeR != InternalType::ScilabDouble)
+        pResult = compequal(_pLeftOperand, _pRightOperand);
+        if (pResult)
         {
-            return new Bool(false);
+            return pResult;
         }
     }
 
     /*
-    ** ?? == []
+    ** Default case : Return NULL will Call Overloading.
     */
-    if (TypeR == GenericType::ScilabDouble && pIR->getAs<Double>()->getSize() == 0)
-    {
-        if (TypeL != InternalType::ScilabDouble)
-        {
-            return new Bool(false);
-        }
-    }
+    return NULL;
+}
+
+
+//Matrix == x
+template<class T, class U, class O>
+InternalType* compequal_M_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
 
-    if (TypeL == GenericType::ScilabColon && TypeR == GenericType::ScilabColon)
+    if (iDimsL != iDimsR)
     {
-        //: == :
-        return new Bool(true);
+        return new Bool(false);
     }
 
-    if (TypeL == GenericType::ScilabColon)
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
     {
-        // : == x
-        if (pIR->isGenericType())
-        {
-            //transform left operand in a identity matrix with same dimension of right operand
-            GenericType* pGT = pIR->getAs<GenericType>();
-            pIL = Double::Identity(pGT->getDims(), pGT->getDimsArray());;
-            TypeL = GenericType::ScilabDouble;
-            bAllocL = true;
-        }
-        else
+        if (piDimsL[i] != piDimsR[i])
         {
             return new Bool(false);
         }
     }
 
-    if (TypeR == GenericType::ScilabColon)
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    compequal(_pL->get(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_M_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
     {
-        // x == :
-        if (pIL->isGenericType())
-        {
-            //transform right operand in a identity matrix with same dimensions of left operand
-            GenericType* pGT = pIL->getAs<GenericType>();
-            pIR = Double::Identity(pGT->getDims(), pGT->getDimsArray());;
-            TypeR = GenericType::ScilabDouble;
-            bAllocR = true;
-        }
-        else
-        {
-            return new Bool(false);
-        }
+        return new Bool(false);
     }
 
-    /*
-    ** DOUBLE == DOUBLE
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabDouble)
-    {
-        Double *pL   = pIL->getAs<Double>();
-        Double *pR   = pIR->getAs<Double>();
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
 
-        int iResult = EqualToDoubleAndDouble(pL, pR, (GenericType**)&pResult);
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        if (iResult)
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
         {
-
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            return new Bool(false);
         }
-
-        return pResult;
     }
 
-    /*
-    ** STRING == STRING
-    */
-    if (TypeL == GenericType::ScilabString && TypeR == GenericType::ScilabString)
-    {
-        String *pL   = pIL->getAs<String>();
-        String *pR   = pIR->getAs<String>();
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
 
-        if (pL->isScalar())
-        {
-            pResult = new Bool(pR->getDims(), pR->getDimsArray());
+    compequal(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
 
-            wchar_t* pstL = pL->get(0);
-            for (int i = 0 ; i < pR->getSize() ; i++)
-            {
-                pResult->getAs<Bool>()->set(i, wcscmp(pstL, pR->get(i)) == 0);
-            }
+template<class T, class U, class O>
+InternalType* compequal_M_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compequal(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
+    return pOut;
+}
 
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
-        }
+template<class T, class U, class O>
+InternalType* compequal_M_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compequal(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
 
-        if (pR->isScalar())
-        {
-            pResult = new Bool(pL->getDims(), pL->getDimsArray());
+template<class T, class U, class O>
+InternalType* compequal_M_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
+    compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
 
-            wchar_t* pstR = pR->get(0);
-            for (int i = 0 ; i < pL->getSize() ; i++)
-            {
-                pResult->getAs<Bool>()->set(i, wcscmp(pL->get(i), pstR) == 0);
-            }
+template<class T, class U, class O>
+InternalType* compequal_M_IC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
+    compequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
 
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
-        }
+template<class T, class U, class O>
+InternalType* compequal_M_E(T *_pL, U *_pR)
+{
+    return new Bool(false);
+}
+
+template<class T, class U, class O>
+InternalType* compequal_E_M(T *_pL, U *_pR)
+{
+    return new Bool(false);
+}
+
+template<class T, class U, class O>
+InternalType* compequal_E_E(T *_pL, U *_pR)
+{
+    return new Bool(true);
+}
 
-        int iDims1 = pL->getDims();
-        int iDims2 = pR->getDims();
+//B == x
+template<class T, class U, class O>
+InternalType* compequal_B_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+    int* piDimsR = _pR->getDimsArray();
 
-        if (iDims1 != iDims2)
+    if (_pL->isScalar() == false)
+    {
+        if (iDimsL != iDimsR)
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
             return new Bool(false);
         }
 
-        int* piDims1 = pL->getDimsArray();
-        int* piDims2 = pR->getDimsArray();
+        int* piDimsL = _pL->getDimsArray();
 
-        for (int i = 0 ; i < iDims1 ; i++)
+        for (int i = 0; i < iDimsL; ++i)
         {
-            if (piDims1[i] != piDims2[i])
+            if (piDimsL[i] != piDimsR[i])
             {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
                 return new Bool(false);
             }
         }
+    }
 
-        pResult = new Bool(pL->getDims(), pL->getDimsArray());
+    O* pOut = new O(iDimsR, piDimsR);
 
-        for (int i = 0 ; i < pL->getSize() ; i++)
-        {
-            pResult->getAs<Bool>()->set(i, wcscmp(pL->get(i), pR->get(i)) == 0);
-        }
+    pOut->setFalse();
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
+    return pOut;
+}
 
-    /*
-    ** BOOL == BOOL
-    */
-    if (TypeL == GenericType::ScilabBool && TypeR == GenericType::ScilabBool)
-    {
-        Bool *pL   = pIL->getAs<Bool>();
-        Bool *pR   = pIR->getAs<Bool>();
+template<class T, class U, class O>
+InternalType* compequal_M_B(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+    int* piDimsL = _pL->getDimsArray();
 
-        if (pL->isScalar())
+    if (_pR->isScalar() == false)
+    {
+        if (iDimsL != iDimsR)
         {
-            pResult = new Bool(pR->getDims(), pR->getDimsArray());
-
-            int iL = pL->get(0);
-            for (int i = 0 ; i < pR->getSize() ; i++)
-            {
-                pResult->getAs<Bool>()->set(i, iL == pR->get(i));
-            }
-
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
+            return new Bool(false);
         }
 
-        if (pR->isScalar())
-        {
-            pResult = new Bool(pL->getDims(), pL->getDimsArray());
+        int* piDimsR = _pR->getDimsArray();
 
-            int iR = pR->get(0);
-            for (int i = 0 ; i < pL->getSize() ; i++)
+        for (int i = 0; i < iDimsL; ++i)
+        {
+            if (piDimsL[i] != piDimsR[i])
             {
-                pResult->getAs<Bool>()->set(i, iR == pL->get(i));
+                return new Bool(false);
             }
-
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
         }
+    }
 
+    O* pOut = new O(iDimsL, piDimsL);
 
-        int iDims1 = pL->getDims();
-        int iDims2 = pR->getDims();
+    pOut->setFalse();
 
-        if (iDims1 != iDims2)
-        {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(false);
-        }
+    return pOut;
+}
 
-        int* piDims1 = pL->getDimsArray();
-        int* piDims2 = pR->getDimsArray();
+//B == x
+template<class T, class U, class O>
+InternalType* compequal_B_S(T *_pL, U *_pR)
+{
 
-        for (int i = 0 ; i < iDims1 ; i++)
-        {
-            if (piDims1[i] != piDims2[i])
-            {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
-                return new Bool(false);
-            }
-        }
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
 
-        pResult = new Bool(pL->getDims(), pL->getDimsArray());
+    pOut->setFalse();
 
-        for (int i = 0 ; i < pL->getSize() ; i++)
-        {
-            pResult->getAs<Bool>()->set(i, pL->get(i) == pR->get(i));
-        }
+    return pOut;
+}
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
+template<class T, class U, class O>
+InternalType* compequal_S_B(T *_pL, U *_pR)
+{
 
-    /*
-    ** POLY == POLY
-    */
-    if (TypeL == GenericType::ScilabPolynom && TypeR == GenericType::ScilabPolynom)
-    {
-        Polynom *pL   = pIL->getAs<Polynom>();
-        Polynom *pR   = pIR->getAs<Polynom>();
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
 
-        if (pL->isScalar())
-        {
-            pResult = new Bool(pR->getDims(), pR->getDimsArray());
+    pOut->setFalse();
 
-            SinglePoly* pSL = pL->get(0);
-            for (int i = 0 ; i < pR->getSize() ; i++)
-            {
-                pResult->getAs<Bool>()->set(i, *pSL == *pR->get(i));
-            }
+    return pOut;
+}
 
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
-        }
 
-        if (pR->isScalar())
-        {
-            pResult = new Bool(pL->getDims(), pL->getDimsArray());
 
-            SinglePoly* pSR = pR->get(0);
-            for (int i = 0 ; i < pL->getSize() ; i++)
-            {
-                pResult->getAs<Bool>()->set(i, *pSR == *pL->get(i));
-            }
+//Matrix complex == x
+template<class T, class U, class O>
+InternalType* compequal_MC_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
 
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
-        }
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(false);
+    }
 
-        if (pL->getDims() != pR->getDims())
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
             return new Bool(false);
         }
+    }
 
-        int* piDims1 = pL->getDimsArray();
-        int* piDims2 = pR->getDimsArray();
-
-        for (int i = 0 ; i < pL->getDims() ; i++)
-        {
-            if (piDims1[i] != piDims2[i])
-            {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
-                return new Bool(false);
-            }
-        }
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
 
-        pResult = new Bool(pL->getDims(), pL->getDimsArray());
+    compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
 
-        for (int i = 0 ; i < pL->getSize() ; i++)
-        {
-            pResult->getAs<Bool>()->set(i, *pL->get(i) == *pR->get(i));
-        }
+template<class T, class U, class O>
+InternalType* compequal_MC_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(false);
     }
 
-    /*
-    ** DOUBLE == POLY
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabPolynom)
-    {
-        Double *pL  = pIL->getAs<Double>();
-        Polynom *pR = pIR->getAs<Polynom>();
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
 
-        if (pR->isScalar())
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
         {
-            pResult         = new Bool(pL->getDims(), pL->getDimsArray());
-            int* piResult   = pResult->getAs<Bool>()->get();
-            int iSize       = pL->getSize();
-            int iRank       = 0;
-
-            pR->getRank(&iRank);
-            if (iRank != 0) // check rank
-            {
-                memset(piResult, 0x00, iSize * sizeof(int));
-            }
-            else
-            {
-                // check values
-                double dR       = pR->get(0)->get(0);
-                double* pdblL   = pL->get();
-                if (pL->isComplex() && pR->isComplex())
-                {
-                    double dRImg    = pR->get(0)->getImg(0);
-                    double* pdblLImg = pL->getImg();
-                    for (int i = 0 ; i < iSize; i++)
-                    {
-                        piResult[i] = (int)((dR == pdblL[i]) && (dRImg == pdblLImg[i]));
-                    }
-                }
-                else if (pL->isComplex())
-                {
-                    double* pdblLImg = pL->getImg();
-                    for (int i = 0 ; i < iSize; i++)
-                    {
-                        piResult[i] = (int)((dR == pdblL[i]) && (pdblLImg[i] == 0));
-                    }
-                }
-                else if (pR->isComplex())
-                {
-                    double dRImg    = pR->get(0)->getImg(0);
-                    for (int i = 0 ; i < iSize; i++)
-                    {
-                        piResult[i] = (int)((dR == pdblL[i]) && (dRImg == 0));
-                    }
-                }
-                else
-                {
-                    for (int i = 0 ; i < iSize; i++)
-                    {
-                        piResult[i] = (int)(dR == pdblL[i]);
-                    }
-                }
-            }
-
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return pResult;
+            return new Bool(false);
         }
+    }
 
-        if (pL->isScalar())
-        {
-            pResult         = new Bool(pR->getDims(), pR->getDimsArray());
-            int* piResult   = pResult->getAs<Bool>()->get();
-            int iSize       = pR->getSize();
-            int* piRank     = new int[iSize];
-            double dL       = pL->get(0);
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
 
-            pR->getRank(piRank);
+    compequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
 
-            if (pL->isComplex() && pR->isComplex())
-            {
-                double dLImg = pL->getImg(0);
-                for (int i = 0 ; i < iSize; i++)
-                {
-                    if (piRank[i] == 0)
-                    {
-                        piResult[i] = (int)(dL == pR->get(i)->get(0) &&
-                                            dLImg == pR->get(i)->getImg(0));
-                    }
-                    else
-                    {
-                        piResult[i] = 0;
-                    }
-                }
-            }
-            else if (pL->isComplex())
-            {
-                double dLImg = pL->getImg(0);
-                for (int i = 0 ; i < iSize; i++)
-                {
-                    if (piRank[i] == 0)
-                    {
-                        piResult[i] = (int)(dL == pR->get(i)->get(0) &&
-                                            dLImg == 0);
-                    }
-                    else
-                    {
-                        piResult[i] = 0;
-                    }
-                }
-            }
-            else if (pR->isComplex())
-            {
-                for (int i = 0 ; i < iSize; i++)
-                {
-                    if (piRank[i] == 0)
-                    {
-                        piResult[i] = (int)(dL == pR->get(i)->get(0) &&
-                                            pR->get(i)->getImg(0) == 0);
-                    }
-                    else
-                    {
-                        piResult[i] = 0;
-                    }
-                }
-            }
-            else
-            {
-                for (int i = 0 ; i < iSize; i++)
-                {
-                    piResult[i] = piRank[i] ? 0 : (int)(dL == pR->get(i)->get(0));
-                }
-            }
+template<class T, class U, class O>
+InternalType* compequal_MC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get());
+    return pOut;
+}
 
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            delete[] piRank;
-            return pResult;
-        }
+template<class T, class U, class O>
+InternalType* compequal_MC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
 
-        if (pL->getDims() != pR->getDims())
-        {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(false);
-        }
+template<class T, class U, class O>
+InternalType* compequal_MC_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
+    compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
 
-        int* piDims1 = pL->getDimsArray();
-        int* piDims2 = pR->getDimsArray();
+template<class T, class U, class O>
+InternalType* compequal_MC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
+    compequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
 
-        for (int i = 0 ; i < pL->getDims() ; i++)
-        {
-            if (piDims1[i] != piDims2[i])
-            {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
-                return new Bool(false);
-            }
-        }
+//Scalar == x
+template<class T, class U, class O>
+InternalType* compequal_S_M(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compequal(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
+    return pOut;
+}
 
-        pResult         = new Bool(pL->getDims(), pL->getDimsArray());
-        int* piResult   = pResult->getAs<Bool>()->get();
-        int iSize       = pL->getSize();
-        int* piRank     = new int[iSize];
-        double* pdblL   = pL->get();
+template<class T, class U, class O>
+InternalType* compequal_S_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compequal(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
 
-        pR->getRank(piRank);
+template<class T, class U, class O>
+InternalType* compequal_S_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
 
-        if (pL->isComplex() && pR->isComplex())
-        {
-            double* pdblLImg = pL->getImg();
-            for (int i = 0 ; i < iSize; i++)
-            {
-                if (piRank[i] == 0)
-                {
-                    piResult[i] = (int)(pdblL[i] == pR->get(i)->get(0) &&
-                                        pdblLImg[i] == pR->get(i)->getImg(0));
-                }
-                else
-                {
-                    piResult[i] = 0;
-                }
+template<class T, class U, class O>
+InternalType* compequal_S_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compequal(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_S_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_S_IC(T *_pL, U *_pR)
+{
+
+    O* pOut = new  Bool(false);
+    compequal(_pL->get(0), 1, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+//Scalar complex == x
+template<class T, class U, class O>
+InternalType* compequal_SC_M(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_SC_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_SC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(false);
+    if (_pL->getImg(0) == 0)
+    {
+        compequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_SC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(true);
+    compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_SC_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(false);
+    if (_pL->getImg(0) == 0)
+    {
+        compequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_SC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(false);
+    compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+//Identity == x
+template<class T, class U, class O>
+InternalType* compequal_I_M(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
+    compequal(pIdentity->get(), pOut->getSize(), _pR->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_I_MC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
+    compequal(pIdentity->get(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_I_S(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(1, 1);
+    compequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_I_SC(T *_pL, U *_pR)
+{
+    return compequal_SC_I<U, T, O>(_pR, _pL);
+}
+
+template<class T, class U, class O>
+InternalType* compequal_I_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(1, 1);
+    compequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_I_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(false);
+    if (_pR->getImg(0) == 0)
+    {
+        compequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+//Identity complex == x
+template<class T, class U, class O>
+InternalType* compequal_IC_M(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
+    compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_IC_MC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
+    compequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_IC_S(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(false);
+    if (_pL->getImg(0) == 0)
+    {
+        compequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_IC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(1, 1);
+    compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_IC_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(false);
+    if (_pL->getImg(0) == 0)
+    {
+        compequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_IC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(1, 1);
+    compequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<>
+InternalType* compequal_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
+{
+    //pending changes
+    if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
+    {
+        return new Bool(false);
+    }
+
+    return _pR->newEqualTo(*_pL);
+}
+
+template<>
+InternalType* compequal_M_M<Sparse, Sparse, SparseBool>(Sparse* _pL, Sparse* _pR)
+{
+    //pending changes
+    if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
+    {
+        return new Bool(false);
+    }
+
+    return _pR->newEqualTo(*_pL);
+}
+
+//[] == SP
+template<>
+InternalType* compequal_M_M<Double, Sparse, Bool>(Double* _pL, Sparse* _pR)
+{
+    return new Bool(false);
+}
+
+//SP == []
+template<>
+InternalType* compequal_M_M<Sparse, Double, Bool>(Sparse* _pL, Double* _pR)
+{
+    return new Bool(false);
+}
+
+//sparse
+template<class T, class U, class O>
+InternalType* compequal_M_SP(T* _pL, U* _pR)
+{
+    //pending changes
+
+    //D -> SP == SP
+    Sparse* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+
+    if (_pL->isScalar())
+    {
+        int iSizeOut = _pR->getSize();
+        if (_pL->isComplex())
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
+            std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, stComplex);
             }
         }
-        else if (pL->isComplex())
+        else
         {
-            double* pdblLImg = pL->getImg();
-            for (int i = 0 ; i < iSize; i++)
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
             {
-                if (piRank[i] == 0)
-                {
-                    piResult[i] = (int)(pdblL[i] == pR->get(i)->get(0) &&
-                                        pdblLImg[i] == 0);
-                }
-                else
-                {
-                    piResult[i] = 0;
-                }
+                pspConvert->set(i, (double)_pL->get(0));
             }
         }
-        else if (pR->isComplex())
+    }
+    else
+    {
+        //check dimensions
+        if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
         {
-            for (int i = 0 ; i < iSize; i++)
+            return new Bool(false);
+        }
+
+        int iSizeOut = _pR->getSize();
+        if (_pL->isComplex())
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
+
+            for (int i = 0; i < iSizeOut; i++)
             {
-                if (piRank[i] == 0)
-                {
-                    piResult[i] = (int)(pdblL[i] == pR->get(i)->get(0) &&
-                                        pR->get(i)->getImg(0) == 0);
-                }
-                else
-                {
-                    piResult[i] = 0;
-                }
+                std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
+                pspConvert->set(i, stComplex);
             }
         }
         else
         {
-            for (int i = 0 ; i < iSize; i++)
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
             {
-                piResult[i] = piRank[i] ? 0 : (int)(pdblL[i] == pR->get(i)->get(0));
+                pspConvert->set(i, (double)_pL->get(i));
             }
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        delete[] piRank;
-        return pResult;
     }
 
-    /*
-    ** POLY == DOUBLE
-    */
-    if (TypeL == GenericType::ScilabPolynom && TypeR == GenericType::ScilabDouble)
-    {
-        return GenericComparisonEqual(_pRightOperand, _pLeftOperand);
-    }
+    pOut = _pR->newEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+}
 
-    /*
-    ** LIST == LIST
-    */
-    if (pIL->isList() && pIR->isList())
+template<class T, class U, class O>
+InternalType* compequal_SP_M(T* _pL, U* _pR)
+{
+    //pending changes
+
+    Sparse* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+    if (_pR->isScalar())
     {
-        List* pLL = pIL->getAs<List>();
-        List* pLR = pIR->getAs<List>();
-
-        // check if an overload exists
-        if (TypeL == GenericType::ScilabMList ||
-                TypeL == GenericType::ScilabTList ||
-                TypeR == GenericType::ScilabMList ||
-                TypeR == GenericType::ScilabTList)
+        int iSizeOut = _pL->getSize();
+        if (_pR->isComplex())
         {
-            std::wstring function_name;
-            function_name = L"%" + pLL->getShortTypeStr() + L"_o_" + pLR->getShortTypeStr();
-            InternalType* pFunc = symbol::Context::getInstance()->get(symbol::Symbol(function_name));
-
-            if (pFunc)
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
+            std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
+            for (int i = 0; i < iSizeOut; i++)
             {
-                //call overload
-                return NULL;
+                pspConvert->set(i, stComplex);
             }
         }
-
-        if (pLL->getSize() != pLR->getSize())
-        {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(false);
-        }
-
-        if (pLL->getSize() == 0 && pLR->getSize() == 0)
-        {
-            //list() == list() -> return true
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(true);
-        }
-
-        Bool* pB = new Bool(1, pLL->getSize());
-        for (int i = 0 ; i < pLL->getSize() ; i++)
+        else
         {
-            pB->set(i, ((*pLL->get(i) == *pLR->get(i)) && (pLL->get(i)->getType() != types::InternalType::ScilabVoid)));
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pR->get(0));
+            }
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pB;
     }
-
-    /*
-    ** CELL == CELL
-    */
-    if (TypeL == GenericType::ScilabCell && TypeR == GenericType::ScilabCell)
+    else
     {
-        Cell* pCL = pIL->getAs<Cell>();
-        Cell* pCR = pIR->getAs<Cell>();
-
-        /* check dimension*/
-        if (pCL->getDims() != pCR->getDims())
+        //check dimensions
+        if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
             return new Bool(false);
         }
 
-        int* piDimsL = pCL->getDimsArray();
-        int* piDimsR = pCR->getDimsArray();
-
-        for (int i = 0 ; i < pCL->getDims() ; i++)
+        int iSizeOut = _pL->getSize();
+        if (_pR->isComplex())
         {
-            if (piDimsL[i] != piDimsR[i])
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
+
+            for (int i = 0; i < iSizeOut; i++)
             {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
-                return new Bool(false);
+                std::complex<double> stComplex((double)_pR->get(i), (double)_pR->getImg(i));
+                pspConvert->set(i, stComplex);
             }
         }
-
-        if (pCL->getSize() == 0)
+        else
         {
-            //{} == {} -> return true
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(true);
-        }
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pR->get(i));
 
-        Bool *pB = new Bool(pCL->getDims(), piDimsL);
-        for (int i = 0 ; i < pCL->getSize() ; i++)
-        {
-            pB->set(i, *pCL->get(i) == *pCR->get(i));
+            }
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pB;
     }
 
-    /*
-    ** STRUCT == STRUCT
-    */
-    if (TypeL == GenericType::ScilabStruct && TypeR == GenericType::ScilabStruct)
-    {
-        Struct* pStL = pIL->getAs<Struct>();
-        Struct* pStR = pIR->getAs<Struct>();
+    pOut = _pL->newEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
 
-        /* check dimension*/
-        if (pStL->getDims() != pStR->getDims())
-        {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(false);
-        }
+}
+
+//sparsebool
+template<>
+InternalType* compequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
+{
+    //pending changes
+
+    //D -> SP == SP
+    SparseBool* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
 
-        int* piDimsL = pStL->getDimsArray();
-        int* piDimsR = pStR->getDimsArray();
 
-        for (int i = 0 ; i < pStL->getDims() ; i++)
+    if (_pL->isScalar())
+    {
+        int iSizeOut = _pR->getSize();
+
+        pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
+        for (int i = 0; i < iSizeOut; i++)
         {
-            if (piDimsL[i] != piDimsR[i])
-            {
-                clearAlloc(bAllocL, pIL, bAllocR, pIR);
-                return new Bool(false);
-            }
+            pspConvert->set(i, _pL->get(0) == 1);
         }
 
-        if (pStL->getSize() == 0)
+    }
+    else
+    {
+        //check dimensions
+        if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return new Bool(true);
+            return new Bool(false);
         }
 
-        Bool *pB = new Bool(pStL->getDims(), piDimsL);
-        for (int i = 0 ; i < pStL->getSize() ; i++)
+        int iSizeOut = _pR->getSize();
+
+        pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
+        for (int i = 0; i < iSizeOut; i++)
         {
-            pB->set(i, *pStL->get(i) == *pStR->get(i));
+            pspConvert->set(i, _pL->get(i) == 1);
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pB;
     }
 
-    /*
-    ** DOUBLE == STRING
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabString)
-    {
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return new Bool(0);
-    }
+    pOut = _pR->newEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+}
 
-    /*
-    ** STRING == DOUBLE
-    */
-    if (TypeL == GenericType::ScilabString && TypeR == GenericType::ScilabDouble)
-    {
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return new Bool(0);
-    }
+template<>
+InternalType* compequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
+{
+    //pending changes
 
-    /*
-    ** SPARSE == SPARSE
-    */
-    if (TypeL == GenericType::ScilabSparse && TypeR == GenericType::ScilabSparse)
+    SparseBool* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+    if (_pR->isScalar())
     {
-        Sparse* pL = pIL->getAs<Sparse>();
-        Sparse* pR = pIR->getAs<Sparse>();
+        int iSizeOut = _pL->getSize();
 
-        int iResult = EqualToSparseAndSparse(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
+        for (int i = 0; i < iSizeOut; i++)
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            pspConvert->set(i, _pR->get(0) == 1);
         }
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
     }
-
-    /*
-    ** SPARSE == DOUBLE
-    */
-    if (TypeL == GenericType::ScilabSparse && TypeR == GenericType::ScilabDouble)
+    else
     {
-        Sparse* pL = pIL->getAs<Sparse>();
-        Double* pR = pIR->getAs<Double>();
-
-        int iResult = EqualToSparseAndDouble(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        //check dimensions
+        if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            return new Bool(false);
         }
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
+        int iSizeOut = _pL->getSize();
 
-    /*
-    ** DOUBLE == SPARSE
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabSparse)
-    {
-        Double* pL = pIL->getAs<Double>();
-        Sparse* pR = pIR->getAs<Sparse>();
-
-        int iResult = EqualToDoubleAndSparse(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
+        for (int i = 0; i < iSizeOut; i++)
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            pspConvert->set(i, _pR->get(i) == 1);
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
     }
 
-    /*
-    ** SPARSE BOOL == SPARSE BOOL
-    */
-    if (TypeL == GenericType::ScilabSparseBool && TypeR == GenericType::ScilabSparseBool)
-    {
-        SparseBool* pL = pIL->getAs<SparseBool>();
-        SparseBool* pR = pIR->getAs<SparseBool>();
+    pOut = _pL->newEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
 
-        int iResult = EqualToSparseBoolAndSparseBool(pL, pR, (GenericType**)&pResult);
-        if (iResult)
-        {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
-        }
+}
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
+//Polynom
+template<>
+InternalType* compequal_M_M<Polynom, Polynom, Bool>(Polynom* _pL, Polynom* _pR)
+{
+    Bool* pbOut = NULL;
+    bool bPoise = true;
 
-    /*
-    ** SPARSE BOOL == BOOL
-    */
-    if (TypeL == GenericType::ScilabSparseBool && TypeR == GenericType::ScilabBool)
+    SinglePoly** pSPL = _pL->get();
+    SinglePoly** pSPR = _pR->get();
+
+    if (_pR->isScalar())
     {
-        SparseBool* pL = pIL->getAs<SparseBool>();
-        Bool* pR = pIR->getAs<Bool>();
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        int iResult = EqualToSparseBoolAndBool(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        if (_pL->isComplex())
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
-        }
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[0]->get(j), (double)0, pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+        }
+        else
+        {
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[0]->get(j), pSPL[i]->get(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+        }
     }
-
-    /*
-    ** BOOL == SPARSE BOOL
-    */
-    if (TypeL == GenericType::ScilabBool && TypeR == GenericType::ScilabSparseBool)
+    else if (_pL->isScalar())
     {
-        Bool* pL = pIL->getAs<Bool>();
-        SparseBool* pR = pIR->getAs<SparseBool>();
+        pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        int iResult = EqualToBoolAndSparseBool(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        if (pSPR[0]->getSize() != 1)
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
-        }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
+            if (_pL->isComplex())
+            {
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = false;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), pSPR[i]->getImg(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = false;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+            }
+            else
+            {
 
-    /*
-    ** INT == INT
-    */
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = false;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compequal(pSPL[0]->get(j), (double)0, pSPR[i]->get(j), pSPR[i]->get(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = false;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                            {
+                                compequal(pSPL[0]->get(j), pSPR[i]->get(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
 
-    if (pIL->isInt() && pIR->isInt())
+            }
+        }
+    }
+    else
     {
-        if (pIL->getType() != pIR->getType())
+        //check dimensions
+        if (_pL->getDims() != _pR->getDims())
         {
-            //call overload function to convert left or right or both to have comparable type
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            return NULL;
+            return new Bool(false);
         }
 
-        int iResult = EqualToIntAndInt(pIL, pIR, (GenericType**)&pResult);
-        if (iResult)
+        for (int i = 0; i < _pL->getDims(); i++)
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
+            {
+                return new Bool(false);
+            }
         }
 
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
-    }
-
-    /*
-    ** HANDLE == HANDLE
-    */
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-    if (pIL->isHandle() && pIR->isHandle())
-    {
-        int iResult = EqualToArrayAndArray(pIL->getAs<GraphicHandle>(), pIR->getAs<GraphicHandle>(), (GenericType**)&pResult);
-        if (iResult)
+        if (_pL->isComplex())
         {
-            clearAlloc(bAllocL, pIL, bAllocR, pIR);
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPL[i]->get(j), pSPL[i]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+        }
+        else
+        {
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = false;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compequal(pSPR[i]->get(j), pSPL[i]->get(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
         }
-
-        clearAlloc(bAllocL, pIL, bAllocR, pIR);
-        return pResult;
     }
 
-    /*
-    ** MACRO == MACROFILE
-    */
+    return pbOut;
+}
+
+template<class T, class U, class O>
+InternalType* compequal_P_M(T *_pL, U *_pR)
+{
+    Bool* pbOut = NULL;
 
-    if (TypeL == GenericType::ScilabMacro || TypeL == GenericType::ScilabMacroFile)
+    SinglePoly** pSPR = _pL->get();
+
+    if (_pR->isIdentity())
     {
-        bool ret = false;
-        if (TypeL == GenericType::ScilabMacroFile)
+        Double* pdblEye = NULL;
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (_pL->isComplex())
         {
-            types::MacroFile* pL = _pLeftOperand->getAs<types::MacroFile>();
-            ret = *pL == *_pRightOperand;
+            if (_pR->isComplex())
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
         }
-        else if (TypeL == GenericType::ScilabMacro)
+        else
         {
-            types::Macro* pL = _pLeftOperand->getAs<types::Macro>();
-            if (TypeR == GenericType::ScilabMacroFile)
+            if (_pR->isComplex())
             {
-                types::MacroFile* pR = _pRightOperand->getAs<types::MacroFile>();
-                ret = *pR == *pL;
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)0, (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
             }
             else
             {
-                ret = *pL == *_pRightOperand;
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pdblEye->get(i), &(pbOut->get()[i]));
+                    }
+                }
             }
         }
-
-        return new Bool(ret == true ? 1 : 0);
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    clearAlloc(bAllocL, pIL, bAllocR, pIR);
-    return NULL;
-}
-
-int EqualToDoubleAndDouble(types::Double* _pDouble1, types::Double* _pDouble2, types::GenericType** _pOut)
-{
-    int iFree = 0;
-
-    if (_pDouble1->isEmpty() && _pDouble2->isEmpty())
-    {
-        *_pOut = new Bool(true);
-        return 0;
-    }
-
-    if (_pDouble1->isEmpty() || _pDouble2->isEmpty())
-    {
-        *_pOut = new Bool(false);
-        return 0;
-    }
-
-    if (_pDouble2->isComplex() && _pDouble1->isComplex() == false)
-    {
-        _pDouble1 = _pDouble1->clone()->getAs<Double>();
-        _pDouble1->setComplex(true);
-        iFree = 1;
+        delete pdblEye;
     }
-
-    if (_pDouble2->isComplex() == false && _pDouble1->isComplex())
-    {
-        _pDouble2 = _pDouble2->clone()->getAs<Double>();
-        _pDouble2->setComplex(true);
-        iFree = 2;
-    }
-
-    if (_pDouble2->isScalar())
+    else if (_pR->isScalar())
     {
-        Bool* pB = new Bool(_pDouble1->getDims(), _pDouble1->getDimsArray());
-        double dblRefR = _pDouble2->get(0);
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        if (_pDouble1->isComplex())
+        if (_pL->isComplex())
         {
-            double dblRefI = _pDouble2->getImg(0);
-            for (int i = 0 ; i < _pDouble1->getSize() ; i++)
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
             {
-                pB->set(i, (_pDouble1->get(i) == dblRefR) && (_pDouble1->getImg(i) == dblRefI));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)0, &(pbOut->get()[i]));
+                    }
+                }
             }
         }
         else
         {
-            for (int i = 0 ; i < _pDouble1->getSize() ; i++)
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
             {
-                pB->set(i, _pDouble1->get(i) == dblRefR);
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)_pR->get(0), &(pbOut->get()[i]));
+                    }
+                }
             }
         }
-
-        *_pOut = pB;
-        return 0;
     }
-
-    if (_pDouble1->isScalar())
+    else if (_pL->isScalar())
     {
-        Bool* pB = new Bool(_pDouble2->getDims(), _pDouble2->getDimsArray());
-        double dblRefR = _pDouble1->get(0);
+        pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        if (_pDouble2->isComplex())
+        if (pSPR[0]->getSize() == 1)
         {
-            double dblRefI = _pDouble1->getImg(0);
-            for (int i = 0 ; i < _pDouble2->getSize() ; i++)
+            if (_pL->isComplex())
             {
-                pB->set(i, (dblRefR == _pDouble2->get(i)) && (dblRefI == _pDouble2->getImg(i)));
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compequal((double)pSPR[0]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compequal((double)pSPR[0]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
+                    }
+                }
+
             }
         }
         else
         {
-            for (int i = 0 ; i < _pDouble2->getSize() ; i++)
-            {
-                pB->set(i, dblRefR == _pDouble2->get(i));
-            }
+            pbOut->setFalse();
         }
 
-        *_pOut = pB;
-        return 0;
     }
-
-
-    if (_pDouble1->getDims() != _pDouble2->getDims())
+    else
     {
-        *_pOut = new Bool(false);
-        return 0;
-    }
-
-    int* piDimsL = _pDouble1->getDimsArray();
-    int* piDimsR = _pDouble2->getDimsArray();
+        //check dimensions
+        if (_pL->getDims() != _pR->getDims())
+        {
+            return new Bool(false);
+        }
 
-    for (int i = 0 ; i < _pDouble1->getDims() ; i++)
-    {
-        if (piDimsL[i] != piDimsR[i])
+        for (int i = 0; i < _pL->getDims(); i++)
         {
-            *_pOut = new Bool(false);
-            return 0;
+            if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
+            {
+                return new Bool(false);
+            }
         }
-    }
 
-    Bool* pB = new Bool(_pDouble2->getDims(), _pDouble2->getDimsArray());
-    if (_pDouble1->isComplex())
-    {
-        for (int i = 0 ; i < _pDouble1->getSize() ; i++)
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (_pL->isComplex())
         {
-            pB->set(i, (_pDouble1->get(i) == _pDouble2->get(i)) && (_pDouble1->getImg(i) == _pDouble2->getImg(i)));
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
         }
-    }
-    else
-    {
-        for (int i = 0 ; i < _pDouble1->getSize() ; i++)
+        else
         {
-            pB->set(i, _pDouble1->get(i) == _pDouble2->get(i));
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, false);
+                    }
+                    else
+                    {
+                        compequal((double)pSPR[i]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
         }
     }
 
-    if (iFree == 1)
-    {
-        delete _pDouble1;
-    }
-    else if (iFree == 2)
-    {
-        delete _pDouble2;
-    }
+    return pbOut;
+}
 
-    *_pOut = pB;
-    return 0;
+template<class T, class U, class O>
+InternalType* compequal_M_P(T *_pL, U *_pR)
+{
+    return GenericComparisonEqual(_pR, _pL);
 }
 
-int EqualToSparseBoolAndSparseBool(SparseBool* _pSB1, SparseBool* _pSB2, GenericType** _pOut)
+template<>
+InternalType* compequal_M_M<String, String, Bool>(String* _pL, String* _pR)
 {
-    SparseBool* pOut = NULL;
-    if (_pSB1->isScalar())
+    if (_pL->getSize() == _pR->getSize())
     {
-        pOut = new SparseBool(_pSB2->getRows(), _pSB2->getCols());
-        bool bVal = _pSB1->get(0, 0);
+        //check dims
+        int iDimsL = _pL->getDims();
+        int iDimsR = _pR->getDims();
 
-        for (int i = 0 ; i < pOut->getRows() ; i++)
+        if (iDimsL != iDimsR)
         {
-            for (int j = 0 ; j < pOut->getCols() ; j++)
-            {
-                pOut->set(i, j, bVal == _pSB2->get(i, j));
-            }
+            return new Bool(false);
         }
 
-        pOut->finalize();
-        *_pOut = pOut;
-        return 0;
-    }
-
-    if (_pSB2->isScalar())
-    {
-        pOut = new SparseBool(_pSB1->getRows(), _pSB1->getCols());
-        bool bVal = _pSB2->get(0, 0);
+        int* piDimsL = _pL->getDimsArray();
+        int* piDimsR = _pR->getDimsArray();
 
-        for (int i = 0 ; i < pOut->getRows() ; i++)
+        for (int i = 0; i < iDimsL; ++i)
         {
-            for (int j = 0 ; j < pOut->getCols() ; j++)
+            if (piDimsL[i] != piDimsR[i])
             {
-                pOut->set(i, j, _pSB1->get(i, j) == bVal);
+                return new Bool(false);
             }
         }
+        Bool*  pOut = new Bool(iDimsL, piDimsL);
 
-        *_pOut = pOut;
-        pOut->finalize();
-        return 0;
+        for (int i = 0; i < _pL->getSize(); i++)
+        {
+            pOut->set(i, wcscmp(_pL->get(i), _pR->get(i)) == 0);
+        }
+        return pOut;
     }
-
-    if (_pSB1->getRows() != _pSB2->getRows() || _pSB1->getCols() != _pSB2->getCols())
+    else if (_pL->getSize() == 1)
     {
-        *_pOut = new Bool(false);
-        return 0;
+        Bool*  pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        for (int i = 0; i < _pR->getSize(); i++)
+        {
+            pOut->set(i, wcscmp(_pL->get(0), _pR->get(i)) == 0);
+        }
+        return pOut;
     }
-
-    pOut = new SparseBool(_pSB1->getRows(), _pSB1->getCols());
-
-    for (int i = 0 ; i < pOut->getRows() ; i++)
+    else if (_pR->getSize() == 1)
     {
-        for (int j = 0 ; j < pOut->getCols() ; j++)
+        Bool*  pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        for (int i = 0; i < _pL->getSize(); i++)
         {
-            pOut->set(i, j, _pSB1->get(i, j) == _pSB2->get(i, j));
+            pOut->set(i, wcscmp(_pL->get(i), _pR->get(0)) == 0);
         }
+        return pOut;
     }
 
-    pOut->finalize();
-    *_pOut = pOut;
-    return 0;
+    return NULL;
 }
 
-int EqualToSparseAndSparse(Sparse* _pSparse1, Sparse* _pSparse2, GenericType** _pOut)
+template<>
+types::InternalType* compequal_M_M<Struct, Struct, Bool>(types::Struct* _pL, types::Struct* _pR)
 {
-    if ((_pSparse1->getRows() == _pSparse2->getRows() && _pSparse1->getCols() == _pSparse2->getCols()) //matrix case
-            || _pSparse1->isScalar() || _pSparse2->isScalar()) //scalar cases
-    {
-        *_pOut = _pSparse1->newEqualTo(*_pSparse2);
-    }
-    else
+
+    if (_pL->getSize() != _pR->getSize())
     {
-        *_pOut = new Bool(false);
+        return new Bool(false);
     }
-    return 0;
-}
 
-int EqualToDoubleAndSparse(Double* _pDouble, Sparse* _pSparse, GenericType** _pOut)
-{
-    Sparse* pSparse = NULL;
-    if (_pDouble->isScalar())
+    String* pStringFielNamesPL = _pL->getFieldNames();
+    String* pStringFielNamesPR = _pR->getFieldNames();
+    wchar_t** ppwchPR = pStringFielNamesPR->get();
+    wchar_t** ppwchPL = pStringFielNamesPL->get();
+
+    Bool* pOut = new Bool(1, 2 * pStringFielNamesPL->getSize());
+    pOut->setTrue();
+    int* piPOut = pOut->get();
+
+    for (int iComptSStruct = 0; iComptSStruct < _pL->getSize(); iComptSStruct++)
     {
-        pSparse = new Sparse(_pSparse->getRows(), _pSparse->getCols(), _pDouble->isComplex());
-        if (pSparse->isComplex())
+        for (int i = 0; i < pStringFielNamesPL->getSize(); i++)
         {
-            std::complex<double> dbl(_pDouble->get(0), _pDouble->getImg(0));
-            for (int i = 0 ; i < pSparse->getRows() ; i++)
+            piPOut[i * 2] = (wcscmp(ppwchPR[i], ppwchPL[i]) == 0) && (piPOut[i * 2] == 1);
+
+
+            if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == _pR->get(iComptSStruct)->get(ppwchPR[i])->getType())
             {
-                for (int j = 0 ; j < pSparse->getCols() ; j++)
+                if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == types::InternalType::ScilabStruct)
                 {
-                    pSparse->set(i, j, dbl);
+                    piPOut[i * 2 + 1] = _pL->get(iComptSStruct)->get(ppwchPL[i]) == _pR->get(iComptSStruct)->get(ppwchPR[i]) && (piPOut[i * 2] == 1);
                 }
-            }
-        }
-        else
-        {
-            double dbl = _pDouble->get(0);
-            for (int i = 0 ; i < pSparse->getRows() ; i++)
-            {
-                for (int j = 0 ; j < pSparse->getCols() ; j++)
+                else
                 {
-                    pSparse->set(i, j, dbl);
+                    types::InternalType* pResolution = GenericComparisonEqual(_pL->get(iComptSStruct)->get(pStringFielNamesPL->get(i)), _pR->get(iComptSStruct)->get(pStringFielNamesPR->get(i)));
+                    bool bValeur = true;
+                    if (pResolution->getType() == types::InternalType::ScilabBool)
+                    {
+                        Bool* pBoolTempo = pResolution->getAs<Bool>();
+                        for (int j = 0; j < pBoolTempo->getSize() && bValeur == true; j++)
+                        {
+                            if (pBoolTempo->get(j) != 1)
+                            {
+                                bValeur = false;
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        SparseBool* pSparseBoolTempo = pResolution->getAs<SparseBool>();
+                        for (int j = 0; j < pSparseBoolTempo->getSize() && bValeur == true; j++)
+                        {
+                            if (pSparseBoolTempo->get(j) != 1)
+                            {
+                                bValeur = false;
+                                break;
+                            }
+                        }
+                    }
+                    piPOut[i * 2 + 1] = bValeur && (piPOut[i * 2 + 1] == 1);
                 }
             }
+            else
+            {
+                piPOut[i * 2 + 1] = false;
+            }
         }
     }
-    else
-    {
-        pSparse = new Sparse(*_pDouble);
-    }
 
-    int iRet = EqualToSparseAndSparse(pSparse, _pSparse, _pOut);
-    delete pSparse;
-    return iRet;
+    return pOut;
 }
 
-int EqualToSparseAndDouble(Sparse* _pSparse, Double* _pDouble, GenericType** _pOut)
+template<class T, class U, class O>
+InternalType* compequal_LT_LT(T *_pL, U *_pR)
 {
-    return EqualToDoubleAndSparse(_pDouble, _pSparse, _pOut);
-}
+    if ((_pL->getType() != _pR->getType()) && (_pL->getType() == GenericType::ScilabList || _pR->getType() == GenericType::ScilabList))
+    {
+        return NULL;
+    }
 
-int EqualToSparseBoolAndBool(SparseBool* _pSB1, Bool* _pB2, GenericType** _pOut)
-{
-    SparseBool* pSB = new SparseBool(*_pB2);
-    int iRet = EqualToSparseBoolAndSparseBool(_pSB1, pSB, _pOut);
-    delete pSB;
-    return iRet;
-}
+    if (_pL->getSize() != _pR->getSize())
+    {
+        return new Bool(false);
+    }
 
-int EqualToBoolAndSparseBool(Bool* _pB1, SparseBool* _pSB2, GenericType** _pOut)
-{
-    SparseBool* pSB = new SparseBool(*_pB1);
-    int iRet = EqualToSparseBoolAndSparseBool(pSB, _pSB2, _pOut);
-    delete pSB;
-    return iRet;
+    if (_pL->getSize() == 0 && _pR->getSize() == 0)
+    {
+        return new Bool(true);
+    }
+
+    Bool* pB = new Bool(1, _pL->getSize());
+    for (int i = 0; i < _pL->getSize(); i++)
+    {
+        pB->set(i, ((*_pL->get(i) == *_pR->get(i)) && (_pL->get(i)->getType() != types::InternalType::ScilabVoid)));
+    }
+
+    return pB;
 }
 
-template <class T>
-static int EqualToArrayAndArray(T* _pL, T* _pR, GenericType** _pOut)
+template<>
+types::InternalType* compequal_M_M<Cell, Cell, Bool>(types::Cell* _pL, types::Cell* _pR)
 {
-    if (_pL->isScalar())
+    /* check dimension*/
+    if (_pL->getDims() != _pR->getDims())
     {
-        Bool *pB = new Bool(_pR->getDims(), _pR->getDimsArray());
+        return new Bool(false);
+    }
 
-        int* pb = pB->get();
-        const typename T::type x = _pL->get(0);
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
 
-        for (int i = 0 ; i < pB->getSize() ; i++)
+    for (int i = 0; i < _pL->getDims(); i++)
+    {
+        if (piDimsL[i] != piDimsR[i])
         {
-            pb[i] = x == _pR->get(i);
+            return new Bool(false);
         }
-
-        *_pOut = pB;
-        return 0;
     }
 
-    if (_pR->isScalar())
+    if (_pL->getSize() == 0)
     {
-        Bool *pB = new Bool(_pL->getDims(), _pL->getDimsArray());
+        //{} == {} -> return true
+        return new Bool(true);
+    }
 
-        int* pb = pB->get();
-        const typename T::type x = _pL->get(0);
+    Bool *pB = new Bool(_pL->getDims(), piDimsL);
+    for (int i = 0; i < _pL->getSize(); i++)
+    {
+        pB->set(i, *_pL->get(i) == *_pR->get(i));
+    }
 
-        for (int i = 0 ; i < pB->getSize() ; i++)
-        {
-            pb[i] = x == _pL->get(i);
-        }
+    return pB;
+}
 
-        *_pOut = pB;
-        return 0;
-    }
+template<>
+types::InternalType* compequal_M_M<GraphicHandle, GraphicHandle, Bool>(GraphicHandle* _pL, GraphicHandle* _pR)
+{
 
+    /* check dimension*/
     if (_pL->getDims() != _pR->getDims())
     {
-        *_pOut = new Bool(false);
-        return 0;
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
     }
 
     int* piDimsL = _pL->getDimsArray();
     int* piDimsR = _pR->getDimsArray();
 
-    for (int i = 0 ; i < _pL->getDims() ; i++)
+    for (int i = 0; i < _pL->getDims(); i++)
     {
         if (piDimsL[i] != piDimsR[i])
         {
-            *_pOut = new Bool(false);
-            return 0;
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
         }
     }
 
-    Bool* pB = new Bool(_pR->getDims(), _pR->getDimsArray());
-    for (int i = 0 ; i < _pL->getSize() ; i++)
-    {
-        pB->set(i, _pL->get(i) == _pR->get(i));
-    }
+    Bool* pOut = new Bool(_pL->getDims(), piDimsL);
+    int iSize = pOut->getSize();
 
-    *_pOut = pB;
-    return 0;
+    compequal(_pL->get(), iSize, _pR->get(), pOut->get());
+    return pOut;
 }
 
-int EqualToIntAndInt(InternalType* _pL, InternalType*  _pR, GenericType** _pOut)
+template<class T, class U, class O>
+InternalType* compequal_MCR_MCR(T *_pL, U *_pR)
 {
-    switch (_pL->getType())
+    bool ret = false;
+    if (_pL->getType() == GenericType::ScilabMacroFile)
     {
-        case InternalType::ScilabInt8 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<Int8>(), _pR->getAs<Int8>(), _pOut);
-        }
-        case InternalType::ScilabUInt8 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<UInt8>(), _pR->getAs<UInt8>(), _pOut);
-        }
-        case InternalType::ScilabInt16 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<Int16>(), _pR->getAs<Int16>(), _pOut);
-        }
-        case InternalType::ScilabUInt16 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<UInt16>(), _pR->getAs<UInt16>(), _pOut);
-        }
-        case InternalType::ScilabInt32 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<Int32>(), _pR->getAs<Int32>(), _pOut);
-        }
-        case InternalType::ScilabUInt32 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<UInt32>(), _pR->getAs<UInt32>(), _pOut);
-        }
-        case InternalType::ScilabInt64 :
-        {
-            return EqualToArrayAndArray(_pL->getAs<Int64>(), _pR->getAs<Int64>(), _pOut);
-        }
-        case InternalType::ScilabUInt64 :
+        types::InternalType* pIT = ((InternalType *) _pL);
+        types::MacroFile* pL = pIT->getAs<types::MacroFile>();
+        ret = *pL == *_pR;
+    }
+    else if (_pL->getType() == GenericType::ScilabMacro)
+    {
+        types::InternalType* pIT = ((InternalType *) _pL);
+        types::Macro* pL = pIT->getAs<types::Macro>();
+        if (_pR->getType() == GenericType::ScilabMacroFile)
         {
-            return EqualToArrayAndArray(_pL->getAs<UInt64>(), _pR->getAs<UInt64>(), _pOut);
+            types::InternalType* pIT = ((InternalType *) _pR);
+            types::MacroFile* pR = pIT->getAs<types::MacroFile>();
+            ret = *pR == *pL;
         }
-        default:
+        else
         {
-            return 3;
+            ret = *pL == *_pR;
         }
     }
-}
-
-static void clearAlloc(bool _bAllocL, InternalType* _pIL, bool _bAllocR, InternalType* _pIR)
-{
-    if (_bAllocL)
-    {
-        delete _pIL;
-    }
 
-    if (_bAllocR)
-    {
-        delete _pIR;
-    }
+    return new Bool(ret);
 }
index 96aeb29..567ab7a 100644 (file)
 /*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011 - DIGITEO - Antoine ELIAS
- *
- *  This file must be used under the terms of the CeCILL.
- *  This source file is licensed as described in the file COPYING, which
- *  you should have received as part of this distribution.  The terms
- *  are also available at
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+*  Copyright (C) 2011 - DIGITEO - Antoine ELIAS
+*  Copyright (C) 2015 - Scilab Enterprises - Sylvain GENIN
+*
+*  This file must be used under the terms of the CeCILL.
+*  This source file is licensed as described in the file COPYING, which
+*  you should have received as part of this distribution.  The terms
+*  are also available at
+*  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include "types_comparison_ne.hxx"
-#include "types_comparison_eq.hxx"
 #include "bool.hxx"
+#include "double.hxx"
+#include "string.hxx"
+#include "polynom.hxx"
+#include "cell.hxx"
+#include "struct.hxx"
+#include "sparse.hxx"
+#include "int.hxx"
+#include "graphichandle.hxx"
 #include "mlist.hxx"
-#include "context.hxx"
+#include "macro.hxx"
+#include "macrofile.hxx"
 
 using namespace types;
 
+//define arrays on operation functions
+static compnoequal_function pComparisonEqualfunction[types::InternalType::IdLast][types::InternalType::IdLast] = { NULL };
+
+
+void fillComparisonNoEqualFunction()
+{
+#define scilab_fill_comparison_no_equal(id1, id2, func, typeIn1, typeIn2, typeOut) \
+    pComparisonEqualfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (compnoequal_function)&compnoequal_##func<typeIn1, typeIn2, typeOut>
+
+    //String != String
+    scilab_fill_comparison_no_equal(String, String, M_M, String, String, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarString, M_M, String, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarString, M_M, String, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, String, M_M, String, String, Bool);
+    //String != Empty
+    scilab_fill_comparison_no_equal(Empty, ScalarString, E_M, String, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Empty, M_E, String, String, Bool);
+    scilab_fill_comparison_no_equal(String, Empty, M_E, String, String, Bool);
+    scilab_fill_comparison_no_equal(Empty, String, E_M, String, String, Bool);
+    //String != Double
+    scilab_fill_comparison_no_equal(Double, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Double, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, Double, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, String, M_E, Double, String, Bool);
+    //String != ScalarDouble
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarDouble, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarDouble, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, String, M_E, Double, String, Bool);
+    //String != Int8
+    scilab_fill_comparison_no_equal(Int8, ScalarString, M_E, Int8, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Int8, M_E, String, Int8, Bool);
+    scilab_fill_comparison_no_equal(String, Int8, M_E, String, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int8, String, M_E, Int8, String, Bool);
+    //String != UInt8
+    scilab_fill_comparison_no_equal(UInt8, ScalarString, M_E, UInt8, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, UInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparison_no_equal(String, UInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, String, M_E, UInt8, String, Bool);
+    //String != Int16
+    scilab_fill_comparison_no_equal(Int16, ScalarString, M_E, Int16, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Int16, M_E, String, Int16, Bool);
+    scilab_fill_comparison_no_equal(String, Int16, M_E, String, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int16, String, M_E, Int16, String, Bool);
+    //String != UInt16
+    scilab_fill_comparison_no_equal(UInt16, ScalarString, M_E, UInt16, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, UInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparison_no_equal(String, UInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, String, M_E, UInt16, String, Bool);
+    //String != Int32
+    scilab_fill_comparison_no_equal(Int32, ScalarString, M_E, Int32, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Int32, M_E, String, Int32, Bool);
+    scilab_fill_comparison_no_equal(String, Int32, M_E, String, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int32, String, M_E, Int32, String, Bool);
+    //String != UInt32
+    scilab_fill_comparison_no_equal(UInt32, ScalarString, M_E, UInt32, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, UInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparison_no_equal(String, UInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, String, M_E, UInt32, String, Bool);
+    //String != Int64
+    scilab_fill_comparison_no_equal(Int64, ScalarString, M_E, Int64, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Int64, M_E, String, Int64, Bool);
+    scilab_fill_comparison_no_equal(String, Int64, M_E, String, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int64, String, M_E, Int64, String, Bool);
+    //String != UInt64
+    scilab_fill_comparison_no_equal(UInt64, ScalarString, M_E, UInt64, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, UInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparison_no_equal(String, UInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, String, M_E, UInt64, String, Bool);
+    //String != Bool
+    scilab_fill_comparison_no_equal(Bool, ScalarString, M_E, Bool, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Bool, M_E, String, Bool, Bool);
+    scilab_fill_comparison_no_equal(String, Bool, M_E, String, Bool, Bool);
+    scilab_fill_comparison_no_equal(Bool, String, M_E, Bool, String, Bool);
+    //String != Polynom
+    scilab_fill_comparison_no_equal(Polynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Polynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, Polynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Polynom, String, M_E, Polynom, String, Bool);
+    //String != PolynomComplex
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, PolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, PolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, String, M_E, Polynom, String, Bool);
+    //String != ScalarPolynom
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, String, M_E, Polynom, String, Bool);
+    //String != ScalarPolynomComplex
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
+    //String != Sparse
+    scilab_fill_comparison_no_equal(Sparse, ScalarString, M_E, Sparse, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Sparse, M_E, String, Sparse, Bool);
+    scilab_fill_comparison_no_equal(String, Sparse, M_E, String, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Sparse, String, M_E, Sparse, String, Bool);
+    //String != SparseBool
+    scilab_fill_comparison_no_equal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(String, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, String, M_E, SparseBool, String, Bool);
+    //String != ScalarInt8
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarString, M_E, Int8, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarInt8, M_E, String, Int8, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarInt8, M_E, String, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, String, M_E, Int8, String, Bool);
+    //String != ScalarUInt8
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarString, M_E, UInt8, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarUInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarUInt8, M_E, String, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, String, M_E, UInt8, String, Bool);
+    //String != ScalarInt16
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarString, M_E, Int16, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarInt16, M_E, String, Int16, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarInt16, M_E, String, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, String, M_E, Int16, String, Bool);
+    //String != ScalarUInt16
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarString, M_E, UInt16, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarUInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarUInt16, M_E, String, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, String, M_E, UInt16, String, Bool);
+    //String != ScalarInt32
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarString, M_E, Int32, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarInt32, M_E, String, Int32, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarInt32, M_E, String, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, String, M_E, Int32, String, Bool);
+    //String != ScalarUInt32
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarString, M_E, UInt32, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarUInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarUInt32, M_E, String, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, String, M_E, UInt32, String, Bool);
+    //String != ScalarInt64
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarString, M_E, Int64, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarInt64, M_E, String, Int64, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarInt64, M_E, String, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, String, M_E, Int64, String, Bool);
+    //String != ScalarUInt64
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarString, M_E, UInt64, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarUInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarUInt64, M_E, String, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, String, M_E, UInt64, String, Bool);
+    //String != ScalarBool
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarString, M_E, Bool, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarBool, M_E, String, Bool, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarBool, M_E, String, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, String, M_E, Bool, String, Bool);
+    //String != ScalarPolynom
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarPolynom, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, String, M_E, Polynom, String, Bool);
+    //String != ScalarDoubleComplex
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarDoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarDoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, String, M_E, Double, String, Bool);
+    //String != DoubleComplex
+    scilab_fill_comparison_no_equal(DoubleComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, DoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, DoubleComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, String, M_E, Double, String, Bool);
+    //String != ScalarPolynomComplex
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarString, M_E, Polynom, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(String, ScalarPolynomComplex, M_E, String, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, String, M_E, Polynom, String, Bool);
+    //String != SparseComplex
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarString, M_E, Sparse, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, SparseComplex, M_E, String, Sparse, Bool);
+    scilab_fill_comparison_no_equal(String, SparseComplex, M_E, String, Sparse, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, String, M_E, Sparse, String, Bool);
+    //String != Identity
+    scilab_fill_comparison_no_equal(Identity, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Identity, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, Identity, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, String, M_E, Double, String, Bool);
+    //String != IdentityComplex
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarString, M_E, Double, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, IdentityComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(String, IdentityComplex, M_E, String, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, String, M_E, Double, String, Bool);
+
+    //Double
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Double, Double, M_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, Int8, M_M, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(Double, UInt8, M_M, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Double, Int16, M_M, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(Double, UInt16, M_M, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Double, Int32, M_M, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(Double, UInt32, M_M, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Double, Int64, M_M, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(Double, UInt64, M_M, Double, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Double, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(Double, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Double, Sparse, M_SP, Double, Sparse, SparseBool);
+
+    //Matrix != Matrix Complex
+    scilab_fill_comparison_no_equal(Double, DoubleComplex, M_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Double, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Double, ScalarDouble, M_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarInt8, M_S, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarUInt8, M_S, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarInt16, M_S, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarUInt16, M_S, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarInt32, M_S, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarUInt32, M_S, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarInt64, M_S, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarUInt64, M_S, Double, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarPolynom, M_P, Double, Polynom, Bool);
+
+    //Matrix != Scalar Complex
+    scilab_fill_comparison_no_equal(Double, ScalarDoubleComplex, M_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+
+    //Matrix != Empty
+    scilab_fill_comparison_no_equal(Double, Empty, M_E, Double, Double, Bool);
+
+
+    //Matrix Complex != Matrix
+    scilab_fill_comparison_no_equal(DoubleComplex, Double, MC_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, ScalarDouble, MC_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, Empty, M_E, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(DoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarDouble, Double, S_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Int8, S_M, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, UInt8, S_M, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Int16, S_M, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, UInt16, S_M, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Int32, S_M, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, UInt32, S_M, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Int64, S_M, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, UInt64, S_M, Double, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Sparse, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar != Matrix Complex
+    scilab_fill_comparison_no_equal(ScalarDouble, DoubleComplex, S_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, SparseComplex, M_SP, Double, Sparse, SparseBool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarDouble, S_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarInt8, S_S, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarInt16, S_S, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarInt32, S_S, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarInt64, S_S, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarPolynom, M_P, Double, Polynom, Bool);
+
+    //Scalar != Scalar Complex
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+
+    //Scalar != Empty
+    scilab_fill_comparison_no_equal(ScalarDouble, Empty, M_E, Double, Double, Bool);
+
+    //Scalar Complex != Matrix
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Double, SC_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Sparse, M_SP, Double, Sparse, SparseBool);
+    //Scalar Complex != Matrix Complex
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, SparseComplex, M_SP, Double, Sparse, SparseBool);
+    //Scalar Complex != Scalar
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    //Scalar Complex != Scalar Complex
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    //Scalar Complex != Empty
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Empty, M_E, Double, Double, Bool);
+
+    //Empty != Matrix
+    scilab_fill_comparison_no_equal(Empty, Double, E_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, Int8, E_M, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(Empty, UInt8, E_M, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Empty, Int16, E_M, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(Empty, UInt16, E_M, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Empty, Int32, E_M, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(Empty, UInt32, E_M, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Empty, Int64, E_M, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(Empty, UInt64, E_M, Double, UInt64, Bool);
+
+    scilab_fill_comparison_no_equal(Empty, Polynom, E_M, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Empty, PolynomComplex, E_M, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Empty, Sparse, E_M, Double, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Empty, SparseComplex, E_M, Double, Sparse, Bool);
+
+    //Empty != Matrix Complex
+    scilab_fill_comparison_no_equal(Empty, DoubleComplex, E_M, Double, Double, Bool);
+    //Empty != Scalar
+    scilab_fill_comparison_no_equal(Empty, ScalarDouble, E_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarInt8, E_M, Double, Int8, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarUInt8, E_M, Double, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarInt16, E_M, Double, Int16, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarUInt16, E_M, Double, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarInt32, E_M, Double, Int32, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarUInt32, E_M, Double, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarInt64, E_M, Double, Int64, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarUInt64, E_M, Double, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarBool, E_M, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarPolynom, E_M, Double, Polynom, Bool);
+
+    //Empty != Scalar Complex
+    scilab_fill_comparison_no_equal(Empty, ScalarDoubleComplex, E_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Bool);
+    //Empty != Empty
+    scilab_fill_comparison_no_equal(Empty, Empty, E_E, Double, Double, Bool);
+    //Empty != eye
+    scilab_fill_comparison_no_equal(Empty, Identity, E_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, IdentityComplex, E_M, Double, Double, Bool);
+
+    //Matrix != Identity
+    scilab_fill_comparison_no_equal(Double, Identity, M_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, IdentityComplex, M_IC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, Identity, MC_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Identity, S_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, IdentityComplex, S_IC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Identity, SC_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Bool);
+
+    //Int8
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Int8, Double, M_M, Int8, Double, Bool);
+    scilab_fill_comparison_no_equal(Int8, Int8, M_M, Int8, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int8, UInt8, M_M, Int8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int8, Int16, M_M, Int8, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int8, UInt16, M_M, Int8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int8, Int32, M_M, Int8, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int8, UInt32, M_M, Int8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int8, Int64, M_M, Int8, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int8, UInt64, M_M, Int8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int8, Bool, M_B, Int8, Bool, Bool);
+    scilab_fill_comparison_no_equal(Int8, Empty, M_E, Int8, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Int8, ScalarDouble, M_S, Int8, Double, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarInt8, M_S, Int8, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarUInt8, M_S, Int8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarInt16, M_S, Int8, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarUInt16, M_S, Int8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarInt32, M_S, Int8, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarUInt32, M_S, Int8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarInt64, M_S, Int8, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarUInt64, M_S, Int8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarBool, M_B, Int8, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarInt8, Double, S_M, Int8, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Int8, S_M, Int8, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, UInt8, S_M, Int8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Int16, S_M, Int8, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, UInt16, S_M, Int8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Int32, S_M, Int8, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, UInt32, S_M, Int8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Int64, S_M, Int8, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, UInt64, S_M, Int8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Bool, S_B, Int8, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Empty, M_E, Int8, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarDouble, S_S, Int8, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarBool, M_E, Int8, Bool, Bool);
+
+    //UInt8
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(UInt8, Double, M_M, UInt8, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Int8, M_M, UInt8, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, UInt8, M_M, UInt8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Int16, M_M, UInt8, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt8, UInt16, M_M, UInt8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Int32, M_M, UInt8, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt8, UInt32, M_M, UInt8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Int64, M_M, UInt8, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt8, UInt64, M_M, UInt8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Bool, M_B, UInt8, Bool, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Empty, M_E, UInt8, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(UInt8, ScalarDouble, M_S, UInt8, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarInt8, M_S, UInt8, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarUInt8, M_S, UInt8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarInt16, M_S, UInt8, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarUInt16, M_S, UInt8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarInt32, M_S, UInt8, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarUInt32, M_S, UInt8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarInt64, M_S, UInt8, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarUInt64, M_S, UInt8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarBool, M_B, UInt8, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarUInt8, Double, S_M, UInt8, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Int8, S_M, UInt8, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, UInt8, S_M, UInt8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Int16, S_M, UInt8, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, UInt16, S_M, UInt8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Int32, S_M, UInt8, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, UInt32, S_M, UInt8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Int64, S_M, UInt8, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, UInt64, S_M, UInt8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Bool, S_B, UInt8, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Empty, M_E, UInt8, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarBool, M_E, UInt8, Bool, Bool);
+
+    //Int16
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Int16, Double, M_M, Int16, Double, Bool);
+    scilab_fill_comparison_no_equal(Int16, Int8, M_M, Int16, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int16, UInt8, M_M, Int16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int16, Int16, M_M, Int16, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int16, UInt16, M_M, Int16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int16, Int32, M_M, Int16, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int16, UInt32, M_M, Int16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int16, Int64, M_M, Int16, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int16, UInt64, M_M, Int16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int16, Bool, M_B, Int16, Bool, Bool);
+    scilab_fill_comparison_no_equal(Int16, Empty, M_E, Int16, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Int16, ScalarDouble, M_S, Int16, Double, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarInt8, M_S, Int16, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarUInt8, M_S, Int16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarInt16, M_S, Int16, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarUInt16, M_S, Int16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarInt32, M_S, Int16, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarUInt32, M_S, Int16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarInt64, M_S, Int16, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarUInt64, M_S, Int16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarBool, M_B, Int16, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarInt16, Double, S_M, Int16, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Int8, S_M, Int16, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, UInt8, S_M, Int16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Int16, S_M, Int16, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, UInt16, S_M, Int16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Int32, S_M, Int16, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, UInt32, S_M, Int16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Int64, S_M, Int16, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, UInt64, S_M, Int16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Bool, S_B, Int16, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Empty, M_E, Int16, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarDouble, S_S, Int16, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarBool, M_E, Int16, Bool, Bool);
+
+    //UInt16
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(UInt16, Double, M_M, UInt16, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Int8, M_M, UInt16, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt16, UInt8, M_M, UInt16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Int16, M_M, UInt16, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, UInt16, M_M, UInt16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Int32, M_M, UInt16, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt16, UInt32, M_M, UInt16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Int64, M_M, UInt16, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt16, UInt64, M_M, UInt16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Bool, M_B, UInt16, Bool, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Empty, M_E, UInt16, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(UInt16, ScalarDouble, M_S, UInt16, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarInt8, M_S, UInt16, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarUInt8, M_S, UInt16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarInt16, M_S, UInt16, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarUInt16, M_S, UInt16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarInt32, M_S, UInt16, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarUInt32, M_S, UInt16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarInt64, M_S, UInt16, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarUInt64, M_S, UInt16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarBool, M_B, UInt16, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarUInt16, Double, S_M, UInt16, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Int8, S_M, UInt16, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, UInt8, S_M, UInt16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Int16, S_M, UInt16, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, UInt16, S_M, UInt16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Int32, S_M, UInt16, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, UInt32, S_M, UInt16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Int64, S_M, UInt16, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, UInt64, S_M, UInt16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Bool, S_B, UInt16, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Empty, M_E, UInt16, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarBool, M_E, UInt16, Bool, Bool);
+
+    //Int32
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Int32, Double, M_M, Int32, Double, Bool);
+    scilab_fill_comparison_no_equal(Int32, Int8, M_M, Int32, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int32, UInt8, M_M, Int32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int32, Int16, M_M, Int32, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int32, UInt16, M_M, Int32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int32, Int32, M_M, Int32, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int32, UInt32, M_M, Int32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int32, Int64, M_M, Int32, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int32, UInt64, M_M, Int32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int32, Bool, M_B, Int32, Bool, Bool);
+    scilab_fill_comparison_no_equal(Int32, Empty, M_E, Int32, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Int32, ScalarDouble, M_S, Int32, Double, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarInt8, M_S, Int32, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarUInt8, M_S, Int32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarInt16, M_S, Int32, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarUInt16, M_S, Int32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarInt32, M_S, Int32, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarUInt32, M_S, Int32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarInt64, M_S, Int32, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarUInt64, M_S, Int32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarBool, M_B, Int32, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarInt32, Double, S_M, Int32, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Int8, S_M, Int32, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, UInt8, S_M, Int32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Int16, S_M, Int32, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, UInt16, S_M, Int32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Int32, S_M, Int32, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, UInt32, S_M, Int32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Int64, S_M, Int32, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, UInt64, S_M, Int32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Bool, S_B, Int32, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Empty, M_E, Int32, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarDouble, S_S, Int32, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarBool, M_E, Int32, Bool, Bool);
+
+    //UInt32
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(UInt32, Double, M_M, UInt32, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Int8, M_M, UInt32, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt32, UInt8, M_M, UInt32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Int16, M_M, UInt32, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt32, UInt16, M_M, UInt32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Int32, M_M, UInt32, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, UInt32, M_M, UInt32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Int64, M_M, UInt32, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt32, UInt64, M_M, UInt32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Bool, M_B, UInt32, Bool, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Empty, M_E, UInt32, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(UInt32, ScalarDouble, M_S, UInt32, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarInt8, M_S, UInt32, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarUInt8, M_S, UInt32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarInt16, M_S, UInt32, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarUInt16, M_S, UInt32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarInt32, M_S, UInt32, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarUInt32, M_S, UInt32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarInt64, M_S, UInt32, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarUInt64, M_S, UInt32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarBool, M_B, UInt32, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarUInt32, Double, S_M, UInt32, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Int8, S_M, UInt32, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, UInt8, S_M, UInt32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Int16, S_M, UInt32, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, UInt16, S_M, UInt32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Int32, S_M, UInt32, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, UInt32, S_M, UInt32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Int64, S_M, UInt32, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, UInt64, S_M, UInt32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Bool, S_B, UInt32, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Empty, M_E, UInt32, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarBool, M_E, UInt32, Bool, Bool);
+
+    //Int64
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Int64, Double, M_M, Int64, Double, Bool);
+    scilab_fill_comparison_no_equal(Int64, Int8, M_M, Int64, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int64, UInt8, M_M, Int64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int64, Int16, M_M, Int64, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int64, UInt16, M_M, Int64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int64, Int32, M_M, Int64, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int64, UInt32, M_M, Int64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int64, Int64, M_M, Int64, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int64, UInt64, M_M, Int64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int64, Bool, M_B, Int64, Bool, Bool);
+    scilab_fill_comparison_no_equal(Int64, Empty, M_E, Int64, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Int64, ScalarDouble, M_S, Int64, Double, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarInt8, M_S, Int64, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarUInt8, M_S, Int64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarInt16, M_S, Int64, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarUInt16, M_S, Int64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarInt32, M_S, Int64, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarUInt32, M_S, Int64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarInt64, M_S, Int64, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarUInt64, M_S, Int64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarBool, M_B, Int64, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarInt64, Double, S_M, Int64, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Int8, S_M, Int64, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, UInt8, S_M, Int64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Int16, S_M, Int64, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, UInt16, S_M, Int64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Int32, S_M, Int64, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, UInt32, S_M, Int64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Int64, S_M, Int64, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, UInt64, S_M, Int64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Bool, S_B, Int64, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Empty, M_E, Int64, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarDouble, S_S, Int64, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarBool, M_E, Int64, Bool, Bool);
+
+    //UInt64
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(UInt64, Double, M_M, UInt64, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Int8, M_M, UInt64, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt64, UInt8, M_M, UInt64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Int16, M_M, UInt64, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt64, UInt16, M_M, UInt64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Int32, M_M, UInt64, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt64, UInt32, M_M, UInt64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Int64, M_M, UInt64, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, UInt64, M_M, UInt64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Bool, M_B, UInt64, Bool, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Empty, M_E, UInt64, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(UInt64, ScalarDouble, M_S, UInt64, Double, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarInt8, M_S, UInt64, Int8, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarUInt8, M_S, UInt64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarInt16, M_S, UInt64, Int16, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarUInt16, M_S, UInt64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarInt32, M_S, UInt64, Int32, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarUInt32, M_S, UInt64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarInt64, M_S, UInt64, Int64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarUInt64, M_S, UInt64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarBool, M_B, UInt64, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarUInt64, Double, S_M, UInt64, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Int8, S_M, UInt64, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, UInt8, S_M, UInt64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Int16, S_M, UInt64, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, UInt16, S_M, UInt64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Int32, S_M, UInt64, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, UInt32, S_M, UInt64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Int64, S_M, UInt64, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, UInt64, S_M, UInt64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Bool, S_B, UInt64, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Empty, M_E, UInt64, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarBool, M_E, UInt64, Bool, Bool);
+
+    //Bool
+    //Matrix != Matrix
+    scilab_fill_comparison_no_equal(Bool, Double, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(Bool, Int8, B_M, Bool, Int8, Bool);
+    scilab_fill_comparison_no_equal(Bool, UInt8, B_M, Bool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Bool, Int16, B_M, Bool, Int16, Bool);
+    scilab_fill_comparison_no_equal(Bool, UInt16, B_M, Bool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Bool, Int32, B_M, Bool, Int32, Bool);
+    scilab_fill_comparison_no_equal(Bool, UInt32, B_M, Bool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Bool, Int64, B_M, Bool, Int64, Bool);
+    scilab_fill_comparison_no_equal(Bool, UInt64, B_M, Bool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Bool, Bool, M_M, Bool, Bool, Bool);
+    scilab_fill_comparison_no_equal(Bool, Empty, M_E, Bool, Double, Bool);
+
+    //Matrix != Scalar
+    scilab_fill_comparison_no_equal(Bool, ScalarDouble, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarInt8, B_S, Bool, Int8, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarUInt8, B_S, Bool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarInt16, B_S, Bool, Int16, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarUInt16, B_S, Bool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarInt32, B_S, Bool, Int32, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarUInt32, B_S, Bool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarInt64, B_S, Bool, Int64, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarUInt64, B_S, Bool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarBool, M_S, Bool, Bool, Bool);
+
+    //Scalar != Matrix
+    scilab_fill_comparison_no_equal(ScalarBool, Double, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Int8, B_M, Bool, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, UInt8, B_M, Bool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Int16, B_M, Bool, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, UInt16, B_M, Bool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Int32, B_M, Bool, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, UInt32, B_M, Bool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Int64, B_M, Bool, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, UInt64, B_M, Bool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Bool, S_M, Bool, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Empty, M_E, Bool, Double, Bool);
+
+    //Scalar != Scalar
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarDouble, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarInt8, M_E, Bool, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarUInt8, M_E, Bool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarInt16, M_E, Bool, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarUInt16, M_E, Bool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarInt32, M_E, Bool, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarUInt32, M_E, Bool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarInt64, M_E, Bool, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarUInt64, M_E, Bool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
+
+    //Bool != Identity
+    scilab_fill_comparison_no_equal(Bool, Identity, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(Bool, IdentityComplex, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Identity, M_E, Bool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, IdentityComplex, M_E, Bool, Double, Bool);
+
+    //Bool != Polynom
+    scilab_fill_comparison_no_equal(Bool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+
+    //Bool != Sparse
+    scilab_fill_comparison_no_equal(Bool, Sparse, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Bool, SparseComplex, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, Sparse, M_E, Bool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(ScalarBool, SparseComplex, M_E, Bool, Sparse, Bool);
+
+    //Identity
+    scilab_fill_comparison_no_equal(Identity, Double, I_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, DoubleComplex, I_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, ScalarDouble, I_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, ScalarDoubleComplex, I_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, Identity, I_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, IdentityComplex, I_IC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, Empty, M_E, Double, Double, Bool);
+
+    scilab_fill_comparison_no_equal(Identity, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Identity, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Identity, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Identity, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Identity, Sparse, M_E, Double, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(Identity, SparseComplex, M_E, Double, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(IdentityComplex, Double, IC_M, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarDouble, IC_S, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, Identity, IC_I, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, Empty, M_E, Double, Double, Bool);
+
+    scilab_fill_comparison_no_equal(IdentityComplex, Polynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, PolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarPolynom, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarPolynomComplex, M_P, Double, Polynom, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, Sparse, M_E, Double, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(IdentityComplex, SparseComplex, M_E, Double, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Identity, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, Bool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(Identity, ScalarBool, M_E, Double, Bool, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, ScalarBool, M_E, Double, Bool, Bool);
+
+    //Polynom
+
+    //poly != poly
+    scilab_fill_comparison_no_equal(Polynom, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Polynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //poly != scalar poly
+    scilab_fill_comparison_no_equal(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //poly != double
+    scilab_fill_comparison_no_equal(Polynom, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(Polynom, DoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly != scalar double
+    scilab_fill_comparison_no_equal(Polynom, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly != Bool
+    scilab_fill_comparison_no_equal(Polynom, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarBool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
+
+    //poly != []
+    scilab_fill_comparison_no_equal(Polynom, Empty, M_E, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Empty, M_E, Polynom, Double, Bool);
+
+    //poly != eye
+    scilab_fill_comparison_no_equal(Polynom, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(Polynom, IdentityComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
+
+    //scalar poly != poly
+    scilab_fill_comparison_no_equal(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //scalar poly != scalar poly
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Bool);
+
+    //scalar poly != double
+    scilab_fill_comparison_no_equal(ScalarPolynom, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, DoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Double, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, DoubleComplex, P_M, Polynom, Double, Bool);
+
+    //scalar poly != scalar double
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarDouble, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarDoubleComplex, P_M, Polynom, Double, Bool);
+
+    //poly != Bool
+    scilab_fill_comparison_no_equal(ScalarPolynom, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarBool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Bool, E_M, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarBool, E_M, Polynom, Bool, Bool);
+
+    //scalar poly != []
+    scilab_fill_comparison_no_equal(ScalarPolynom, Empty, M_E, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Bool);
+
+    //scalar poly != eye
+    scilab_fill_comparison_no_equal(ScalarPolynom, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, IdentityComplex, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Identity, P_M, Polynom, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, IdentityComplex, P_M, Polynom, Double, Bool);
+
+    //poly != Int8
+    scilab_fill_comparison_no_equal(Polynom, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(Polynom, UInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparison_no_equal(Int8, Polynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Polynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int8, PolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, UInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Int8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, UInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparison_no_equal(Int8, ScalarPolynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    //poly != Int16
+    scilab_fill_comparison_no_equal(Polynom, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(Polynom, UInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparison_no_equal(Int16, Polynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Polynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int16, PolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, UInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Int16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, UInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparison_no_equal(Int16, ScalarPolynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    //poly != Int32
+    scilab_fill_comparison_no_equal(Polynom, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(Polynom, UInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparison_no_equal(Int32, Polynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Polynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int32, PolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, UInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Int32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, UInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparison_no_equal(Int32, ScalarPolynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    //poly != Int64
+    scilab_fill_comparison_no_equal(Polynom, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(Polynom, UInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparison_no_equal(Int64, Polynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Polynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int64, PolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, UInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Int64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, UInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparison_no_equal(Int64, ScalarPolynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Int64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(UInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    //poly != Int8
+    scilab_fill_comparison_no_equal(Polynom, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt8, Polynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Polynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, PolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, PolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarInt8, P_M, Polynom, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarUInt8, P_M, Polynom, UInt8, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarPolynom, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarPolynom, M_P, UInt8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, ScalarPolynomComplex, M_P, Int8, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, ScalarPolynomComplex, M_P, UInt8, Polynom, Bool);
+
+    //poly != Int16
+    scilab_fill_comparison_no_equal(Polynom, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt16, Polynom, M_P, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Polynom, M_P, Polynom, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, PolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, PolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarInt16, P_M, Polynom, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarUInt16, P_M, Polynom, UInt16, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarPolynom, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarPolynom, M_P, UInt16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, ScalarPolynomComplex, M_P, Int16, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, ScalarPolynomComplex, M_P, UInt16, Polynom, Bool);
+
+    //poly != Int32
+    scilab_fill_comparison_no_equal(Polynom, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt32, Polynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Polynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, PolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, PolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarInt32, P_M, Polynom, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarUInt32, P_M, Polynom, UInt32, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarPolynom, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarPolynom, M_P, UInt32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, ScalarPolynomComplex, M_P, Int32, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, ScalarPolynomComplex, M_P, UInt32, Polynom, Bool);
+
+    //poly != Int64
+    scilab_fill_comparison_no_equal(Polynom, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(Polynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt64, Polynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Polynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, PolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, PolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarInt64, P_M, Polynom, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, ScalarUInt64, P_M, Polynom, UInt64, Bool);
+
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarPolynom, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarPolynom, M_P, UInt64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, ScalarPolynomComplex, M_P, Int64, Polynom, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, ScalarPolynomComplex, M_P, UInt64, Polynom, Bool);
+
+    //poly != bool
+    scilab_fill_comparison_no_equal(Polynom, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(PolynomComplex, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynom, Bool, M_E, Polynom, Bool, Bool);
+    scilab_fill_comparison_no_equal(ScalarPolynomComplex, Bool, M_E, Polynom, Bool, Bool);
+
+    scilab_fill_comparison_no_equal(Bool, Polynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, PolynomComplex, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarPolynom, M_E, Bool, Polynom, Bool);
+    scilab_fill_comparison_no_equal(Bool, ScalarPolynomComplex, M_E, Bool, Polynom, Bool);
+
+    //Sparse
+    scilab_fill_comparison_no_equal(Sparse, Sparse, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, SparseComplex, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, Double, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, DoubleComplex, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, ScalarDouble, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, Empty, M_E, Sparse, Double, Bool);
+    scilab_fill_comparison_no_equal(Sparse, Identity, M_E, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(Sparse, IdentityComplex, M_E, Sparse, Double, SparseBool);
+
+    scilab_fill_comparison_no_equal(SparseComplex, Sparse, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, SparseComplex, M_M, Sparse, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, Double, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, DoubleComplex, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarDouble, SP_M, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarDoubleComplex, SP_M, Sparse, Double, SparseBool);
+
+    scilab_fill_comparison_no_equal(SparseComplex, Empty, M_E, Sparse, Double, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, Identity, M_E, Sparse, Double, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, IdentityComplex, M_E, Sparse, Double, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, Bool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparison_no_equal(Sparse, ScalarBool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, Bool, M_E, Sparse, Bool, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarBool, M_E, Sparse, Bool, Bool);
+
+    scilab_fill_comparison_no_equal(Sparse, Int8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparison_no_equal(Int8, Sparse, M_SP, Int8, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, Int8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparison_no_equal(Int8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, UInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparison_no_equal(UInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, UInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparison_no_equal(UInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, Int16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparison_no_equal(Int16, Sparse, M_SP, Int16, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, Int16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparison_no_equal(Int16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, UInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparison_no_equal(UInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, UInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparison_no_equal(UInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, Int32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparison_no_equal(Int32, Sparse, M_SP, Int32, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, Int32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparison_no_equal(Int32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, UInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparison_no_equal(UInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, UInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparison_no_equal(UInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, Int64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparison_no_equal(Int64, Sparse, M_SP, Int64, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, Int64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparison_no_equal(Int64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, UInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparison_no_equal(UInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, UInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparison_no_equal(UInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Sparse, M_SP, Int8, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarInt8, SP_M, Sparse, Int8, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt8, SparseComplex, M_SP, Int8, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Sparse, M_SP, UInt8, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarUInt8, SP_M, Sparse, UInt8, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, SparseComplex, M_SP, UInt8, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Sparse, M_SP, Int16, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarInt16, SP_M, Sparse, Int16, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt16, SparseComplex, M_SP, Int16, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Sparse, M_SP, UInt16, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarUInt16, SP_M, Sparse, UInt16, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, SparseComplex, M_SP, UInt16, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Sparse, M_SP, Int32, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarInt32, SP_M, Sparse, Int32, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt32, SparseComplex, M_SP, Int32, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Sparse, M_SP, UInt32, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarUInt32, SP_M, Sparse, UInt32, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, SparseComplex, M_SP, UInt32, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Sparse, M_SP, Int64, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarInt64, SP_M, Sparse, Int64, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarInt64, SparseComplex, M_SP, Int64, Sparse, SparseBool);
+
+    scilab_fill_comparison_no_equal(Sparse, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Sparse, M_SP, UInt64, Sparse, SparseBool);
+    scilab_fill_comparison_no_equal(SparseComplex, ScalarUInt64, SP_M, Sparse, UInt64, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, SparseComplex, M_SP, UInt64, Sparse, SparseBool);
+
+
+    //SparseBool
+    scilab_fill_comparison_no_equal(SparseBool, SparseBool, M_M, SparseBool, SparseBool, SparseBool);
+    scilab_fill_comparison_no_equal(SparseBool, Bool, M_M, SparseBool, Bool, SparseBool);
+    scilab_fill_comparison_no_equal(Bool, SparseBool, M_M, Bool, SparseBool, SparseBool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarBool, M_M, SparseBool, Bool, SparseBool);
+    scilab_fill_comparison_no_equal(ScalarBool, SparseBool, M_M, Bool, SparseBool, SparseBool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Double, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, DoubleComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, ScalarDouble, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarDoubleComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Empty, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, Identity, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, SparseBool, M_E, Double, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, IdentityComplex, M_E, SparseBool, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, SparseBool, M_E, Double, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Int8, M_E, SparseBool, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int8, SparseBool, M_E, Int8, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, UInt8, M_E, SparseBool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Int16, M_E, SparseBool, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int16, SparseBool, M_E, Int16, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, UInt16, M_E, SparseBool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Int32, M_E, SparseBool, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int32, SparseBool, M_E, Int32, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, UInt32, M_E, SparseBool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Int64, M_E, SparseBool, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int64, SparseBool, M_E, Int64, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, UInt64, M_E, SparseBool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, ScalarInt8, M_E, SparseBool, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, SparseBool, M_E, Int8, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarUInt8, M_E, SparseBool, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, SparseBool, M_E, UInt8, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, ScalarInt16, M_E, SparseBool, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, SparseBool, M_E, Int16, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarUInt16, M_E, SparseBool, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, SparseBool, M_E, UInt16, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, ScalarInt32, M_E, SparseBool, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, SparseBool, M_E, Int32, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarUInt32, M_E, SparseBool, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, SparseBool, M_E, UInt32, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, ScalarInt64, M_E, SparseBool, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, SparseBool, M_E, Int64, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarUInt64, M_E, SparseBool, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, SparseBool, M_E, UInt64, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, String, M_E, SparseBool, String, Bool);
+    scilab_fill_comparison_no_equal(String, SparseBool, M_E, String, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, ScalarString, M_E, SparseBool, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, SparseBool, M_E, String, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, SparseComplex, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    scilab_fill_comparison_no_equal(SparseBool, Sparse, M_E, SparseBool, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Sparse, SparseBool, M_E, Sparse, SparseBool, Bool);
+
+    //struct
+    scilab_fill_comparison_no_equal(Struct, Struct, M_M, Struct, Struct, Bool);
+
+    /*scilab_fill_comparison_no_equal(Struct, Double, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(Double, Struct, M_E, Double, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, DoubleComplex, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(DoubleComplex, Struct, M_E, Double, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, ScalarDouble, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDouble, Struct, M_E, Double, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarDoubleComplex, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(ScalarDoubleComplex, Struct, M_E, Double, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Empty, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(Empty, Struct, M_E, Double, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, Identity, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(Identity, Struct, M_E, Double, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, IdentityComplex, M_E, Struct, Double, Bool);
+    scilab_fill_comparison_no_equal(IdentityComplex, Struct, M_E, Double, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Int8, M_E, Struct, Int8, Bool);
+    scilab_fill_comparison_no_equal(Int8, Struct, M_E, Int8, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, UInt8, M_E, Struct, UInt8, Bool);
+    scilab_fill_comparison_no_equal(UInt8, Struct, M_E, UInt8, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Int16, M_E, Struct, Int16, Bool);
+    scilab_fill_comparison_no_equal(Int16, Struct, M_E, Int16, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, UInt16, M_E, Struct, UInt16, Bool);
+    scilab_fill_comparison_no_equal(UInt16, Struct, M_E, UInt16, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Int32, M_E, Struct, Int32, Bool);
+    scilab_fill_comparison_no_equal(Int32, Struct, M_E, Int32, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, UInt32, M_E, Struct, UInt32, Bool);
+    scilab_fill_comparison_no_equal(UInt32, Struct, M_E, UInt32, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Int64, M_E, Struct, Int64, Bool);
+    scilab_fill_comparison_no_equal(Int64, Struct, M_E, Int64, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, UInt64, M_E, Struct, UInt64, Bool);
+    scilab_fill_comparison_no_equal(UInt64, Struct, M_E, UInt64, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, ScalarInt8, M_E, Struct, Int8, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt8, Struct, M_E, Int8, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarUInt8, M_E, Struct, UInt8, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt8, Struct, M_E, UInt8, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, ScalarInt16, M_E, Struct, Int16, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt16, Struct, M_E, Int16, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarUInt16, M_E, Struct, UInt16, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt16, Struct, M_E, UInt16, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, ScalarInt32, M_E, Struct, Int32, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt32, Struct, M_E, Int32, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarUInt32, M_E, Struct, UInt32, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt32, Struct, M_E, UInt32, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, ScalarInt64, M_E, Struct, Int64, Bool);
+    scilab_fill_comparison_no_equal(ScalarInt64, Struct, M_E, Int64, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarUInt64, M_E, Struct, UInt64, Bool);
+    scilab_fill_comparison_no_equal(ScalarUInt64, Struct, M_E, UInt64, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, String, M_E, Struct, String, Bool);
+    scilab_fill_comparison_no_equal(String, Struct, M_E, String, Struct, Bool);
+    scilab_fill_comparison_no_equal(Struct, ScalarString, M_E, Struct, String, Bool);
+    scilab_fill_comparison_no_equal(ScalarString, Struct, M_E, String, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, SparseComplex, M_E, Struct, Sparse, Bool);
+    scilab_fill_comparison_no_equal(SparseComplex, Struct, M_E, Sparse, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, Sparse, M_E, Struct, Sparse, Bool);
+    scilab_fill_comparison_no_equal(Sparse, Struct, M_E, Sparse, Struct, Bool);
+
+    scilab_fill_comparison_no_equal(Struct, SparseBool, M_E, Struct, SparseBool, Bool);
+    scilab_fill_comparison_no_equal(SparseBool, Struct, M_E, SparseBool, Struct, Bool);*/
+
+    //List, TList, MList
+    scilab_fill_comparison_no_equal(List, List, LT_LT, List, List, Bool);
+    scilab_fill_comparison_no_equal(MList, MList, LT_LT, MList, MList, Bool);
+    scilab_fill_comparison_no_equal(TList, TList, LT_LT, TList, TList, Bool);
+
+    scilab_fill_comparison_no_equal(List, TList, LT_LT, List, TList, Bool);
+    scilab_fill_comparison_no_equal(TList, List, LT_LT, TList, List, Bool);
+    scilab_fill_comparison_no_equal(List, MList, LT_LT, List, MList, Bool);
+    scilab_fill_comparison_no_equal(MList, List, LT_LT, MList, List, Bool);
+
+    scilab_fill_comparison_no_equal(TList, MList, LT_LT, TList, MList, Bool);
+    scilab_fill_comparison_no_equal(MList, TList, LT_LT, MList, TList, Bool);
+
+    //Cell
+    scilab_fill_comparison_no_equal(Cell, Cell, M_M, Cell, Cell, Bool);
+
+    //Handle
+    scilab_fill_comparison_no_equal(Handle, Handle, M_M, GraphicHandle, GraphicHandle, Bool);
+
+    //Macro
+    scilab_fill_comparison_no_equal(Macro, Macro, MCR_MCR, Macro, Macro, Bool);
+    scilab_fill_comparison_no_equal(MacroFile, MacroFile, MCR_MCR, MacroFile, MacroFile, Bool);
+    scilab_fill_comparison_no_equal(Macro, MacroFile, MCR_MCR, Macro, MacroFile, Bool);
+    scilab_fill_comparison_no_equal(MacroFile, Macro, MCR_MCR, MacroFile, Macro, Bool);
+
+
+#undef scilab_fill_comparison_no_equal
+
+}
+
 InternalType *GenericComparisonNonEqual(InternalType *_pLeftOperand, InternalType *_pRightOperand)
 {
-    if (_pLeftOperand->isSparse() && _pRightOperand->isSparse())
+    InternalType *pResult = NULL;
+
+    compnoequal_function compnoequal = pComparisonEqualfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
+    if (compnoequal)
+    {
+        pResult = compnoequal(_pLeftOperand, _pRightOperand);
+        if (pResult)
+        {
+            return pResult;
+        }
+    }
+
+    /*
+    ** Default case : Return NULL will Call Overloading.
+    */
+    return NULL;
+}
+
+
+//Matrix != x
+template<class T, class U, class O>
+InternalType* compnoequal_M_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(true);
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return new Bool(true);
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    compnoequal(_pL->get(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(true);
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return new Bool(true);
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    compnoequal(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compnoequal(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compnoequal(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
+    compnoequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_IC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
+    compnoequal(_pL->get(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_E(T *_pL, U *_pR)
+{
+    return new Bool(true);
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_E_M(T *_pL, U *_pR)
+{
+    return new Bool(true);
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_E_E(T *_pL, U *_pR)
+{
+    return new Bool(false);
+}
+
+//B != x
+template<class T, class U, class O>
+InternalType* compnoequal_B_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+    int* piDimsR = _pR->getDimsArray();
+
+    if (_pL->isScalar() == false)
+    {
+        if (iDimsL != iDimsR)
+        {
+            return new Bool(true);
+        }
+
+        int* piDimsL = _pL->getDimsArray();
+
+        for (int i = 0; i < iDimsL; ++i)
+        {
+            if (piDimsL[i] != piDimsR[i])
+            {
+                return new Bool(true);
+            }
+        }
+    }
+
+    O* pOut = new O(iDimsR, piDimsR);
+
+    pOut->setTrue();
+
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_B(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+    int* piDimsL = _pL->getDimsArray();
+
+    if (_pR->isScalar() == false)
+    {
+        if (iDimsL != iDimsR)
+        {
+            return new Bool(true);
+        }
+
+        int* piDimsR = _pR->getDimsArray();
+
+        for (int i = 0; i < iDimsL; ++i)
+        {
+            if (piDimsL[i] != piDimsR[i])
+            {
+                return new Bool(true);
+            }
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+
+    pOut->setTrue();
+
+    return pOut;
+}
+
+//B != x
+template<class T, class U, class O>
+InternalType* compnoequal_B_S(T *_pL, U *_pR)
+{
+
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+
+    pOut->setTrue();
+
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_B(T *_pL, U *_pR)
+{
+
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+
+    pOut->setTrue();
+
+    return pOut;
+}
+
+
+
+//Matrix complex != x
+template<class T, class U, class O>
+InternalType* compnoequal_MC_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(true);
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return new Bool(true);
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    compnoequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MC_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        return new Bool(true);
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < iDimsL; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return new Bool(true);
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    compnoequal(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compnoequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    compnoequal(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MC_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0));
+    compnoequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    Double* pIdentity = Double::Identity(_pL->getDims(), _pL->getDimsArray(), _pR->get(0), _pR->getImg(0));
+    compnoequal(_pL->get(), _pL->getImg(), (size_t)pOut->getSize(), pIdentity->get(), pIdentity->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+//Scalar == x
+template<class T, class U, class O>
+InternalType* compnoequal_S_M(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compnoequal(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compnoequal(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compnoequal(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_I(T *_pL, U *_pR)
+{
+    O* pOut = new O(1, 1);
+    compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_S_IC(T *_pL, U *_pR)
+{
+
+    O* pOut = new  Bool(true);
+    compnoequal(_pL->get(0), 1, _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+//Scalar complex != x
+template<class T, class U, class O>
+InternalType* compnoequal_SC_M(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compnoequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_SC_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    compnoequal(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_SC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(true);
+    if (_pL->getImg(0) == 0)
+    {
+        compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_SC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(false);
+    compnoequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_SC_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    if (_pL->getImg(0) == 0)
+    {
+        compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_SC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    compnoequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+//Identity != x
+template<class T, class U, class O>
+InternalType* compnoequal_I_M(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
+    compnoequal(pIdentity->get(), pOut->getSize(), _pR->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_I_MC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0));
+    compnoequal(pIdentity->get(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_I_S(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_I_SC(T *_pL, U *_pR)
+{
+    return compnoequal_SC_I<U, T, O>(_pR, _pL);
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_I_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_I_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    if (_pR->getImg(0) == 0)
+    {
+        compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+//Identity complex != x
+template<class T, class U, class O>
+InternalType* compnoequal_IC_M(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
+    compnoequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_IC_MC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+    Double* pIdentity = Double::Identity(_pR->getDims(), _pR->getDimsArray(), _pL->get(0), _pL->getImg(0));
+    compnoequal(pIdentity->get(), pIdentity->getImg(), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get());
+    delete pIdentity;
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_IC_S(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    if (_pL->getImg(0) == 0)
+    {
+        compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_IC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    compnoequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_IC_I(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    if (_pL->getImg(0) == 0)
+    {
+        compnoequal(_pL->get(0), _pR->get(0), pOut->get());
+    }
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_IC_IC(T *_pL, U *_pR)
+{
+    O* pOut = new Bool(true);
+    compnoequal(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get());
+    return pOut;
+}
+
+
+template<>
+InternalType* compnoequal_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, SparseBool* _pR)
+{
+    //pending changes
+
+    if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
+    {
+        return new Bool(true);
+    }
+
+    return _pR->newNotEqualTo(*_pL);
+}
+
+template<>
+InternalType* compnoequal_M_M<Sparse, Sparse, SparseBool>(Sparse* _pL, Sparse* _pR)
+{
+    //pending changes
+
+    if (((_pL->getRows() != _pR->getRows()) || (_pL->getCols() != _pR->getCols())) && (_pL->getSize() != 1) && (_pR->getSize() != 1))
+    {
+        return new Bool(true);
+    }
+
+    return _pR->newNotEqualTo(*_pL);
+}
+
+//[] != SP
+template<>
+InternalType* compnoequal_M_M<Double, Sparse, Bool>(Double* _pL, Sparse* _pR)
+{
+    return new Bool(true);
+}
+
+//SP != []
+template<>
+InternalType* compnoequal_M_M<Sparse, Double, Bool>(Sparse* _pL, Double* _pR)
+{
+    return new Bool(true);
+}
+
+//
+template<class T, class U, class O>
+InternalType* compnoequal_M_SP(T* _pL, U* _pR)
+{
+    //pending changes
+
+    //D -> SP != SP
+    Sparse* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+
+    if (_pL->isScalar())
+    {
+        int iSizeOut = _pR->getSize();
+        if (_pL->isComplex())
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
+            std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, stComplex);
+            }
+        }
+        else
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pL->get(0));
+            }
+        }
+    }
+    else
+    {
+        //check dimensions
+        if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
+        {
+            return new Bool(true);
+        }
+
+        int iSizeOut = _pR->getSize();
+        if (_pL->isComplex())
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), true);
+
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
+                pspConvert->set(i, stComplex);
+            }
+        }
+        else
+        {
+            pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pL->get(i));
+            }
+        }
+    }
+
+    pOut = _pR->newNotEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+}
+
+
+template<class T, class U, class O>
+InternalType* compnoequal_SP_M(T* _pL, U* _pR)
+{
+    //pending changes
+
+    Sparse* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+    if (_pR->isScalar())
+    {
+        int iSizeOut = _pL->getSize();
+        if (_pR->isComplex())
+        {
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
+            std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, stComplex);
+            }
+        }
+        else
+        {
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pR->get(0));
+            }
+        }
+    }
+    else
+    {
+        //check dimensions
+        if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
+        {
+            return new Bool(true);
+        }
+
+        int iSizeOut = _pL->getSize();
+        if (_pR->isComplex())
+        {
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), true);
+
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                std::complex<double> stComplex((double)_pR->get(i), (double)_pR->getImg(i));
+                pspConvert->set(i, stComplex);
+            }
+        }
+        else
+        {
+            pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
+            for (int i = 0; i < iSizeOut; i++)
+            {
+                pspConvert->set(i, (double)_pR->get(i));
+            }
+        }
+    }
+
+    pOut = _pL->newNotEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+
+}
+
+//sparsebool
+template<>
+InternalType* compnoequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool* _pR)
+{
+    //pending changes
+
+    //D -> SP == SP
+    SparseBool* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+
+    if (_pL->isScalar())
+    {
+        int iSizeOut = _pR->getSize();
+
+        pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
+        for (int i = 0; i < iSizeOut; i++)
+        {
+            pspConvert->set(i, _pL->get(0) == 1);
+        }
+
+    }
+    else
+    {
+        //check dimensions
+        if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
+        {
+            return new Bool(true);
+        }
+
+        int iSizeOut = _pR->getSize();
+
+        pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
+        for (int i = 0; i < iSizeOut; i++)
+        {
+            pspConvert->set(i, _pL->get(i) == 1);
+        }
+    }
+
+    pOut = _pR->newNotEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+}
+
+template<>
+InternalType* compnoequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool* _pR)
+{
+    //pending changes
+
+    SparseBool* pspConvert = NULL;
+    types::SparseBool* pOut = NULL;
+
+    if (_pR->isScalar())
+    {
+        int iSizeOut = _pL->getSize();
+
+        pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
+        for (int i = 0; i < iSizeOut; i++)
+        {
+            pspConvert->set(i, _pR->get(0) == 1);
+        }
+    }
+    else
+    {
+        //check dimensions
+        if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
+        {
+            return new Bool(true);
+        }
+
+        int iSizeOut = _pL->getSize();
+
+        pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
+        for (int i = 0; i < iSizeOut; i++)
+        {
+            pspConvert->set(i, _pR->get(i) == 1);
+        }
+    }
+
+    pOut = _pL->newNotEqualTo(*pspConvert);
+    delete pspConvert;
+    return pOut;
+
+}
+
+//Polynom
+template<>
+InternalType* compnoequal_M_M<Polynom, Polynom, Bool>(Polynom* _pL, Polynom* _pR)
+{
+    Bool* pbOut = NULL;
+    bool bPoise = true;
+
+    SinglePoly** pSPL = _pL->get();
+    SinglePoly** pSPR = _pR->get();
+
+    if (_pR->isScalar())
     {
-        InternalType *pResult = NULL;
-        Sparse* pL = _pLeftOperand->getAs<Sparse>();
-        Sparse* pR = _pRightOperand->getAs<Sparse>();
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        int iResult = NotEqualToSparseAndSparse(pL, pR, (GenericType**)&pResult);
-        if (iResult)
+        if (_pL->isComplex())
         {
-            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[0]->get(j), (double)0, pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+        }
+        else
+        {
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[0]->get(j), pSPR[0]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[0]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[0]->get(j), pSPL[i]->get(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
         }
+    }
+    else if (_pL->isScalar())
+    {
+        pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (pSPR[0]->getSize() != 1)
+        {
+            if (_pL->isComplex())
+            {
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = true;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compnoequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), pSPR[i]->getImg(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = true;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compnoequal(pSPL[0]->get(j), pSPL[0]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+            }
+            else
+            {
+
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = true;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPL[0]->getSize() && (bPoise == true); j++)
+                            {
+                                compnoequal(pSPL[0]->get(j), (double)0, pSPR[i]->get(j), pSPR[i]->get(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        if (pSPL[0]->getSize() != pSPR[i]->getSize())
+                        {
+                            bPoise = true;
+                        }
+                        else
+                        {
+                            bPoise = true;
+                            for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                            {
+                                compnoequal(pSPL[0]->get(j), pSPR[i]->get(j), &bPoise);
+                            }
+                        }
+                        pbOut->set(i, bPoise);
+                    }
+                }
 
-        return pResult;
+            }
+        }
     }
-    else if ((_pLeftOperand->isTList() && _pRightOperand->isTList()) ||
-             (_pLeftOperand->isMList() && _pRightOperand->isMList()))
+    else
     {
-        TList* pLL = _pLeftOperand->getAs<TList>();
-        TList* pLR = _pRightOperand->getAs<TList>();
+        //check dimensions
+        if (_pL->getDims() != _pR->getDims())
+        {
+            return new Bool(true);
+        }
+
+        for (int i = 0; i < _pL->getDims(); i++)
+        {
+            if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
+            {
+                return new Bool(true);
+            }
+        }
 
-        // check if an overload exists
-        std::wstring function_name;
-        function_name = L"%" + pLL->getShortTypeStr() + L"_n_" + pLR->getShortTypeStr();
-        InternalType* pFunc = symbol::Context::getInstance()->get(symbol::Symbol(function_name));
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        if (pFunc)
+        if (_pL->isComplex())
+        {
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), pSPL[i]->getImg(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPL[i]->get(j), pSPL[i]->getImg(j), pSPR[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+        }
+        else
         {
-            //call overload
-            return NULL;
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[i]->get(j), pSPR[i]->getImg(j), pSPL[i]->get(j), (double)0, &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPL[i]->getSize() != pSPR[i]->getSize())
+                    {
+                        bPoise = true;
+                    }
+                    else
+                    {
+                        bPoise = true;
+                        for (int j = 0; j < pSPR[i]->getSize() && (bPoise == true); j++)
+                        {
+                            compnoequal(pSPR[i]->get(j), pSPL[i]->get(j), &bPoise);
+                        }
+                    }
+                    pbOut->set(i, bPoise);
+                }
+            }
         }
+    }
+
+    return pbOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_P_M(T *_pL, U *_pR)
+{
+    Bool* pbOut = NULL;
+
+    SinglePoly** pSPR = _pL->get();
 
-        if (pLL->getSize() != pLR->getSize())
+    if (_pR->isIdentity())
+    {
+        Double* pdblEye = NULL;
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (_pL->isComplex())
         {
-            return new Bool(true);
+            if (_pR->isComplex())
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)pdblEye->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (_pR->isComplex())
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0), (double)_pR->getImg(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)0, (double)pdblEye->get(i), (double)pdblEye->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                pdblEye = Double::Identity(_pL->getDims(), _pL->getDimsArray(), (double)_pR->get(0));
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pdblEye->get(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
         }
+        delete pdblEye;
+    }
+    else if (_pR->isScalar())
+    {
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
 
-        if (pLL->getSize() == 0 && pLR->getSize() == 0)
+        if (_pL->isComplex())
+        {
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(0), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
+        }
+        else
         {
-            //list() == list() -> return true
-            return new Bool(false);
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(0), (double)_pR->getImg(0), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)_pR->get(0), &(pbOut->get()[i]));
+                    }
+                }
+            }
         }
+    }
+    else if (_pL->isScalar())
+    {
+        pbOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (pSPR[0]->getSize() == 1)
+        {
+            if (_pL->isComplex())
+            {
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compnoequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compnoequal((double)pSPR[0]->get(0), (double)pSPR[0]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
+            {
+                if (_pR->isComplex())
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compnoequal((double)pSPR[0]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < iSize; i++)
+                    {
+                        compnoequal((double)pSPR[0]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
+                    }
+                }
 
-        Bool* pB = new Bool(1, pLL->getSize());
-        for (int i = 0 ; i < pLL->getSize() ; i++)
+            }
+        }
+        else
         {
-            pB->set(i, *pLL->get(i) != *pLR->get(i));
+            pbOut->setTrue();
         }
 
-        return pB;
     }
     else
     {
-        InternalType* pResult = GenericComparisonEqual(_pLeftOperand, _pRightOperand);
-        if (pResult == NULL)
+        //check dimensions
+        if (_pL->getDims() != _pR->getDims())
+        {
+            return new Bool(true);
+        }
+
+        for (int i = 0; i < _pL->getDims(); i++)
         {
-            //to call overloading
-            return NULL;
+            if (_pL->getDimsArray()[i] != _pR->getDimsArray()[i])
+            {
+                return new Bool(true);
+            }
         }
 
-        if (pResult->isBool())
+        pbOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        int iSize = pbOut->getSize();
+
+        if (_pL->isComplex())
         {
-            Bool *pB = pResult->getAs<Bool>();
-            for (int i = 0 ; i < pB->getSize() ; i++)
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
             {
-                pB->set(i, pB->get(i) == 0);
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)pSPR[i]->getImg(0), (double)_pR->get(i), (double)0, &(pbOut->get()[i]));
+                    }
+                }
             }
-            return pB;
         }
-        else if (pResult->isSparseBool())
+        else
         {
-            SparseBool *pSB = pResult->getAs<SparseBool>();
-            for (int i = 0 ; i < pSB->getRows() ; i++)
+            if (_pR->isComplex())
+            {
+                for (int i = 0; i < iSize; i++)
+                {
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)0, (double)_pR->get(i), (double)_pR->getImg(i), &(pbOut->get()[i]));
+                    }
+                }
+            }
+            else
             {
-                for (int j = 0 ; j < pSB->getCols() ; j++)
+                for (int i = 0; i < iSize; i++)
                 {
-                    pSB->set(i, j, !pSB->get(i, j));
+                    if (pSPR[i]->getSize() != 1)
+                    {
+                        pbOut->set(i, true);
+                    }
+                    else
+                    {
+                        compnoequal((double)pSPR[i]->get(0), (double)_pR->get(i), &(pbOut->get()[i]));
+                    }
                 }
             }
-            return pSB;
         }
     }
 
+    return pbOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_M_P(T *_pL, U *_pR)
+{
+    return GenericComparisonNonEqual(_pR, _pL);
+}
+
+template<>
+InternalType* compnoequal_M_M<String, String, Bool>(String* _pL, String* _pR)
+{
+    if (_pL->getSize() == _pR->getSize())
+    {
+        //check dims
+        int iDimsL = _pL->getDims();
+        int iDimsR = _pR->getDims();
+
+        if (iDimsL != iDimsR)
+        {
+            return new Bool(true);
+        }
+
+        int* piDimsL = _pL->getDimsArray();
+        int* piDimsR = _pR->getDimsArray();
+
+        for (int i = 0; i < iDimsL; ++i)
+        {
+            if (piDimsL[i] != piDimsR[i])
+            {
+                return new Bool(true);
+            }
+        }
+        Bool*  pOut = new Bool(iDimsL, piDimsL);
+
+        for (int i = 0; i < _pL->getSize(); i++)
+        {
+            pOut->set(i, wcscmp(_pL->get(i), _pR->get(i)) != 0);
+        }
+        return pOut;
+    }
+    else if (_pL->getSize() == 1)
+    {
+        Bool*  pOut = new Bool(_pR->getDims(), _pR->getDimsArray());
+        for (int i = 0; i < _pR->getSize(); i++)
+        {
+            pOut->set(i, wcscmp(_pL->get(0), _pR->get(i)) != 0);
+        }
+        return pOut;
+    }
+    else if (_pR->getSize() == 1)
+    {
+        Bool*  pOut = new Bool(_pL->getDims(), _pL->getDimsArray());
+        for (int i = 0; i < _pL->getSize(); i++)
+        {
+            pOut->set(i, wcscmp(_pL->get(i), _pR->get(0)) != 0);
+        }
+        return pOut;
+    }
+
     return NULL;
 }
 
-int NotEqualToSparseAndSparse(Sparse* _pSparse1, Sparse* _pSparse2, GenericType** _pOut)
+template<>
+types::InternalType* compnoequal_M_M<Struct, Struct, Bool>(types::Struct* _pL, types::Struct* _pR)
 {
-    if ((_pSparse1->getRows() == _pSparse2->getRows() && _pSparse1->getCols() == _pSparse2->getCols()) //matrix case
-            || _pSparse1->isScalar() || _pSparse2->isScalar()) //scalar cases
+
+    if (_pL->getSize() != _pR->getSize())
     {
-        *_pOut = _pSparse1->newNotEqualTo(*_pSparse2);
+        return new Bool(true);
     }
-    else
+
+    String* pStringFielNamesPL = _pL->getFieldNames();
+    String* pStringFielNamesPR = _pR->getFieldNames();
+    wchar_t** ppwchPR = pStringFielNamesPR->get();
+    wchar_t** ppwchPL = pStringFielNamesPL->get();
+
+    Bool* pOut = new Bool(1, 2 * pStringFielNamesPL->getSize());
+    pOut->setTrue();
+    int* piPOut = pOut->get();
+
+    for (int iComptSStruct = 0; iComptSStruct < _pL->getSize(); iComptSStruct++)
+    {
+        for (int i = 0; i < pStringFielNamesPL->getSize(); i++)
+        {
+            piPOut[i * 2] = (wcscmp(ppwchPR[i], ppwchPL[i]) != 0) && (piPOut[i * 2] == 1);
+
+
+            if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == _pR->get(iComptSStruct)->get(ppwchPR[i])->getType())
+            {
+                if (_pL->get(iComptSStruct)->get(ppwchPL[i])->getType() == types::InternalType::ScilabStruct)
+                {
+                    piPOut[i * 2 + 1] = _pL->get(iComptSStruct)->get(ppwchPL[i]) != _pR->get(iComptSStruct)->get(ppwchPR[i]) && (piPOut[i * 2] == 1);
+                }
+                else
+                {
+                    types::InternalType* pResolution = GenericComparisonNonEqual(_pL->get(iComptSStruct)->get(ppwchPL[i]), _pR->get(iComptSStruct)->get(ppwchPR[i]));
+                    bool bValeur = true;
+                    if (pResolution->getType() == types::InternalType::ScilabBool)
+                    {
+                        Bool* pBoolTempo = pResolution->getAs<Bool>();
+                        for (int j = 0; j < pBoolTempo->getSize() && bValeur == true; j++)
+                        {
+                            if (pBoolTempo->get(j) != 1)
+                            {
+                                bValeur = false;
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        SparseBool* pSparseBoolTempo = pResolution->getAs<SparseBool>();
+                        for (int j = 0; j < pSparseBoolTempo->getSize() && bValeur == true; j++)
+                        {
+                            if (pSparseBoolTempo->get(j) != 1)
+                            {
+                                bValeur = false;
+                                break;
+                            }
+                        }
+                    }
+                    piPOut[i * 2 + 1] = bValeur && (piPOut[i * 2 + 1] == 1);
+                }
+            }
+            else
+            {
+                piPOut[i * 2 + 1] = true;
+            }
+        }
+    }
+
+    return pOut;
+}
+
+//List, TList, MList
+template<class T, class U, class O>
+InternalType* compnoequal_LT_LT(T *_pL, U *_pR)
+{
+    if (_pL->getSize() != _pR->getSize())
+    {
+        return new Bool(true);
+    }
+
+    if (_pL->getSize() == 0 && _pR->getSize() == 0)
+    {
+        return new Bool(false);
+    }
+
+    Bool* pB = new Bool(1, _pL->getSize());
+    for (int i = 0; i < _pL->getSize(); i++)
+    {
+        pB->set(i, !((*_pL->get(i) == *_pR->get(i)) && (_pL->get(i)->getType() != types::InternalType::ScilabVoid)));
+    }
+
+    return pB;
+}
+
+template<>
+types::InternalType* compnoequal_M_M<Cell, Cell, Bool>(types::Cell* _pL, types::Cell* _pR)
+{
+    /* check dimension*/
+    if (_pL->getDims() != _pR->getDims())
+    {
+        return new Bool(true);
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < _pL->getDims(); i++)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            return new Bool(true);
+        }
+    }
+
+    if (_pL->getSize() == 0)
+    {
+        //{} == {} -> return true
+        return new Bool(false);
+    }
+
+    Bool *pB = new Bool(_pL->getDims(), piDimsL);
+    for (int i = 0; i < _pL->getSize(); i++)
+    {
+        pB->set(i, !(*_pL->get(i) == *_pR->get(i)));
+    }
+
+    return pB;
+}
+
+template<>
+types::InternalType* compnoequal_M_M<GraphicHandle, GraphicHandle, Bool>(GraphicHandle* _pL, GraphicHandle* _pR)
+{
+
+    /* check dimension*/
+    if (_pL->getDims() != _pR->getDims())
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0; i < _pL->getDims(); i++)
     {
-        *_pOut = new Bool(true);
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+    Bool* pOut = new Bool(_pL->getDims(), piDimsL);
+    int iSize = pOut->getSize();
+
+    compnoequal(_pL->get(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* compnoequal_MCR_MCR(T *_pL, U *_pR)
+{
+    bool ret = false;
+    if (_pL->getType() == GenericType::ScilabMacroFile)
+    {
+        types::InternalType* pIT = ((InternalType *) _pL);
+        types::MacroFile* pL = pIT->getAs<types::MacroFile>();
+        ret = *pL != *_pR;
+    }
+    else if (_pL->getType() == GenericType::ScilabMacro)
+    {
+        types::InternalType* pIT = ((InternalType *) _pL);
+        types::Macro* pL = pIT->getAs<types::Macro>();
+        if (_pR->getType() == GenericType::ScilabMacroFile)
+        {
+            types::InternalType* pIT = ((InternalType *) _pR);
+            types::MacroFile* pR = pIT->getAs<types::MacroFile>();
+            ret = *pR != *pL;
+        }
+        else
+        {
+            ret = *pL != *_pR;
+        }
     }
 
-    return 0;
+    return new Bool(ret);
 }
index 0e8ce21..9d7cb72 100644 (file)
@@ -80,6 +80,61 @@ Double* Double::Identity(int _iDims, int* _piDims)
     return pI;
 }
 
+Double* Double::Identity(int _iDims, int* _piDims, double _dblReal)
+{
+    Double* pI = new Double(_iDims, _piDims);
+    pI->setZeros();
+    int iMinDim = _piDims[0];
+    for (int i = 1; i < _iDims; i++)
+    {
+        if (_piDims[i] < iMinDim)
+        {
+            iMinDim = _piDims[i];
+        }
+    }
+
+    for (int i = 0; i < iMinDim; i++)
+    {
+        int* piIndex = new int[_iDims];
+        for (int j = 0; j < _iDims; j++)
+        {
+            piIndex[j] = i;
+        }
+
+        int index = getIndexWithDims(piIndex, _piDims, _iDims);
+        pI->set(index, _dblReal);
+    }
+    return pI;
+}
+
+Double* Double::Identity(int _iDims, int* _piDims, double _dblReal, double _dblImg)
+{
+    Double* pI = new Double(_iDims, _piDims, true);
+    pI->setZeros();
+    int iMinDim = _piDims[0];
+    for (int i = 1; i < _iDims; i++)
+    {
+        if (_piDims[i] < iMinDim)
+        {
+            iMinDim = _piDims[i];
+        }
+    }
+
+    for (int i = 0; i < iMinDim; i++)
+    {
+        int* piIndex = new int[_iDims];
+        for (int j = 0; j < _iDims; j++)
+        {
+            piIndex[j] = i;
+        }
+
+        int index = getIndexWithDims(piIndex, _piDims, _iDims);
+        pI->set(index, _dblReal);
+        pI->setImg(index, _dblImg);
+    }
+    return pI;
+}
+
 bool Double::isEmpty()
 {
     if (getDims() == 2 && getRows() == 0 && getCols() == 0)
diff --git a/scilab/modules/ast/tests/unit_tests/comparisonequal.dia.ref b/scilab/modules/ast/tests/unit_tests/comparisonequal.dia.ref
new file mode 100644 (file)
index 0000000..c175d8d
--- /dev/null
@@ -0,0 +1,1028 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2014 - Scilab Enterprises - Sylvain GENIN
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+// <-- JVM NOT MANDATORY -->
+s = %s;
+empty = [];
+r = 2;
+R = [1,2;3,4];
+R3(:,:,1) = R;
+R3(:,:,2) = R';
+c = 1 + 2*%i;
+C = [1+2*%i,2+4*%i;3+6*%i,4+8*%i];
+C3(:,:,1) = C;
+C3(:,:,2) = C';
+e = eye();
+ec = (5+%i) * eye();
+p = 1 + %s - %s**2;
+pc = 1 + %s - %s**2 + ( 2 - 3 * %s + 4 * %s**2 ) * %i;
+P = [2*p, 2;4*p,-5*p];
+PC = [2*pc, 2;4*pc,-5*pc];
+SP = sparse([1,2;4,5;3,10],[1,2,3]);
+SPC = sparse([1,2;4,5;3,10],[1,2,3]) * ( 1 + 4*%i);
+SPB = sparse([1,2;2,1],[%t;%t],[2,2]);
+SP1 = sparse([1,1],[10]);
+SPC1 = sparse([1,1],[1]) * ( 2 + 6*%i);
+i8 = int8(-8);
+ui8 = uint8(8);
+I8 = int8([-8 2 ; -24 -32]);
+UI8 = uint8([8 2 ; 24 32]);
+I16 = int16([-16 2 ; -48 -64]);
+UI16 = uint16([16 2 ; 48 64]);
+i16 = int16(-16);
+ui16 = uint16(16);
+i32 = int32(-32);
+ui32 = uint32(32);
+I32 = int32([-32 2 ; -96 -128]);
+UI32 = uint32([32 2 ; 96 128]);
+str = "string";
+STR = ["string1" "string2";"string3" "string4"];
+b = %f;
+B = [%t %f;%f %t];
+assert_checkequal(empty == empty, %t);
+assert_checkequal(empty == r, %f);
+assert_checkequal(empty == c, %f);
+assert_checkequal(empty == R, %f);
+assert_checkequal(empty == C, %f);
+assert_checkequal(empty == e, %f);
+assert_checkequal(empty == ec, %f);
+assert_checkequal(empty == p, %f);
+assert_checkequal(empty == pc, %f);
+assert_checkequal(empty == P, %f);
+assert_checkequal(empty == PC, %f);
+assert_checkequal(empty == SP, %f);
+assert_checkequal(empty == SPC, %f);
+assert_checkequal(empty == SP1, %f);
+assert_checkequal(empty == SPC1, %f);
+assert_checkequal(empty == i8, %f);
+assert_checkequal(empty == I8, %f);
+assert_checkequal(empty == ui8, %f);
+assert_checkequal(empty == UI8, %f);
+assert_checkequal(empty == i16, %f);
+assert_checkequal(empty == I16, %f);
+assert_checkequal(empty == ui16, %f);
+assert_checkequal(empty == UI16, %f);
+assert_checkequal(empty == i32, %f);
+assert_checkequal(empty == I32, %f);
+assert_checkequal(empty == ui32, %f);
+assert_checkequal(empty == UI32, %f);
+assert_checkequal(empty == str, %f);
+assert_checkequal(empty == STR, %f);
+assert_checkequal(empty == b, %f);
+assert_checkequal(empty == B, %f);
+assert_checkequal(empty == SPB, %f);
+assert_checkequal(r == empty, %f);
+assert_checkequal(r == r, %t);
+assert_checkequal(r == c, %f);
+assert_checkequal(r == R, [%f,%t;%f,%f]);
+assert_checkequal(r == C, [%f,%f;%f,%f]);
+assert_checkequal(r == e, %f);
+assert_checkequal(r == ec, %f);
+assert_checkequal(r == p, %f);
+assert_checkequal(r == pc, %f);
+assert_checkequal(r == P, [%f,%t;%f,%f]);
+assert_checkequal(r == PC, [%f,%t;%f,%f]);
+assert_checkequal(r == SP, sparse([4,5],%t,[4,10]));
+assert_checkequal(r == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(r == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(r == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(r == i8, %f);
+assert_checkequal(r == I8, [%f,%t;%f,%f]);
+assert_checkequal(r == ui8, %f);
+assert_checkequal(r == UI8, [%f,%t;%f,%f]);
+assert_checkequal(r == i16, %f);
+assert_checkequal(r == I16, [%f,%t;%f,%f]);
+assert_checkequal(r == ui16, %f);
+assert_checkequal(r == UI16, [%f,%t;%f,%f]);
+assert_checkequal(r == i32, %f);
+assert_checkequal(r == I32, [%f,%t;%f,%f]);
+assert_checkequal(r == ui32, %f);
+assert_checkequal(r == UI32, [%f,%t;%f,%f]);
+assert_checkequal(r == str, %f);
+assert_checkequal(r == STR, %f);
+assert_checkequal(r == b, %f);
+assert_checkequal(r == B, %f);
+assert_checkequal(r == SPB, %f);
+assert_checkequal(c == empty, %f);
+assert_checkequal(c == r, %f);
+assert_checkequal(c == c, %t);
+assert_checkequal(c == R, [%f,%f;%f,%f]);
+assert_checkequal(c == C, [%t,%f;%f,%f]);
+assert_checkequal(c == e, %f);
+assert_checkequal(c == ec, %f);
+assert_checkequal(c == p, %f);
+assert_checkequal(c == pc, %f);
+assert_checkequal(c == P, [%f,%f;%f,%f]);
+assert_checkequal(c == PC, [%f,%f;%f,%f]);
+assert_checkequal(c == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(c == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(c == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(c == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(c == i8, %f);
+assert_checkequal(c == I8, [%f,%f;%f,%f]);
+assert_checkequal(c == ui8, %f);
+assert_checkequal(c == UI8, [%f,%f;%f,%f]);
+assert_checkequal(c == i16, %f);
+assert_checkequal(c == I16, [%f,%f;%f,%f]);
+assert_checkequal(c == ui16, %f);
+assert_checkequal(c == UI16, [%f,%f;%f,%f]);
+assert_checkequal(c == i32, %f);
+assert_checkequal(c == I32, [%f,%f;%f,%f]);
+assert_checkequal(c == ui32, %f);
+assert_checkequal(c == UI32, [%f,%f;%f,%f]);
+assert_checkequal(c == str, %f);
+assert_checkequal(c == STR, %f);
+assert_checkequal(c == b, %f);
+assert_checkequal(c == B, %f);
+assert_checkequal(c == SPB, %f);
+assert_checkequal(R == empty, %f);
+assert_checkequal(R == r, [%f,%t;%f,%f]);
+assert_checkequal(R == c, [%f,%f;%f,%f]);
+assert_checkequal(R == R, [%t,%t;%t,%t]);
+assert_checkequal(R == C, [%f,%f;%f,%f]);
+assert_checkequal(R == e, [%t,%f;%f,%f]);
+assert_checkequal(R == ec, [%f,%f;%f,%f]);
+assert_checkequal(R == p, [%f,%f;%f,%f]);
+assert_checkequal(R == pc, [%f,%f;%f,%f]);
+assert_checkequal(R == P, [%f,%t;%f,%f]);
+assert_checkequal(R == PC, [%f,%t;%f,%f]);
+assert_checkequal(R == SP, %f);
+assert_checkequal(R == SPC, %f);
+assert_checkequal(R == SP1, %f);
+assert_checkequal(R == SPC1, %f);
+assert_checkequal(R == i8, [%f,%f;%f,%f]);
+assert_checkequal(R == I8, [%f,%t;%f,%f]);
+assert_checkequal(R == ui8, [%f,%f;%f,%f]);
+assert_checkequal(R == UI8, [%f,%t;%f,%f]);
+assert_checkequal(R == i16, [%f,%f;%f,%f]);
+assert_checkequal(R == I16, [%f,%t;%f,%f]);
+assert_checkequal(R == ui16, [%f,%f;%f,%f]);
+assert_checkequal(R == UI16, [%f,%t;%f,%f]);
+assert_checkequal(R == i32, [%f,%f;%f,%f]);
+assert_checkequal(R == I32, [%f,%t;%f,%f]);
+assert_checkequal(R == ui32, [%f,%f;%f,%f]);
+assert_checkequal(R == UI32, [%f,%t;%f,%f]);
+assert_checkequal(R == str, %f);
+assert_checkequal(R == STR, %f);
+assert_checkequal(R == b, %f);
+assert_checkequal(R == B, %f);
+assert_checkequal(R == SPB, %f);
+assert_checkequal(C == empty, %f);
+assert_checkequal(C == r, [%f,%f;%f,%f]);
+assert_checkequal(C == c, [%t,%f;%f,%f]);
+assert_checkequal(C == R, [%f,%f;%f,%f]);
+assert_checkequal(C == C, [%t,%t;%t,%t]);
+assert_checkequal(C == e, [%f,%f;%f,%f]);
+assert_checkequal(C == ec, [%f,%f;%f,%f]);
+assert_checkequal(C == p, [%f,%f;%f,%f]);
+assert_checkequal(C == pc, [%f,%f;%f,%f]);
+assert_checkequal(C == P, [%f,%f;%f,%f]);
+assert_checkequal(C == PC, [%f,%f;%f,%f]);
+assert_checkequal(C == SP, %f);
+assert_checkequal(C == SPC, %f);
+assert_checkequal(C == SP1, %f);
+assert_checkequal(C == SPC1, %f);
+assert_checkequal(C == i8, [%f,%f;%f,%f]);
+assert_checkequal(C == I8, [%f,%f;%f,%f]);
+assert_checkequal(C == ui8, [%f,%f;%f,%f]);
+assert_checkequal(C == UI8, [%f,%f;%f,%f]);
+assert_checkequal(C == i16, [%f,%f;%f,%f]);
+assert_checkequal(C == I16, [%f,%f;%f,%f]);
+assert_checkequal(C == ui16, [%f,%f;%f,%f]);
+assert_checkequal(C == UI16, [%f,%f;%f,%f]);
+assert_checkequal(C == i32, [%f,%f;%f,%f]);
+assert_checkequal(C == I32, [%f,%f;%f,%f]);
+assert_checkequal(C == ui32, [%f,%f;%f,%f]);
+assert_checkequal(C == UI32, [%f,%f;%f,%f]);
+assert_checkequal(C == str, %f);
+assert_checkequal(C == STR, %f);
+assert_checkequal(C == b, %f);
+assert_checkequal(C == B, %f);
+assert_checkequal(C == SPB, %f);
+assert_checkequal(e == empty, %f);
+assert_checkequal(e == r, %f);
+assert_checkequal(e == c, %f);
+assert_checkequal(e == R, [%t,%f;%f,%f]);
+assert_checkequal(e == C, [%f,%f;%f,%f]);
+assert_checkequal(e == e, %t);
+assert_checkequal(e == ec, %f);
+assert_checkequal(e == p, %f);
+assert_checkequal(e == pc, %f);
+assert_checkequal(e == P, [%f,%f;%f,%f]);
+assert_checkequal(e == PC, [%f,%f;%f,%f]);
+assert_checkequal(e == SP, %f);
+assert_checkequal(e == SPC, %f);
+assert_checkequal(e == SP1, %f);
+assert_checkequal(e == SPC1, %f);
+assert_checkequal(e == i8, %f);
+assert_checkequal(e == I8, [%f,%f;%f,%f]);
+assert_checkequal(e == ui8, %f);
+assert_checkequal(e == UI8, [%f,%f;%f,%f]);
+assert_checkequal(e == i16, %f);
+assert_checkequal(e == I16, [%f,%f;%f,%f]);
+assert_checkequal(e == ui16, %f);
+assert_checkequal(e == UI16, [%f,%f;%f,%f]);
+assert_checkequal(e == i32, %f);
+assert_checkequal(e == I32, [%f,%f;%f,%f]);
+assert_checkequal(e == ui32, %f);
+assert_checkequal(e == UI32, [%f,%f;%f,%f]);
+assert_checkequal(e == str, %f);
+assert_checkequal(e == STR, %f);
+assert_checkequal(e == b, %f);
+assert_checkequal(e == B, %f);
+assert_checkequal(e == SPB, %f);
+assert_checkequal(ec == empty, %f);
+assert_checkequal(ec == r, %f);
+assert_checkequal(ec == c, %f);
+assert_checkequal(ec == R, [%f,%f;%f,%f]);
+assert_checkequal(ec == C, [%f,%f;%f,%f]);
+assert_checkequal(ec == e, %f);
+assert_checkequal(ec == ec, %t);
+assert_checkequal(ec == p, %f);
+assert_checkequal(ec == pc, %f);
+assert_checkequal(ec == P, [%f,%f;%f,%f]);
+assert_checkequal(ec == PC, [%f,%f;%f,%f]);
+assert_checkequal(ec == SP, %f);
+assert_checkequal(ec == SPC, %f);
+assert_checkequal(ec == SP1, %f);
+assert_checkequal(ec == SPC1, %f);
+assert_checkequal(ec == i8, %f);
+assert_checkequal(ec == I8, [%f,%f;%f,%f]);
+assert_checkequal(ec == ui8, %f);
+assert_checkequal(ec == UI8, [%f,%f;%f,%f]);
+assert_checkequal(ec == i16, %f);
+assert_checkequal(ec == I16, [%f,%f;%f,%f]);
+assert_checkequal(ec == ui16, %f);
+assert_checkequal(ec == UI16, [%f,%f;%f,%f]);
+assert_checkequal(ec == i32, %f);
+assert_checkequal(ec == I32, [%f,%f;%f,%f]);
+assert_checkequal(ec == ui32, %f);
+assert_checkequal(ec == UI32, [%f,%f;%f,%f]);
+assert_checkequal(ec == str, %f);
+assert_checkequal(ec == STR, %f);
+assert_checkequal(ec == b, %f);
+assert_checkequal(ec == B, %f);
+assert_checkequal(ec == SPB, %f);
+assert_checkequal(p == empty, %f);
+assert_checkequal(p == r, %f);
+assert_checkequal(p == c, %f);
+assert_checkequal(p == R, [%f,%f;%f,%f]);
+assert_checkequal(p == C, [%f,%f;%f,%f]);
+assert_checkequal(p == e, %f);
+assert_checkequal(p == ec, %f);
+assert_checkequal(p == p, %t);
+assert_checkequal(p == pc, %f);
+assert_checkequal(p == P, [%f,%f;%f,%f]);
+assert_checkequal(p == PC, [%f,%f;%f,%f]);
+assert_checkequal(p == i8, %f);
+assert_checkequal(p == I8, [%f,%f;%f,%f]);
+assert_checkequal(p == ui8, %f);
+assert_checkequal(p == UI8, [%f,%f;%f,%f]);
+assert_checkequal(p == i16, %f);
+assert_checkequal(p == I16, [%f,%f;%f,%f]);
+assert_checkequal(p == ui16, %f);
+assert_checkequal(p == UI16, [%f,%f;%f,%f]);
+assert_checkequal(p == i32, %f);
+assert_checkequal(p == I32, [%f,%f;%f,%f]);
+assert_checkequal(p == ui32, %f);
+assert_checkequal(p == UI32, [%f,%f;%f,%f]);
+assert_checkequal(p == str, %f);
+assert_checkequal(p == STR, %f);
+assert_checkequal(p == b, %f);
+assert_checkequal(p == B, %f);
+assert_checkequal(pc == empty, %f);
+assert_checkequal(pc == r, %f);
+assert_checkequal(pc == c, %f);
+assert_checkequal(pc == R, [%f,%f;%f,%f]);
+assert_checkequal(pc == C, [%f,%f;%f,%f]);
+assert_checkequal(pc == e, %f);
+assert_checkequal(pc == ec, %f);
+assert_checkequal(pc == p, %f);
+assert_checkequal(pc == pc, %t);
+assert_checkequal(pc == P, [%f,%f;%f,%f]);
+assert_checkequal(pc == PC, [%f,%f;%f,%f]);
+assert_checkequal(pc == i8, %f);
+assert_checkequal(pc == I8, [%f,%f;%f,%f]);
+assert_checkequal(pc == ui8, %f);
+assert_checkequal(pc == UI8, [%f,%f;%f,%f]);
+assert_checkequal(pc == i16, %f);
+assert_checkequal(pc == I16, [%f,%f;%f,%f]);
+assert_checkequal(pc == ui16, %f);
+assert_checkequal(pc == UI16, [%f,%f;%f,%f]);
+assert_checkequal(pc == i32, %f);
+assert_checkequal(pc == I32, [%f,%f;%f,%f]);
+assert_checkequal(pc == ui32, %f);
+assert_checkequal(pc == UI32, [%f,%f;%f,%f]);
+assert_checkequal(pc == str, %f);
+assert_checkequal(pc == STR, %f);
+assert_checkequal(pc == b, %f);
+assert_checkequal(pc == B, %f);
+assert_checkequal(P == empty, %f);
+assert_checkequal(P == r, [%f,%t;%f,%f]);
+assert_checkequal(P == c, [%f,%f;%f,%f]);
+assert_checkequal(P == R, [%f,%t;%f,%f]);
+assert_checkequal(P == C, [%f,%f;%f,%f]);
+assert_checkequal(P == e, [%f,%f;%f,%f]);
+assert_checkequal(P == ec, [%f,%f;%f,%f]);
+assert_checkequal(P == p, [%f,%f;%f,%f]);
+assert_checkequal(P == pc, [%f,%f;%f,%f]);
+assert_checkequal(P == P, [%t,%t;%t,%t]);
+assert_checkequal(P == PC, [%f,%t;%f,%f]);
+assert_checkequal(P == i8, [%f,%f;%f,%f]);
+assert_checkequal(P == I8, [%f,%t;%f,%f]);
+assert_checkequal(P == ui8, [%f,%f;%f,%f]);
+assert_checkequal(P == UI8, [%f,%t;%f,%f]);
+assert_checkequal(P == i16, [%f,%f;%f,%f]);
+assert_checkequal(P == I16, [%f,%t;%f,%f]);
+assert_checkequal(P == ui16, [%f,%f;%f,%f]);
+assert_checkequal(P == UI16, [%f,%t;%f,%f]);
+assert_checkequal(P == i32, [%f,%f;%f,%f]);
+assert_checkequal(P == I32, [%f,%t;%f,%f]);
+assert_checkequal(P == ui32, [%f,%f;%f,%f]);
+assert_checkequal(P == UI32, [%f,%t;%f,%f]);
+assert_checkequal(P == str, %f);
+assert_checkequal(P == STR, %f);
+assert_checkequal(P == b, %f);
+assert_checkequal(P == B, %f);
+assert_checkequal(PC == empty, %f);
+assert_checkequal(PC == r, [%f,%t;%f,%f]);
+assert_checkequal(PC == c, [%f,%f;%f,%f]);
+assert_checkequal(PC == R, [%f,%t;%f,%f]);
+assert_checkequal(PC == C, [%f,%f;%f,%f]);
+assert_checkequal(PC == e, [%f,%f;%f,%f]);
+assert_checkequal(PC == ec, [%f,%f;%f,%f]);
+assert_checkequal(PC == p, [%f,%f;%f,%f]);
+assert_checkequal(PC == pc, [%f,%f;%f,%f]);
+assert_checkequal(PC == P, [%f,%t;%f,%f]);
+assert_checkequal(PC == PC, [%t,%t;%t,%t]);
+assert_checkequal(PC == i8, [%f,%f;%f,%f]);
+assert_checkequal(PC == I8, [%f,%t;%f,%f]);
+assert_checkequal(PC == ui8, [%f,%f;%f,%f]);
+assert_checkequal(PC == UI8, [%f,%t;%f,%f]);
+assert_checkequal(PC == i16, [%f,%f;%f,%f]);
+assert_checkequal(PC == I16, [%f,%t;%f,%f]);
+assert_checkequal(PC == ui16, [%f,%f;%f,%f]);
+assert_checkequal(PC == UI16, [%f,%t;%f,%f]);
+assert_checkequal(PC == i32, [%f,%f;%f,%f]);
+assert_checkequal(PC == I32, [%f,%t;%f,%f]);
+assert_checkequal(PC == ui32, [%f,%f;%f,%f]);
+assert_checkequal(PC == UI32, [%f,%t;%f,%f]);
+assert_checkequal(PC == str, %f);
+assert_checkequal(PC == STR, %f);
+assert_checkequal(PC == b, %f);
+assert_checkequal(PC == B, %f);
+assert_checkequal(SP == empty, %f);
+assert_checkequal(SP == r, sparse([4,5],%t,[4,10]));
+assert_checkequal(SP == c, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == R, %f);
+assert_checkequal(SP == C, %f);
+assert_checkequal(SP == e, %f);
+assert_checkequal(SP == ec, %f);
+assert_checkequal(SP == SP, sparse([1,1;1,2;1,3;1,4;1,5;1,6;1,7;1,8;1,9;1,10;2,1;2,2;2,3;2,4;2,5;2,6;2,7;2,8;2,9;2,10;3,1;3,2;3,3;3,4;3,5;3,6;3,7;3,8;3,9;3,10;4,1;4,2;4,3;4,4;4,5;4,6;4,7;4,8;4,9;4,10],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t],[4,10]));
+assert_checkequal(SP == SPC, sparse([1,1;1,3;1,4;1,5;1,6;1,7;1,8;1,9;1,10;2,1;2,2;2,3;2,4;2,5;2,6;2,7;2,8;2,9;2,10;3,1;3,2;3,3;3,4;3,5;3,6;3,7;3,8;3,9;4,1;4,2;4,3;4,4;4,6;4,7;4,8;4,9;4,10],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t],[4,10]));
+assert_checkequal(SP == SP1, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == SPC1, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == i8, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == I8, %f);
+assert_checkequal(SP == ui8, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == UI8, %f);
+assert_checkequal(SP == i16, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == I16, %f);
+assert_checkequal(SP == ui16, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == UI16, %f);
+assert_checkequal(SP == i32, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == I32, %f);
+assert_checkequal(SP == ui32, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP == UI32, %f);
+assert_checkequal(SP == str, %f);
+assert_checkequal(SP == STR, %f);
+assert_checkequal(SP == b, %f);
+assert_checkequal(SP == B, %f);
+assert_checkequal(SP == SPB, %f);
+assert_checkequal(SPC == empty, %f);
+assert_checkequal(SPC == r, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == c, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == R, %f);
+assert_checkequal(SPC == C, %f);
+assert_checkequal(SPC == e, %f);
+assert_checkequal(SPC == ec, %f);
+assert_checkequal(SPC == SP, sparse([1,1;1,3;1,4;1,5;1,6;1,7;1,8;1,9;1,10;2,1;2,2;2,3;2,4;2,5;2,6;2,7;2,8;2,9;2,10;3,1;3,2;3,3;3,4;3,5;3,6;3,7;3,8;3,9;4,1;4,2;4,3;4,4;4,6;4,7;4,8;4,9;4,10],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t],[4,10]));
+assert_checkequal(SPC == SPC, sparse([1,1;1,2;1,3;1,4;1,5;1,6;1,7;1,8;1,9;1,10;2,1;2,2;2,3;2,4;2,5;2,6;2,7;2,8;2,9;2,10;3,1;3,2;3,3;3,4;3,5;3,6;3,7;3,8;3,9;3,10;4,1;4,2;4,3;4,4;4,5;4,6;4,7;4,8;4,9;4,10],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t],[4,10]));
+assert_checkequal(SPC == SP1, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == SPC1, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == i8, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == I8, %f);
+assert_checkequal(SPC == ui8, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == UI8, %f);
+assert_checkequal(SPC == i16, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == I16, %f);
+assert_checkequal(SPC == ui16, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == UI16, %f);
+assert_checkequal(SPC == i32, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == I32, %f);
+assert_checkequal(SPC == ui32, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC == UI32, %f);
+assert_checkequal(SPC == str, %f);
+assert_checkequal(SPC == STR, %f);
+assert_checkequal(SPC == b, %f);
+assert_checkequal(SPC == B, %f);
+assert_checkequal(SPC == SPB, %f);
+assert_checkequal(SP1 == empty, %f);
+assert_checkequal(SP1 == r, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == c, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == R, %f);
+assert_checkequal(SP1 == C, %f);
+assert_checkequal(SP1 == e, %f);
+assert_checkequal(SP1 == ec, %f);
+assert_checkequal(SP1 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP1 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SP1 == SP1, sparse([1,1],%t,[1,1]));
+assert_checkequal(SP1 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == i8, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == I8, %f);
+assert_checkequal(SP1 == ui8, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == UI8, %f);
+assert_checkequal(SP1 == i16, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == I16, %f);
+assert_checkequal(SP1 == ui16, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == UI16, %f);
+assert_checkequal(SP1 == i32, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == I32, %f);
+assert_checkequal(SP1 == ui32, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SP1 == UI32, %f);
+assert_checkequal(SP1 == str, %f);
+assert_checkequal(SP1 == STR, %f);
+assert_checkequal(SP1 == b, %f);
+assert_checkequal(SP1 == B, %f);
+assert_checkequal(SP1 == SPB, %f);
+assert_checkequal(SPC1 == empty, %f);
+assert_checkequal(SPC1 == r, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == c, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == R, %f);
+assert_checkequal(SPC1 == C, %f);
+assert_checkequal(SPC1 == e, %f);
+assert_checkequal(SPC1 == ec, %f);
+assert_checkequal(SPC1 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC1 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(SPC1 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == SPC1, sparse([1,1],%t,[1,1]));
+assert_checkequal(SPC1 == i8, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == I8, %f);
+assert_checkequal(SPC1 == ui8, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == UI8, %f);
+assert_checkequal(SPC1 == i16, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == I16, %f);
+assert_checkequal(SPC1 == ui16, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == UI16, %f);
+assert_checkequal(SPC1 == i32, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == I32, %f);
+assert_checkequal(SPC1 == ui32, sparse([1,1],[%f],[1,1]));
+assert_checkequal(SPC1 == UI32, %f);
+assert_checkequal(SPC1 == str, %f);
+assert_checkequal(SPC1 == STR, %f);
+assert_checkequal(SPC1 == b, %f);
+assert_checkequal(SPC1 == B, %f);
+assert_checkequal(SPC1 == SPB, %f);
+assert_checkequal(i8 == empty, %f);
+assert_checkequal(i8 == r, %f);
+assert_checkequal(i8 == c, %f);
+assert_checkequal(i8 == R, [%f,%f;%f,%f]);
+assert_checkequal(i8 == C, [%f,%f;%f,%f]);
+assert_checkequal(i8 == e, %f);
+assert_checkequal(i8 == ec, %f);
+assert_checkequal(i8 == p, %f);
+assert_checkequal(i8 == pc, %f);
+assert_checkequal(i8 == P, [%f,%f;%f,%f]);
+assert_checkequal(i8 == PC, [%f,%f;%f,%f]);
+assert_checkequal(i8 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i8 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i8 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i8 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i8 == i8, %t);
+assert_checkequal(i8 == I8, [%t,%f;%f,%f]);
+assert_checkequal(i8 == ui8, %f);
+assert_checkequal(i8 == UI8, [%f,%f;%f,%f]);
+assert_checkequal(i8 == i16, %f);
+assert_checkequal(i8 == I16, [%f,%f;%f,%f]);
+assert_checkequal(i8 == ui16, %f);
+assert_checkequal(i8 == UI16, [%f,%f;%f,%f]);
+assert_checkequal(i8 == i32, %f);
+assert_checkequal(i8 == I32, [%f,%f;%f,%f]);
+assert_checkequal(i8 == ui32, %f);
+assert_checkequal(i8 == UI32, [%f,%f;%f,%f]);
+assert_checkequal(i8 == str, %f);
+assert_checkequal(i8 == STR, %f);
+assert_checkequal(i8 == b, %f);
+assert_checkequal(i8 == B, [%f,%f;%f,%f]);
+assert_checkequal(i8 == SPB, %f);
+assert_checkequal(I8 == empty, %f);
+assert_checkequal(I8 == r, [%f,%t;%f,%f]);
+assert_checkequal(I8 == c, [%f,%f;%f,%f]);
+assert_checkequal(I8 == R, [%f,%t;%f,%f]);
+assert_checkequal(I8 == C, [%f,%f;%f,%f]);
+assert_checkequal(I8 == e, [%f,%f;%f,%f]);
+assert_checkequal(I8 == ec, [%f,%f;%f,%f]);
+assert_checkequal(I8 == p, [%f,%f;%f,%f]);
+assert_checkequal(I8 == pc, [%f,%f;%f,%f]);
+assert_checkequal(I8 == P, [%f,%t;%f,%f]);
+assert_checkequal(I8 == PC, [%f,%t;%f,%f]);
+assert_checkequal(I8 == SP, %f);
+assert_checkequal(I8 == SPC, %f);
+assert_checkequal(I8 == SP1, %f);
+assert_checkequal(I8 == SPC1, %f);
+assert_checkequal(I8 == i8, [%t,%f;%f,%f]);
+assert_checkequal(I8 == I8, [%t,%t;%t,%t]);
+assert_checkequal(I8 == ui8, [%f,%f;%f,%f]);
+assert_checkequal(I8 == UI8, [%f,%t;%f,%f]);
+assert_checkequal(I8 == i16, [%f,%f;%f,%f]);
+assert_checkequal(I8 == I16, [%f,%t;%f,%f]);
+assert_checkequal(I8 == ui16, [%f,%f;%f,%f]);
+assert_checkequal(I8 == UI16, [%f,%t;%f,%f]);
+assert_checkequal(I8 == i32, [%f,%f;%f,%t]);
+assert_checkequal(I8 == I32, [%f,%t;%f,%f]);
+assert_checkequal(I8 == ui32, [%f,%f;%f,%f]);
+assert_checkequal(I8 == UI32, [%f,%t;%f,%f]);
+assert_checkequal(I8 == str, %f);
+assert_checkequal(I8 == STR, %f);
+assert_checkequal(I8 == b, [%f,%f;%f,%f]);
+assert_checkequal(I8 == B, [%f,%f;%f,%f]);
+assert_checkequal(I8 == SPB, %f);
+assert_checkequal(ui8 == empty, %f);
+assert_checkequal(ui8 == r, %f);
+assert_checkequal(ui8 == c, %f);
+assert_checkequal(ui8 == R, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == C, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == e, %f);
+assert_checkequal(ui8 == ec, %f);
+assert_checkequal(ui8 == p, %f);
+assert_checkequal(ui8 == pc, %f);
+assert_checkequal(ui8 == P, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == PC, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui8 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui8 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui8 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui8 == i8, %f);
+assert_checkequal(ui8 == I8, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == ui8, %t);
+assert_checkequal(ui8 == UI8, [%t,%f;%f,%f]);
+assert_checkequal(ui8 == i16, %f);
+assert_checkequal(ui8 == I16, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == ui16, %f);
+assert_checkequal(ui8 == UI16, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == i32, %f);
+assert_checkequal(ui8 == I32, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == ui32, %f);
+assert_checkequal(ui8 == UI32, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == str, %f);
+assert_checkequal(ui8 == STR, %f);
+assert_checkequal(ui8 == b, %f);
+assert_checkequal(ui8 == B, [%f,%f;%f,%f]);
+assert_checkequal(ui8 == SPB, %f);
+assert_checkequal(UI8 == empty, %f);
+assert_checkequal(UI8 == r, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == c, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == R, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == C, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == e, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == ec, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == p, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == pc, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == P, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == PC, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == SP, %f);
+assert_checkequal(UI8 == SPC, %f);
+assert_checkequal(UI8 == SP1, %f);
+assert_checkequal(UI8 == SPC1, %f);
+assert_checkequal(UI8 == i8, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == I8, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == ui8, [%t,%f;%f,%f]);
+assert_checkequal(UI8 == UI8, [%t,%t;%t,%t]);
+assert_checkequal(UI8 == i16, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == I16, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == ui16, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == UI16, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == i32, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == I32, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == ui32, [%f,%f;%f,%t]);
+assert_checkequal(UI8 == UI32, [%f,%t;%f,%f]);
+assert_checkequal(UI8 == str, %f);
+assert_checkequal(UI8 == STR, %f);
+assert_checkequal(UI8 == b, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == B, [%f,%f;%f,%f]);
+assert_checkequal(UI8 == SPB, %f);
+assert_checkequal(i16 == empty, %f);
+assert_checkequal(i16 == r, %f);
+assert_checkequal(i16 == c, %f);
+assert_checkequal(i16 == R, [%f,%f;%f,%f]);
+assert_checkequal(i16 == C, [%f,%f;%f,%f]);
+assert_checkequal(i16 == e, %f);
+assert_checkequal(i16 == ec, %f);
+assert_checkequal(i16 == p, %f);
+assert_checkequal(i16 == pc, %f);
+assert_checkequal(i16 == P, [%f,%f;%f,%f]);
+assert_checkequal(i16 == PC, [%f,%f;%f,%f]);
+assert_checkequal(i16 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i16 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i16 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i16 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i16 == i8, %f);
+assert_checkequal(i16 == I8, [%f,%f;%f,%f]);
+assert_checkequal(i16 == ui8, %f);
+assert_checkequal(i16 == UI8, [%f,%f;%f,%f]);
+assert_checkequal(i16 == i16, %t);
+assert_checkequal(i16 == I16, [%t,%f;%f,%f]);
+assert_checkequal(i16 == ui16, %f);
+assert_checkequal(i16 == UI16, [%f,%f;%f,%f]);
+assert_checkequal(i16 == i32, %f);
+assert_checkequal(i16 == I32, [%f,%f;%f,%f]);
+assert_checkequal(i16 == ui32, %f);
+assert_checkequal(i16 == UI32, [%f,%f;%f,%f]);
+assert_checkequal(i16 == str, %f);
+assert_checkequal(i16 == STR, %f);
+assert_checkequal(i16 == b, %f);
+assert_checkequal(i16 == B, [%f,%f;%f,%f]);
+assert_checkequal(i16 == SPB, %f);
+assert_checkequal(I16 == empty, %f);
+assert_checkequal(I16 == r, [%f,%t;%f,%f]);
+assert_checkequal(I16 == c, [%f,%f;%f,%f]);
+assert_checkequal(I16 == R, [%f,%t;%f,%f]);
+assert_checkequal(I16 == C, [%f,%f;%f,%f]);
+assert_checkequal(I16 == e, [%f,%f;%f,%f]);
+assert_checkequal(I16 == ec, [%f,%f;%f,%f]);
+assert_checkequal(I16 == p, [%f,%f;%f,%f]);
+assert_checkequal(I16 == pc, [%f,%f;%f,%f]);
+assert_checkequal(I16 == P, [%f,%t;%f,%f]);
+assert_checkequal(I16 == PC, [%f,%t;%f,%f]);
+assert_checkequal(I16 == SP, %f);
+assert_checkequal(I16 == SPC, %f);
+assert_checkequal(I16 == SP1, %f);
+assert_checkequal(I16 == SPC1, %f);
+assert_checkequal(I16 == i8, [%f,%f;%f,%f]);
+assert_checkequal(I16 == I8, [%f,%t;%f,%f]);
+assert_checkequal(I16 == ui8, [%f,%f;%f,%f]);
+assert_checkequal(I16 == UI8, [%f,%t;%f,%f]);
+assert_checkequal(I16 == i16, [%t,%f;%f,%f]);
+assert_checkequal(I16 == I16, [%t,%t;%t,%t]);
+assert_checkequal(I16 == ui16, [%f,%f;%f,%f]);
+assert_checkequal(I16 == UI16, [%f,%t;%f,%f]);
+assert_checkequal(I16 == i32, [%f,%f;%f,%f]);
+assert_checkequal(I16 == I32, [%f,%t;%f,%f]);
+assert_checkequal(I16 == ui32, [%f,%f;%f,%f]);
+assert_checkequal(I16 == UI32, [%f,%t;%f,%f]);
+assert_checkequal(I16 == str, %f);
+assert_checkequal(I16 == STR, %f);
+assert_checkequal(I16 == b, [%f,%f;%f,%f]);
+assert_checkequal(I16 == B, [%f,%f;%f,%f]);
+assert_checkequal(I16 == SPB, %f);
+assert_checkequal(ui16 == empty, %f);
+assert_checkequal(ui16 == r, %f);
+assert_checkequal(ui16 == c, %f);
+assert_checkequal(ui16 == R, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == C, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == e, %f);
+assert_checkequal(ui16 == ec, %f);
+assert_checkequal(ui16 == p, %f);
+assert_checkequal(ui16 == pc, %f);
+assert_checkequal(ui16 == P, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == PC, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui16 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui16 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui16 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui16 == i8, %f);
+assert_checkequal(ui16 == I8, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == ui8, %f);
+assert_checkequal(ui16 == UI8, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == i16, %f);
+assert_checkequal(ui16 == I16, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == ui16, %t);
+assert_checkequal(ui16 == UI16, [%t,%f;%f,%f]);
+assert_checkequal(ui16 == i32, %f);
+assert_checkequal(ui16 == I32, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == ui32, %f);
+assert_checkequal(ui16 == UI32, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == str, %f);
+assert_checkequal(ui16 == STR, %f);
+assert_checkequal(ui16 == b, %f);
+assert_checkequal(ui16 == B, [%f,%f;%f,%f]);
+assert_checkequal(ui16 == SPB, %f);
+assert_checkequal(UI16 == empty, %f);
+assert_checkequal(UI16 == r, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == c, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == R, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == C, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == e, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == ec, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == p, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == pc, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == P, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == PC, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == SP, %f);
+assert_checkequal(UI16 == SPC, %f);
+assert_checkequal(UI16 == SP1, %f);
+assert_checkequal(UI16 == SPC1, %f);
+assert_checkequal(UI16 == i8, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == I8, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == ui8, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == UI8, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == i16, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == I16, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == ui16, [%t,%f;%f,%f]);
+assert_checkequal(UI16 == UI16, [%t,%t;%t,%t]);
+assert_checkequal(UI16 == i32, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == I32, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == ui32, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == UI32, [%f,%t;%f,%f]);
+assert_checkequal(UI16 == str, %f);
+assert_checkequal(UI16 == STR, %f);
+assert_checkequal(UI16 == b, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == B, [%f,%f;%f,%f]);
+assert_checkequal(UI16 == SPB, %f);
+assert_checkequal(i32 == empty, %f);
+assert_checkequal(i32 == r, %f);
+assert_checkequal(i32 == c, %f);
+assert_checkequal(i32 == R, [%f,%f;%f,%f]);
+assert_checkequal(i32 == C, [%f,%f;%f,%f]);
+assert_checkequal(i32 == e, %f);
+assert_checkequal(i32 == ec, %f);
+assert_checkequal(i32 == p, %f);
+assert_checkequal(i32 == pc, %f);
+assert_checkequal(i32 == P, [%f,%f;%f,%f]);
+assert_checkequal(i32 == PC, [%f,%f;%f,%f]);
+assert_checkequal(i32 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i32 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(i32 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i32 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(i32 == i8, %f);
+assert_checkequal(i32 == I8, [%f,%f;%f,%t]);
+assert_checkequal(i32 == ui8, %f);
+assert_checkequal(i32 == UI8, [%f,%f;%f,%f]);
+assert_checkequal(i32 == i16, %f);
+assert_checkequal(i32 == I16, [%f,%f;%f,%f]);
+assert_checkequal(i32 == ui16, %f);
+assert_checkequal(i32 == UI16, [%f,%f;%f,%f]);
+assert_checkequal(i32 == i32, %t);
+assert_checkequal(i32 == I32, [%t,%f;%f,%f]);
+assert_checkequal(i32 == ui32, %f);
+assert_checkequal(i32 == UI32, [%f,%f;%f,%f]);
+assert_checkequal(i32 == str, %f);
+assert_checkequal(i32 == STR, %f);
+assert_checkequal(i32 == b, %f);
+assert_checkequal(i32 == B, [%f,%f;%f,%f]);
+assert_checkequal(i32 == SPB, %f);
+assert_checkequal(I32 == empty, %f);
+assert_checkequal(I32 == r, [%f,%t;%f,%f]);
+assert_checkequal(I32 == c, [%f,%f;%f,%f]);
+assert_checkequal(I32 == R, [%f,%t;%f,%f]);
+assert_checkequal(I32 == C, [%f,%f;%f,%f]);
+assert_checkequal(I32 == e, [%f,%f;%f,%f]);
+assert_checkequal(I32 == ec, [%f,%f;%f,%f]);
+assert_checkequal(I32 == p, [%f,%f;%f,%f]);
+assert_checkequal(I32 == pc, [%f,%f;%f,%f]);
+assert_checkequal(I32 == P, [%f,%t;%f,%f]);
+assert_checkequal(I32 == PC, [%f,%t;%f,%f]);
+assert_checkequal(I32 == SP, %f);
+assert_checkequal(I32 == SPC, %f);
+assert_checkequal(I32 == SP1, %f);
+assert_checkequal(I32 == SPC1, %f);
+assert_checkequal(I32 == i8, [%f,%f;%f,%f]);
+assert_checkequal(I32 == I8, [%f,%t;%f,%f]);
+assert_checkequal(I32 == ui8, [%f,%f;%f,%f]);
+assert_checkequal(I32 == UI8, [%f,%t;%f,%f]);
+assert_checkequal(I32 == i16, [%f,%f;%f,%f]);
+assert_checkequal(I32 == I16, [%f,%t;%f,%f]);
+assert_checkequal(I32 == ui16, [%f,%f;%f,%f]);
+assert_checkequal(I32 == UI16, [%f,%t;%f,%f]);
+assert_checkequal(I32 == i32, [%t,%f;%f,%f]);
+assert_checkequal(I32 == I32, [%t,%t;%t,%t]);
+assert_checkequal(I32 == ui32, [%f,%f;%f,%f]);
+assert_checkequal(I32 == UI32, [%f,%t;%f,%f]);
+assert_checkequal(I32 == str, %f);
+assert_checkequal(I32 == STR, %f);
+assert_checkequal(I32 == b, [%f,%f;%f,%f]);
+assert_checkequal(I32 == B, [%f,%f;%f,%f]);
+assert_checkequal(I32 == SPB, %f);
+assert_checkequal(ui32 == empty, %f);
+assert_checkequal(ui32 == r, %f);
+assert_checkequal(ui32 == c, %f);
+assert_checkequal(ui32 == R, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == C, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == e, %f);
+assert_checkequal(ui32 == ec, %f);
+assert_checkequal(ui32 == p, %f);
+assert_checkequal(ui32 == pc, %f);
+assert_checkequal(ui32 == P, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == PC, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui32 == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(ui32 == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui32 == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(ui32 == i8, %f);
+assert_checkequal(ui32 == I8, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == ui8, %f);
+assert_checkequal(ui32 == UI8, [%f,%f;%f,%t]);
+assert_checkequal(ui32 == i16, %f);
+assert_checkequal(ui32 == I16, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == ui16, %f);
+assert_checkequal(ui32 == UI16, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == i32, %f);
+assert_checkequal(ui32 == I32, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == ui32, %t);
+assert_checkequal(ui32 == UI32, [%t,%f;%f,%f]);
+assert_checkequal(ui32 == str, %f);
+assert_checkequal(ui32 == STR, %f);
+assert_checkequal(ui32 == b, %f);
+assert_checkequal(ui32 == B, [%f,%f;%f,%f]);
+assert_checkequal(ui32 == SPB, %f);
+assert_checkequal(UI32 == empty, %f);
+assert_checkequal(UI32 == r, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == c, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == R, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == C, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == e, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == ec, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == p, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == pc, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == P, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == PC, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == SP, %f);
+assert_checkequal(UI32 == SPC, %f);
+assert_checkequal(UI32 == SP1, %f);
+assert_checkequal(UI32 == SPC1, %f);
+assert_checkequal(UI32 == i8, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == I8, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == ui8, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == UI8, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == i16, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == I16, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == ui16, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == UI16, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == i32, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == I32, [%f,%t;%f,%f]);
+assert_checkequal(UI32 == ui32, [%t,%f;%f,%f]);
+assert_checkequal(UI32 == UI32, [%t,%t;%t,%t]);
+assert_checkequal(UI32 == str, %f);
+assert_checkequal(UI32 == STR, %f);
+assert_checkequal(UI32 == b, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == B, [%f,%f;%f,%f]);
+assert_checkequal(UI32 == SPB, %f);
+assert_checkequal(str == empty, %f);
+assert_checkequal(str == r, %f);
+assert_checkequal(str == c, %f);
+assert_checkequal(str == R, %f);
+assert_checkequal(str == C, %f);
+assert_checkequal(str == e, %f);
+assert_checkequal(str == ec, %f);
+assert_checkequal(str == p, %f);
+assert_checkequal(str == pc, %f);
+assert_checkequal(str == P, %f);
+assert_checkequal(str == PC, %f);
+assert_checkequal(str == SP, %f);
+assert_checkequal(str == SPC, %f);
+assert_checkequal(str == SP1, %f);
+assert_checkequal(str == SPC1, %f);
+assert_checkequal(str == i8, %f);
+assert_checkequal(str == I8, %f);
+assert_checkequal(str == ui8, %f);
+assert_checkequal(str == UI8, %f);
+assert_checkequal(str == i16, %f);
+assert_checkequal(str == I16, %f);
+assert_checkequal(str == ui16, %f);
+assert_checkequal(str == UI16, %f);
+assert_checkequal(str == i32, %f);
+assert_checkequal(str == I32, %f);
+assert_checkequal(str == ui32, %f);
+assert_checkequal(str == UI32, %f);
+assert_checkequal(str == str, %t);
+assert_checkequal(str == STR, [%f,%f;%f,%f]);
+assert_checkequal(str == b, %f);
+assert_checkequal(str == B, %f);
+assert_checkequal(str == SPB, %f);
+assert_checkequal(STR == empty, %f);
+assert_checkequal(STR == r, %f);
+assert_checkequal(STR == c, %f);
+assert_checkequal(STR == R, %f);
+assert_checkequal(STR == C, %f);
+assert_checkequal(STR == e, %f);
+assert_checkequal(STR == ec, %f);
+assert_checkequal(STR == p, %f);
+assert_checkequal(STR == pc, %f);
+assert_checkequal(STR == P, %f);
+assert_checkequal(STR == PC, %f);
+assert_checkequal(STR == SP, %f);
+assert_checkequal(STR == SPC, %f);
+assert_checkequal(STR == SP1, %f);
+assert_checkequal(STR == SPC1, %f);
+assert_checkequal(STR == i8, %f);
+assert_checkequal(STR == I8, %f);
+assert_checkequal(STR == ui8, %f);
+assert_checkequal(STR == UI8, %f);
+assert_checkequal(STR == i16, %f);
+assert_checkequal(STR == I16, %f);
+assert_checkequal(STR == ui16, %f);
+assert_checkequal(STR == UI16, %f);
+assert_checkequal(STR == i32, %f);
+assert_checkequal(STR == I32, %f);
+assert_checkequal(STR == ui32, %f);
+assert_checkequal(STR == UI32, %f);
+assert_checkequal(STR == str, [%f,%f;%f,%f]);
+assert_checkequal(STR == STR, [%t,%t;%t,%t]);
+assert_checkequal(STR == b, %f);
+assert_checkequal(STR == B, %f);
+assert_checkequal(STR == SPB, %f);
+assert_checkequal(b == empty, %f);
+assert_checkequal(b == r, %f);
+assert_checkequal(b == c, %f);
+assert_checkequal(b == R, %f);
+assert_checkequal(b == C, %f);
+assert_checkequal(b == e, %f);
+assert_checkequal(b == ec, %f);
+assert_checkequal(b == p, %f);
+assert_checkequal(b == pc, %f);
+assert_checkequal(b == P, %f);
+assert_checkequal(b == PC, %f);
+assert_checkequal(b == SP, %f);
+assert_checkequal(b == SPC, %f);
+assert_checkequal(b == SP1, %f);
+assert_checkequal(b == SPC1, %f);
+assert_checkequal(b == i8, %f);
+assert_checkequal(b == I8, [%f,%f;%f,%f]);
+assert_checkequal(b == ui8, %f);
+assert_checkequal(b == UI8, [%f,%f;%f,%f]);
+assert_checkequal(b == i16, %f);
+assert_checkequal(b == I16, [%f,%f;%f,%f]);
+assert_checkequal(b == ui16, %f);
+assert_checkequal(b == UI16, [%f,%f;%f,%f]);
+assert_checkequal(b == i32, %f);
+assert_checkequal(b == I32, [%f,%f;%f,%f]);
+assert_checkequal(b == ui32, %f);
+assert_checkequal(b == UI32, [%f,%f;%f,%f]);
+assert_checkequal(b == str, %f);
+assert_checkequal(b == STR, %f);
+assert_checkequal(b == b, %t);
+assert_checkequal(b == B, [%f,%t;%t,%f]);
+assert_checkequal(b == SPB, sparse([1,1;2,2],[%t;%t],[2,2]));
+assert_checkequal(B == empty, %f);
+assert_checkequal(B == r, %f);
+assert_checkequal(B == c, %f);
+assert_checkequal(B == R, %f);
+assert_checkequal(B == C, %f);
+assert_checkequal(B == e, %f);
+assert_checkequal(B == ec, %f);
+assert_checkequal(B == p, %f);
+assert_checkequal(B == pc, %f);
+assert_checkequal(B == P, %f);
+assert_checkequal(B == PC, %f);
+assert_checkequal(B == SP, %f);
+assert_checkequal(B == SPC, %f);
+assert_checkequal(B == SP1, %f);
+assert_checkequal(B == SPC1, %f);
+assert_checkequal(B == i8, [%f,%f;%f,%f]);
+assert_checkequal(B == I8, [%f,%f;%f,%f]);
+assert_checkequal(B == ui8, [%f,%f;%f,%f]);
+assert_checkequal(B == UI8, [%f,%f;%f,%f]);
+assert_checkequal(B == i16, [%f,%f;%f,%f]);
+assert_checkequal(B == I16, [%f,%f;%f,%f]);
+assert_checkequal(B == ui16, [%f,%f;%f,%f]);
+assert_checkequal(B == UI16, [%f,%f;%f,%f]);
+assert_checkequal(B == i32, [%f,%f;%f,%f]);
+assert_checkequal(B == I32, [%f,%f;%f,%f]);
+assert_checkequal(B == ui32, [%f,%f;%f,%f]);
+assert_checkequal(B == UI32, [%f,%f;%f,%f]);
+assert_checkequal(B == str, %f);
+assert_checkequal(B == STR, %f);
+assert_checkequal(B == b, [%f,%t;%t,%f]);
+assert_checkequal(B == B, [%t,%t;%t,%t]);
+assert_checkequal(B == SPB, sparse([1,1],[%f],[2,2]));
+assert_checkequal(SPB == empty, %f);
+assert_checkequal(SPB == r, %f);
+assert_checkequal(SPB == c, %f);
+assert_checkequal(SPB == R, %f);
+assert_checkequal(SPB == C, %f);
+assert_checkequal(SPB == e, %f);
+assert_checkequal(SPB == ec, %f);
+assert_checkequal(SPB == SP, %f);
+assert_checkequal(SPB == SPC, %f);
+assert_checkequal(SPB == SP1, %f);
+assert_checkequal(SPB == SPC1, %f);
+assert_checkequal(SPB == i8, %f);
+assert_checkequal(SPB == I8, %f);
+assert_checkequal(SPB == ui8, %f);
+assert_checkequal(SPB == UI8, %f);
+assert_checkequal(SPB == i16, %f);
+assert_checkequal(SPB == I16, %f);
+assert_checkequal(SPB == ui16, %f);
+assert_checkequal(SPB == UI16, %f);
+assert_checkequal(SPB == i32, %f);
+assert_checkequal(SPB == I32, %f);
+assert_checkequal(SPB == ui32, %f);
+assert_checkequal(SPB == UI32, %f);
+assert_checkequal(SPB == str, %f);
+assert_checkequal(SPB == STR, %f);
+assert_checkequal(SPB == b, sparse([1,1;2,2],[%t;%t],[2,2]));
+assert_checkequal(SPB == B, sparse([1,1],[%f],[2,2]));
+assert_checkequal(SPB == SPB, sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,2]));
diff --git a/scilab/modules/ast/tests/unit_tests/comparisonequal.tst b/scilab/modules/ast/tests/unit_tests/comparisonequal.tst
new file mode 100644 (file)
index 0000000..0e4eb50
--- /dev/null
@@ -0,0 +1,1072 @@
+// ============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2014 - Scilab Enterprises - Sylvain GENIN
+//
+//  This file is distributed under the same license as the Scilab package.
+// ============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+s = %s;
+
+empty = [];
+
+r = 2;
+R = [1,2;3,4];
+R3(:,:,1) = R;
+R3(:,:,2) = R';
+c = 1 + 2*%i;
+C = [1+2*%i,2+4*%i;3+6*%i,4+8*%i];
+C3(:,:,1) = C;
+C3(:,:,2) = C';
+
+e = eye();
+ec = (5+%i) * eye();
+
+p = 1 + %s - %s**2;
+pc = 1 + %s - %s**2 + ( 2 - 3 * %s + 4 * %s**2 ) * %i;
+P = [2*p, 2;4*p,-5*p];
+PC = [2*pc, 2;4*pc,-5*pc];
+
+SP = sparse([1,2;4,5;3,10],[1,2,3]);
+SPC = sparse([1,2;4,5;3,10],[1,2,3]) * ( 1 + 4*%i);
+SPB = sparse([1,2;2,1],[%t;%t],[2,2]);
+SP1 = sparse([1,1],[10]);
+SPC1 = sparse([1,1],[1]) * ( 2 + 6*%i);
+
+i8 = int8(-8);
+ui8 = uint8(8);
+I8 = int8([-8 2 ; -24 -32]);
+UI8 = uint8([8 2 ; 24 32]);
+
+I16 = int16([-16 2 ; -48 -64]);
+UI16 = uint16([16 2 ; 48 64]);
+i16 = int16(-16);
+ui16 = uint16(16);
+
+i32 = int32(-32);
+ui32 = uint32(32);
+I32 = int32([-32 2 ; -96 -128]);
+UI32 = uint32([32 2 ; 96 128]);
+
+str = "string";
+STR = ["string1" "string2";"string3" "string4"];
+
+b = %f;
+B = [%t %f;%f %t];
+
+assert_checkequal(empty == empty, %t);
+assert_checkequal(empty == r, %f);
+assert_checkequal(empty == c, %f);
+assert_checkequal(empty == R, %f);
+assert_checkequal(empty == C, %f);
+assert_checkequal(empty == e, %f);
+assert_checkequal(empty == ec, %f);
+assert_checkequal(empty == p, %f);
+assert_checkequal(empty == pc, %f);
+assert_checkequal(empty == P, %f);
+assert_checkequal(empty == PC, %f);
+assert_checkequal(empty == SP, %f);
+assert_checkequal(empty == SPC, %f);
+assert_checkequal(empty == SP1, %f);
+assert_checkequal(empty == SPC1, %f);
+assert_checkequal(empty == i8, %f);
+assert_checkequal(empty == I8, %f);
+assert_checkequal(empty == ui8, %f);
+assert_checkequal(empty == UI8, %f);
+assert_checkequal(empty == i16, %f);
+assert_checkequal(empty == I16, %f);
+assert_checkequal(empty == ui16, %f);
+assert_checkequal(empty == UI16, %f);
+assert_checkequal(empty == i32, %f);
+assert_checkequal(empty == I32, %f);
+assert_checkequal(empty == ui32, %f);
+assert_checkequal(empty == UI32, %f);
+assert_checkequal(empty == str, %f);
+assert_checkequal(empty == STR, %f);
+assert_checkequal(empty == b, %f);
+assert_checkequal(empty == B, %f);
+assert_checkequal(empty == SPB, %f);
+
+assert_checkequal(r == empty, %f);
+assert_checkequal(r == r, %t);
+assert_checkequal(r == c, %f);
+assert_checkequal(r == R, [%f,%t;%f,%f]);
+assert_checkequal(r == C, [%f,%f;%f,%f]);
+assert_checkequal(r == e, %f);
+assert_checkequal(r == ec, %f);
+assert_checkequal(r == p, %f);
+assert_checkequal(r == pc, %f);
+assert_checkequal(r == P, [%f,%t;%f,%f]);
+assert_checkequal(r == PC, [%f,%t;%f,%f]);
+assert_checkequal(r == SP, sparse([4,5],%t,[4,10]));
+assert_checkequal(r == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(r == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(r == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(r == i8, %f);
+assert_checkequal(r == I8, [%f,%t;%f,%f]);
+assert_checkequal(r == ui8, %f);
+assert_checkequal(r == UI8, [%f,%t;%f,%f]);
+assert_checkequal(r == i16, %f);
+assert_checkequal(r == I16, [%f,%t;%f,%f]);
+assert_checkequal(r == ui16, %f);
+assert_checkequal(r == UI16, [%f,%t;%f,%f]);
+assert_checkequal(r == i32, %f);
+assert_checkequal(r == I32, [%f,%t;%f,%f]);
+assert_checkequal(r == ui32, %f);
+assert_checkequal(r == UI32, [%f,%t;%f,%f]);
+assert_checkequal(r == str, %f);
+assert_checkequal(r == STR, %f);
+assert_checkequal(r == b, %f);
+assert_checkequal(r == B, %f);
+assert_checkequal(r == SPB, %f);
+
+assert_checkequal(c == empty, %f);
+assert_checkequal(c == r, %f);
+assert_checkequal(c == c, %t);
+assert_checkequal(c == R, [%f,%f;%f,%f]);
+assert_checkequal(c == C, [%t,%f;%f,%f]);
+assert_checkequal(c == e, %f);
+assert_checkequal(c == ec, %f);
+assert_checkequal(c == p, %f);
+assert_checkequal(c == pc, %f);
+assert_checkequal(c == P, [%f,%f;%f,%f]);
+assert_checkequal(c == PC, [%f,%f;%f,%f]);
+assert_checkequal(c == SP, sparse([1,1],[%f],[4,10]));
+assert_checkequal(c == SPC, sparse([1,1],[%f],[4,10]));
+assert_checkequal(c == SP1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(c == SPC1, sparse([1,1],[%f],[1,1]));
+assert_checkequal(c == i8, %f);
+assert_checkequal(c == I8, [%f,%f;%f,%f]);
+assert_checkequal(c == ui8, %f);
+assert_checkequal(c == UI8, [%f,%f;%f,%f]);
+assert_checkequal(c == i16, %f);
+assert_checkequal(c == I16, [%f,%f;%f,%f]);
+assert_checkequal(c == ui16, %f);
+assert_checkequal(c == UI16, [%f,%f;%f,%f]);
+assert_checkequal(c == i32, %f);
+assert_checkequal(c == I32, [%f,%f;%f,%f]);
+assert_checkequal(c == ui32, %f);
+assert_checkequal(c == UI32, [%f,%f;%f,%f]);
+assert_checkequal(c == str, %f);
+assert_checkequal(c == STR, %f);
+assert_checkequal(c == b, %f);
+assert_checkequal(c == B, %f);
+assert_checkequal(c == SPB, %f);
+
+assert_checkequal(R == empty, %f);
+assert_checkequal(R == r, [%f,%t;%f,%f]);
+assert_checkequal(R == c, [%f,%f;%f,%f]);
+assert_checkequal(R == R, [%t,%t;%t,%t]);
+assert_checkequal(R == C, [%f,%f;%f,%f]);