dot divide 98/15198/16
Sylvain GENIN [Wed, 10 Sep 2014 12:49:58 +0000 (14:49 +0200)]
test_run("ast","dotdivide",["no_check_error_output" ]);

Change-Id: I53385b1b28fb9dae5f05da2be4d6f5e31149390e

13 files changed:
scilab/modules/ast/Makefile.am
scilab/modules/ast/Makefile.in
scilab/modules/ast/ast.vcxproj
scilab/modules/ast/ast.vcxproj.filters
scilab/modules/ast/includes/operations/types_dotdivide.hxx [new file with mode: 0644]
scilab/modules/ast/includes/types/sparse.hxx
scilab/modules/ast/src/cpp/operations/operations.cpp
scilab/modules/ast/src/cpp/operations/types_divide.cpp
scilab/modules/ast/src/cpp/operations/types_dotdivide.cpp [new file with mode: 0644]
scilab/modules/ast/src/cpp/operations/types_ldivide.cpp
scilab/modules/ast/src/cpp/types/sparse.cpp
scilab/modules/ast/tests/unit_tests/dotdivide.dia.ref [new file with mode: 0644]
scilab/modules/ast/tests/unit_tests/dotdivide.tst [new file with mode: 0644]

index 0cd825c..6f21794 100644 (file)
@@ -31,6 +31,7 @@ libsciast_la_SOURCES = \
     src/cpp/operations/types_comparison_eq.cpp \
     src/cpp/operations/types_multiplication.cpp \
     src/cpp/operations/types_dotmultiplication.cpp \
+    src/cpp/operations/types_dotdivide.cpp \
     src/cpp/operations/types_comparison_lt_le_gt_ge.cpp \
     src/cpp/operations/types_or.cpp \
     src/cpp/operations/types_and.cpp \
index 0fc69bf..32aed34 100644 (file)
@@ -175,6 +175,7 @@ am__libsciast_la_SOURCES_DIST = src/cpp/ast/runvisitor.cpp \
        src/cpp/operations/types_comparison_eq.cpp \
        src/cpp/operations/types_multiplication.cpp \
        src/cpp/operations/types_dotmultiplication.cpp \
+       src/cpp/operations/types_dotdivide.cpp \
        src/cpp/operations/types_comparison_lt_le_gt_ge.cpp \
        src/cpp/operations/types_or.cpp \
        src/cpp/operations/types_and.cpp \
@@ -247,6 +248,7 @@ am_libsciast_la_OBJECTS = src/cpp/ast/libsciast_la-runvisitor.lo \
        src/cpp/operations/libsciast_la-types_comparison_eq.lo \
        src/cpp/operations/libsciast_la-types_multiplication.lo \
        src/cpp/operations/libsciast_la-types_dotmultiplication.lo \
+       src/cpp/operations/libsciast_la-types_dotdivide.lo \
        src/cpp/operations/libsciast_la-types_comparison_lt_le_gt_ge.lo \
        src/cpp/operations/libsciast_la-types_or.lo \
        src/cpp/operations/libsciast_la-types_and.lo \
@@ -706,6 +708,7 @@ libsciast_la_SOURCES = src/cpp/ast/runvisitor.cpp \
        src/cpp/operations/types_comparison_eq.cpp \
        src/cpp/operations/types_multiplication.cpp \
        src/cpp/operations/types_dotmultiplication.cpp \
+       src/cpp/operations/types_dotdivide.cpp \
        src/cpp/operations/types_comparison_lt_le_gt_ge.cpp \
        src/cpp/operations/types_or.cpp \
        src/cpp/operations/types_and.cpp \
@@ -1179,6 +1182,9 @@ src/cpp/operations/libsciast_la-types_multiplication.lo:  \
 src/cpp/operations/libsciast_la-types_dotmultiplication.lo:  \
        src/cpp/operations/$(am__dirstamp) \
        src/cpp/operations/$(DEPDIR)/$(am__dirstamp)
+src/cpp/operations/libsciast_la-types_dotdivide.lo:  \
+       src/cpp/operations/$(am__dirstamp) \
+       src/cpp/operations/$(DEPDIR)/$(am__dirstamp)
 src/cpp/operations/libsciast_la-types_comparison_lt_le_gt_ge.lo:  \
        src/cpp/operations/$(am__dirstamp) \
        src/cpp/operations/$(DEPDIR)/$(am__dirstamp)
@@ -1455,6 +1461,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_comparison_lt_le_gt_ge.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_comparison_ne.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_divide.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_dotdivide.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_dotmultiplication.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_finite.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@src/cpp/operations/$(DEPDIR)/libsciast_la-types_kronecker.Plo@am__quote@
@@ -1757,6 +1764,13 @@ src/cpp/operations/libsciast_la-types_dotmultiplication.lo: src/cpp/operations/t
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o src/cpp/operations/libsciast_la-types_dotmultiplication.lo `test -f 'src/cpp/operations/types_dotmultiplication.cpp' || echo '$(srcdir)/'`src/cpp/operations/types_dotmultiplication.cpp
 
+src/cpp/operations/libsciast_la-types_dotdivide.lo: src/cpp/operations/types_dotdivide.cpp
+@am__fastdepCXX_TRUE@  $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT src/cpp/operations/libsciast_la-types_dotdivide.lo -MD -MP -MF src/cpp/operations/$(DEPDIR)/libsciast_la-types_dotdivide.Tpo -c -o src/cpp/operations/libsciast_la-types_dotdivide.lo `test -f 'src/cpp/operations/types_dotdivide.cpp' || echo '$(srcdir)/'`src/cpp/operations/types_dotdivide.cpp
+@am__fastdepCXX_TRUE@  $(AM_V_at)$(am__mv) src/cpp/operations/$(DEPDIR)/libsciast_la-types_dotdivide.Tpo src/cpp/operations/$(DEPDIR)/libsciast_la-types_dotdivide.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@     $(AM_V_CXX)source='src/cpp/operations/types_dotdivide.cpp' object='src/cpp/operations/libsciast_la-types_dotdivide.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@     DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o src/cpp/operations/libsciast_la-types_dotdivide.lo `test -f 'src/cpp/operations/types_dotdivide.cpp' || echo '$(srcdir)/'`src/cpp/operations/types_dotdivide.cpp
+
 src/cpp/operations/libsciast_la-types_comparison_lt_le_gt_ge.lo: src/cpp/operations/types_comparison_lt_le_gt_ge.cpp
 @am__fastdepCXX_TRUE@  $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libsciast_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT src/cpp/operations/libsciast_la-types_comparison_lt_le_gt_ge.lo -MD -MP -MF src/cpp/operations/$(DEPDIR)/libsciast_la-types_comparison_lt_le_gt_ge.Tpo -c -o src/cpp/operations/libsciast_la-types_comparison_lt_le_gt_ge.lo `test -f 'src/cpp/operations/types_comparison_lt_le_gt_ge.cpp' || echo '$(srcdir)/'`src/cpp/operations/types_comparison_lt_le_gt_ge.cpp
 @am__fastdepCXX_TRUE@  $(AM_V_at)$(am__mv) src/cpp/operations/$(DEPDIR)/libsciast_la-types_comparison_lt_le_gt_ge.Tpo src/cpp/operations/$(DEPDIR)/libsciast_la-types_comparison_lt_le_gt_ge.Plo
index e4bebc8..ff2ee9a 100644 (file)
@@ -336,6 +336,7 @@ lib /DEF:"$(ProjectDir)fileio_import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Platform
     <ClInclude Include="includes\operations\types_comparison_lt_le_gt_ge.hxx" />
     <ClInclude Include="includes\operations\types_comparison_ne.hxx" />
     <ClInclude Include="includes\operations\types_divide.hxx" />
+    <ClInclude Include="includes\operations\types_dotdivide.hxx" />
     <ClInclude Include="includes\operations\types_dotmultiplication.hxx" />
     <ClInclude Include="includes\operations\types_finite.hxx" />
     <ClInclude Include="includes\operations\types_kronecker.hxx" />
@@ -437,6 +438,7 @@ lib /DEF:"$(ProjectDir)fileio_import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Platform
     <ClCompile Include="src\cpp\operations\types_comparison_lt_le_gt_ge.cpp" />
     <ClCompile Include="src\cpp\operations\types_comparison_ne.cpp" />
     <ClCompile Include="src\cpp\operations\types_divide.cpp" />
+    <ClCompile Include="src\cpp\operations\types_dotdivide.cpp" />
     <ClCompile Include="src\cpp\operations\types_dotmultiplication.cpp" />
     <ClCompile Include="src\cpp\operations\types_finite.cpp" />
     <ClCompile Include="src\cpp\operations\types_kronecker.cpp" />
index b38bd1d..52baf67 100644 (file)
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Library Include="..\..\bin\blasplus.lib" />
     <ClInclude Include="includes\analysis\TIType.hxx">
       <Filter>Header Files\analysis</Filter>
     </ClInclude>
+    <ClInclude Include="includes\operations\types_dotdivide.hxx">
+      <Filter>Header Files\operations</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\cpp\ast\debugvisitor.cpp">
     <ClCompile Include="src\cpp\operations\types_or.cpp">
       <Filter>Source Files\operations</Filter>
     </ClCompile>
+    <ClCompile Include="src\cpp\operations\types_dotdivide.cpp">
+      <Filter>Source Files\operations</Filter>
+    </ClCompile>
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/scilab/modules/ast/includes/operations/types_dotdivide.hxx b/scilab/modules/ast/includes/operations/types_dotdivide.hxx
new file mode 100644 (file)
index 0000000..263fef5
--- /dev/null
@@ -0,0 +1,236 @@
+/*
+*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2014 - 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_DOTDIVIDE_HXX__
+#define __TYPES_DOTDIVIDE_HXX__
+
+#include "generic_operations.hxx"
+#include "double.hxx"
+#include "polynom.hxx"
+#include "sparse.hxx"
+
+void fillDotDivFunction();
+
+//define arrays on operation functions
+typedef types::InternalType*(*dotdiv_function)(types::InternalType*, types::InternalType*);
+
+#define DECLARE_DOTDIV_PROTO(x) template<class T, class U, class O> types::InternalType* x(T *_pL, U *_pR)
+
+DECLARE_DOTDIV_PROTO(dotdiv_M_M);
+DECLARE_DOTDIV_PROTO(dotdiv_M_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_M_S);
+DECLARE_DOTDIV_PROTO(dotdiv_M_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_M_E);
+DECLARE_DOTDIV_PROTO(dotdiv_M_I);
+DECLARE_DOTDIV_PROTO(dotdiv_M_IC);
+
+DECLARE_DOTDIV_PROTO(dotdiv_MC_M);
+DECLARE_DOTDIV_PROTO(dotdiv_MC_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_MC_S);
+DECLARE_DOTDIV_PROTO(dotdiv_MC_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_MC_I);
+DECLARE_DOTDIV_PROTO(dotdiv_MC_IC);
+
+DECLARE_DOTDIV_PROTO(dotdiv_S_M);
+DECLARE_DOTDIV_PROTO(dotdiv_S_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_S_S);
+DECLARE_DOTDIV_PROTO(dotdiv_S_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_S_I);
+DECLARE_DOTDIV_PROTO(dotdiv_S_IC);
+
+DECLARE_DOTDIV_PROTO(dotdiv_SC_M);
+DECLARE_DOTDIV_PROTO(dotdiv_SC_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_SC_S);
+DECLARE_DOTDIV_PROTO(dotdiv_SC_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_SC_I);
+DECLARE_DOTDIV_PROTO(dotdiv_SC_IC);
+
+//[]
+DECLARE_DOTDIV_PROTO(dotdiv_E_M);
+
+//eye
+DECLARE_DOTDIV_PROTO(dotdiv_I_M);
+DECLARE_DOTDIV_PROTO(dotdiv_I_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_I_S);
+DECLARE_DOTDIV_PROTO(dotdiv_I_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_I_I);
+DECLARE_DOTDIV_PROTO(dotdiv_I_IC);
+
+DECLARE_DOTDIV_PROTO(dotdiv_IC_M);
+DECLARE_DOTDIV_PROTO(dotdiv_IC_MC);
+DECLARE_DOTDIV_PROTO(dotdiv_IC_S);
+DECLARE_DOTDIV_PROTO(dotdiv_IC_SC);
+DECLARE_DOTDIV_PROTO(dotdiv_IC_I);
+DECLARE_DOTDIV_PROTO(dotdiv_IC_IC);
+
+#undef DECLARE_DOTDIV_PROTO
+
+template<> types::InternalType* dotdiv_M_M<types::Sparse, types::Sparse, types::Sparse>(types::Sparse* _pL, types::Sparse* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Double, types::Sparse, types::Double>(types::Double* _pL, types::Sparse* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Sparse, types::Double, types::Double>(types::Sparse* _pL, types::Double* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Double, types::Sparse, types::Sparse>(types::Double* _pL, types::Sparse* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Sparse, types::Double, types::Sparse>(types::Sparse* _pL, types::Double* _pR);
+
+template<> types::InternalType* dotdiv_M_M<types::Polynom, types::Polynom, types::Polynom>(types::Polynom* _pL, types::Polynom* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Polynom, types::Double, types::Polynom>(types::Polynom* _pL, types::Double* _pR);
+template<> types::InternalType* dotdiv_M_M<types::Double, types::Polynom, types::Polynom>(types::Double* _pL, types::Polynom* _pR);
+
+//x ./ x
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l[i] / (O)r[i];
+    }
+}
+
+//xC ./ x
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, T* lc, size_t size, U* r, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l[i] / (O)r[i];
+        oc[i] = (O)lc[i] / (O)r[i];
+    }
+}
+
+//x ./ xC
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, size_t size, U* r, U* rc, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = ((O)l[i] * (O)r[i]) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+        oc[i] = ((O)l[i] * -(O)rc[i]) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+    }
+}
+
+//xC ./ xC
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, T* lc, size_t size, U* r, U* rc, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] =  ((O)l[i] * (O)r[i] + (O)lc[i] * (O)rc[i] ) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+        oc[i] = ((O)r[i] * (O)lc[i] - (O)rc[i] * (O)l[i] ) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+    }
+}
+
+//x1 ./ x1
+template<typename T, typename U, typename O> inline static void dotdiv(T l, U r, O* o)
+{
+    *o = (O)l / (O)r;
+}
+
+//x1 ./ x1c
+template<typename T, typename U, typename O> inline static void dotdiv(T l, size_t size, U r, U rc, O* o, O* oc)
+{
+    *o  = ((O)l * (O)r) / ((O)rc * (O)rc + (O)r * (O)r) ;
+    *oc = ((O)l * -(O)rc) / ((O)rc * (O)rc + (O)r * (O)r) ;
+}
+
+//x1c ./ x1
+template<typename T, typename U, typename O> inline static void dotdiv(T l, T lc, size_t size, U r, O* o, O* oc)
+{
+    *o = (O)l / (O)r;
+    *oc = (O)lc / (O)r;
+}
+
+//x1c ./ x1c
+template<typename T, typename U, typename O> inline static void dotdiv(T l, T lc, size_t size, U r, U rc, O* o, O* oc)
+{
+    *o  = ((O)l * (O)r + (O)lc * (O)rc ) / ((O)rc * (O)rc + (O)r * (O)r);
+    *oc = ((O)r * (O)lc - (O)rc * (O)l ) / ((O)rc * (O)rc + (O)r * (O)r) ;
+}
+
+//x ./ x1
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, size_t size, U r, O* o)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l[i] / (O)r;
+    }
+}
+
+//x1 ./ x
+template<typename T, typename U, typename O> inline static void dotdiv(T l, size_t size, U* r, O* o)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l / (O)r[i];
+    }
+}
+
+
+//x ./ x1c
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, size_t size, U r, U rc, O* o, O* oc)
+{
+    O denum = ((O)rc * (O)rc + (O)r * (O)r);
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = ((O)l[i] * (O)r) / denum ;
+        oc[i] = ((O)l[i] * -(O)rc) / denum;
+    }
+}
+
+//x1 ./ xc
+template<typename T, typename U, typename O> inline static void dotdiv(T l, size_t size, U* r, U* rc, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = ((O)l * (O)r[i]) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+        oc[i] = ((O)l * -(O)rc[i]) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+    }
+}
+
+//xC ./ x1
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, T* lc, size_t size, U r, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l[i] / (O)r;
+        oc[i] = (O)lc[i] / (O)r;
+    }
+}
+
+//x1C ./ x
+template<typename T, typename U, typename O> inline static void dotdiv(T l, T lc, size_t size, U* r, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] = (O)l / (O)r[i];
+        oc[i] = (O)lc / (O)r[i];
+    }
+}
+
+
+//xC ./ x1c
+template<typename T, typename U, typename O> inline static void dotdiv(T* l, T* lc, size_t size, U r, U rc, O* o, O* oc)
+{
+    O denum = ((O)rc * (O)rc + (O)r * (O)r);
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] =  ((O)l[i] * (O)r + (O)lc[i] * (O)rc ) / denum ;
+        oc[i] = ((O)r * (O)lc[i] - (O)rc * (O)l[i] ) / denum ;
+    }
+}
+
+//x1C ./ xc
+template<typename T, typename U, typename O> inline static void dotdiv(T l, T lc, size_t size, U* r, U* rc, O* o, O* oc)
+{
+    for (size_t i = 0; i < size ; ++i)
+    {
+        o[i] =  ((O)l * (O)r[i] + (O)lc * (O)rc[i] ) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+        oc[i] = ((O)r[i] * (O)lc - (O)rc[i] * (O)l ) / ((O)rc[i] * (O)rc[i] + (O)r[i] * (O)r[i]) ;
+    }
+}
+
+
+#endif /* !__TYPES_DOTDIVIDE_HXX__ */
\ No newline at end of file
index dc69794..5b18058 100644 (file)
@@ -331,6 +331,12 @@ struct EXTERN_AST Sparse : GenericType
      */
     Sparse* dotMultiply(Sparse SPARSE_CONST& o) const;
 
+    /* create a new matrix containing the result of an ./
+      @param o sparse matrix to ./
+      @return ptr to the new matrix, 0 in case of failure
+    */
+    Sparse* dotDivide(Sparse SPARSE_CONST& o) const;
+
     bool neg(InternalType *& out);
 
     bool transpose(InternalType *& out)
index fe742dc..0c15fe1 100644 (file)
@@ -6,6 +6,7 @@
 #include "types_subtraction.hxx"
 #include "types_opposite.hxx"
 #include "types_dotmultiplication.hxx"
+#include "types_dotdivide.hxx"
 #include "types_and.hxx"
 #include "types_or.hxx"
 
@@ -15,6 +16,7 @@ void initOperationArray()
     fillOppositeFunction();
     fillSubtractFunction();
     fillDotMulFunction();
+    fillDotDivFunction();
     fillAndFunction();
     fillOrFunction();
 }
index 6089ef8..80a4739 100644 (file)
@@ -107,78 +107,6 @@ InternalType *GenericRDivide(InternalType *_pLeftOperand, InternalType *_pRightO
     return pResult;
 }
 
-InternalType *GenericDotRDivide(InternalType *_pLeftOperand, InternalType *_pRightOperand)
-{
-    InternalType *pResult       = NULL;
-    GenericType::ScilabType TypeL = _pLeftOperand->getType();
-    GenericType::ScilabType TypeR = _pRightOperand->getType();
-
-    int iResult = 0;
-
-    if (_pLeftOperand->isDouble() && _pLeftOperand->getAs<Double>()->isEmpty())
-    {
-        return Double::Empty();
-    }
-
-    if (_pRightOperand->isDouble() && _pRightOperand->getAs<Double>()->isEmpty())
-    {
-        return Double::Empty();
-    }
-
-    /*
-    ** DOUBLE ./ DOUBLE
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabDouble)
-    {
-        Double *pL  = _pLeftOperand->getAs<Double>();
-        Double *pR  = _pRightOperand->getAs<Double>();
-
-        iResult = DotRDivideDoubleByDouble(pL, pR, (Double**)&pResult);
-    }
-
-    if (TypeL == GenericType::ScilabPolynom && TypeR == GenericType::ScilabDouble)
-    {
-        Polynom *pL = _pLeftOperand->getAs<Polynom>();
-        Double *pR  = _pRightOperand->getAs<Double>();
-
-        // ou exclusif
-        if (pL->isScalar() ^ pR->isScalar())
-        {
-            // call overload
-            return NULL;
-        }
-
-        iResult = DotRDividePolyByDouble(pL, pR, (Polynom**)&pResult);
-    }
-
-    //manage errors
-    if (iResult)
-    {
-        switch (iResult)
-        {
-            case 1 :
-                throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
-            case 2 :
-                throw ast::ScilabError(_W("With NaN or Inf a division by scalar expected.\n"));
-            case 3 :
-                throw ast::ScilabError(_W("Division by zero...\n"));
-            case 4 :
-                if (getWarningMode())
-                {
-                    sciprint(_("Warning : Division by zero...\n"));
-                }
-                break;
-                //            default : throw ast::ScilabError(_W("Operator / : Error %d not yet managed.\n"), iResult);
-            default :
-                sciprint(_("Operator ./ : Error %d not yet managed.\n"), iResult);
-        }
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    return pResult;
-}
 
 int RDivideDoubleByDouble(Double *_pDouble1, Double *_pDouble2, Double **_pDoubleOut)
 {
diff --git a/scilab/modules/ast/src/cpp/operations/types_dotdivide.cpp b/scilab/modules/ast/src/cpp/operations/types_dotdivide.cpp
new file mode 100644 (file)
index 0000000..9b4cb3d
--- /dev/null
@@ -0,0 +1,1787 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
+ *  Copyright (C) 2014 - 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_dotdivide.hxx"
+#include "scilabexception.hxx"
+#include "double.hxx"
+#include "int.hxx"
+#include "sparse.hxx"
+#include "polynom.hxx"
+
+
+extern "C"
+{
+#include "localization.h"
+}
+
+using namespace types;
+//define arrays on operation functions
+static dotdiv_function pDotDivfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
+
+void fillDotDivFunction()
+{
+#define scilab_fill_dotdiv(id1, id2, func, typeIn1, typeIn2, typeOut) \
+    pDotDivfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (dotdiv_function)&dotdiv_##func<typeIn1, typeIn2, typeOut>
+
+    //Double
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Double, Double, M_M, Double, Double, Double);
+    scilab_fill_dotdiv(Double, Int8, M_M, Double, Int8, Int8);
+    scilab_fill_dotdiv(Double, UInt8, M_M, Double, UInt8, UInt8);
+    scilab_fill_dotdiv(Double, Int16, M_M, Double, Int16, Int16);
+    scilab_fill_dotdiv(Double, UInt16, M_M, Double, UInt16, UInt16);
+    scilab_fill_dotdiv(Double, Int32, M_M, Double, Int32, Int32);
+    scilab_fill_dotdiv(Double, UInt32, M_M, Double, UInt32, UInt32);
+    scilab_fill_dotdiv(Double, Int64, M_M, Double, Int64, Int64);
+    scilab_fill_dotdiv(Double, UInt64, M_M, Double, UInt64, UInt64);
+    scilab_fill_dotdiv(Double, Bool, M_M, Double, Bool, Double);
+    scilab_fill_dotdiv(Double, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(Double, Sparse, M_M, Double, Sparse, Sparse);
+
+    //Matrix ./ Matrix Complex
+    scilab_fill_dotdiv(Double, DoubleComplex, M_MC, Double, Double, Double);
+    scilab_fill_dotdiv(Double, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(Double, SparseComplex, M_M, Double, Sparse, Sparse);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Double, ScalarDouble, M_S, Double, Double, Double);
+    scilab_fill_dotdiv(Double, ScalarInt8, M_S, Double, Int8, Int8);
+    scilab_fill_dotdiv(Double, ScalarUInt8, M_S, Double, UInt8, UInt8);
+    scilab_fill_dotdiv(Double, ScalarInt16, M_S, Double, Int16, Int16);
+    scilab_fill_dotdiv(Double, ScalarUInt16, M_S, Double, UInt16, UInt16);
+    scilab_fill_dotdiv(Double, ScalarInt32, M_S, Double, Int32, Int32);
+    scilab_fill_dotdiv(Double, ScalarUInt32, M_S, Double, UInt32, UInt32);
+    scilab_fill_dotdiv(Double, ScalarInt64, M_S, Double, Int64, Int64);
+    scilab_fill_dotdiv(Double, ScalarUInt64, M_S, Double, UInt64, UInt64);
+    scilab_fill_dotdiv(Double, ScalarBool, M_S, Double, Bool, Double);
+    scilab_fill_dotdiv(Double, ScalarPolynom, M_M, Double, Polynom, Polynom);
+
+    //Matrix ./ Scalar Complex
+    scilab_fill_dotdiv(Double, ScalarDoubleComplex, M_SC, Double, Double, Double);
+    scilab_fill_dotdiv(Double, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+    //Matrix ./ Empty
+    scilab_fill_dotdiv(Double, Empty, M_E, Double, Double, Double);
+
+
+    //Matrix Complex ./ Matrix
+    scilab_fill_dotdiv(DoubleComplex, Double, MC_M, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, ScalarDouble, MC_S, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, Empty, M_E, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(DoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(DoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(DoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(DoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
+    scilab_fill_dotdiv(DoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarDouble, Double, S_M, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, Int8, S_M, Double, Int8, Int8);
+    scilab_fill_dotdiv(ScalarDouble, UInt8, S_M, Double, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarDouble, Int16, S_M, Double, Int16, Int16);
+    scilab_fill_dotdiv(ScalarDouble, UInt16, S_M, Double, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarDouble, Int32, S_M, Double, Int32, Int32);
+    scilab_fill_dotdiv(ScalarDouble, UInt32, S_M, Double, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarDouble, Int64, S_M, Double, Int64, Int64);
+    scilab_fill_dotdiv(ScalarDouble, UInt64, S_M, Double, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarDouble, Bool, S_M, Double, Bool, Double);
+    scilab_fill_dotdiv(ScalarDouble, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarDouble, Sparse, M_M, Double, Sparse, Sparse);
+
+    //Scalar ./ Matrix Complex
+    scilab_fill_dotdiv(ScalarDouble, DoubleComplex, S_MC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarDouble, SparseComplex, M_M, Double, Sparse, Sparse);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarDouble, ScalarDouble, S_S, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, ScalarInt8, S_S, Double, Int8, Int8);
+    scilab_fill_dotdiv(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarDouble, ScalarInt16, S_S, Double, Int16, Int16);
+    scilab_fill_dotdiv(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarDouble, ScalarInt32, S_S, Double, Int32, Int32);
+    scilab_fill_dotdiv(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarDouble, ScalarInt64, S_S, Double, Int64, Int64);
+    scilab_fill_dotdiv(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarDouble, ScalarBool, S_S, Double, Bool, Double);
+    scilab_fill_dotdiv(ScalarDouble, ScalarPolynom, M_M, Double, Polynom, Polynom);
+
+    //Scalar ./ Scalar Complex
+    scilab_fill_dotdiv(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarDouble, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+
+    //Scalar ./ Empty
+    scilab_fill_dotdiv(ScalarDouble, Empty, M_E, Double, Double, Double);
+
+    //Scalar Complex ./ Matrix
+    scilab_fill_dotdiv(ScalarDoubleComplex, Double, SC_M, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarDoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
+    //Scalar Complex ./ Matrix Complex
+    scilab_fill_dotdiv(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarDoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
+    //Scalar Complex ./ Scalar
+    scilab_fill_dotdiv(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
+    //Scalar Complex ./ Scalar Complex
+    scilab_fill_dotdiv(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+    //Scalar Complex ./ Empty
+    scilab_fill_dotdiv(ScalarDoubleComplex, Empty, M_E, Double, Double, Double);
+
+    //Empty ./ Matrix
+    scilab_fill_dotdiv(Empty, Double, E_M, Double, Double, Double);
+    scilab_fill_dotdiv(Empty, Int8, E_M, Double, Int8, Double);
+    scilab_fill_dotdiv(Empty, UInt8, E_M, Double, UInt8, Double);
+    scilab_fill_dotdiv(Empty, Int16, E_M, Double, Int16, Double);
+    scilab_fill_dotdiv(Empty, UInt16, E_M, Double, UInt16, Double);
+    scilab_fill_dotdiv(Empty, Int32, E_M, Double, Int32, Double);
+    scilab_fill_dotdiv(Empty, UInt32, E_M, Double, UInt32, Double);
+    scilab_fill_dotdiv(Empty, Int64, E_M, Double, Int64, Double);
+    scilab_fill_dotdiv(Empty, UInt64, E_M, Double, UInt64, Double);
+    scilab_fill_dotdiv(Empty, Polynom, E_M, Double, Polynom, Double);
+    scilab_fill_dotdiv(Empty, PolynomComplex, E_M, Double, Polynom, Double);
+    scilab_fill_dotdiv(Empty, Sparse, E_M, Double, Sparse, Double);
+    scilab_fill_dotdiv(Empty, SparseComplex, E_M, Double, Sparse, Double);
+
+    //Empty ./ Matrix Complex
+    scilab_fill_dotdiv(Empty, DoubleComplex, E_M, Double, Double, Double);
+    //Empty ./ Scalar
+    scilab_fill_dotdiv(Empty, ScalarDouble, E_M, Double, Double, Double);
+    scilab_fill_dotdiv(Empty, ScalarInt8, E_M, Double, Int8, Double);
+    scilab_fill_dotdiv(Empty, ScalarUInt8, E_M, Double, UInt8, Double);
+    scilab_fill_dotdiv(Empty, ScalarInt16, E_M, Double, Int16, Double);
+    scilab_fill_dotdiv(Empty, ScalarUInt16, E_M, Double, UInt16, Double);
+    scilab_fill_dotdiv(Empty, ScalarInt32, E_M, Double, Int32, Double);
+    scilab_fill_dotdiv(Empty, ScalarUInt32, E_M, Double, UInt32, Double);
+    scilab_fill_dotdiv(Empty, ScalarInt64, E_M, Double, Int64, Double);
+    scilab_fill_dotdiv(Empty, ScalarUInt64, E_M, Double, UInt64, Double);
+    scilab_fill_dotdiv(Empty, ScalarBool, E_M, Double, Bool, Double);
+    scilab_fill_dotdiv(Empty, ScalarPolynom, E_M, Double, Polynom, Double);
+
+    //Empty ./ Scalar Complex
+    scilab_fill_dotdiv(Empty, ScalarDoubleComplex, E_M, Double, Double, Double);
+    scilab_fill_dotdiv(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Double);
+    //Empty ./ Empty
+    scilab_fill_dotdiv(Empty, Empty, E_M, Double, Double, Double);
+    //Empty ./ eye
+    scilab_fill_dotdiv(Empty, Identity, E_M, Double, Double, Double);
+    scilab_fill_dotdiv(Empty, IdentityComplex, E_M, Double, Double, Double);
+
+    //Matrix ./ Identity
+    scilab_fill_dotdiv(Double, Identity, M_I, Double, Double, Double);
+    scilab_fill_dotdiv(Double, IdentityComplex, M_IC, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, Identity, MC_I, Double, Double, Double);
+    scilab_fill_dotdiv(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, Identity, S_I, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDouble, IdentityComplex, S_IC, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, Identity, SC_I, Double, Double, Double);
+    scilab_fill_dotdiv(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Double);
+
+    //Int8
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Int8, Double, M_M, Int8, Double, Int8);
+    scilab_fill_dotdiv(Int8, Int8, M_M, Int8, Int8, Int8);
+    scilab_fill_dotdiv(Int8, UInt8, M_M, Int8, UInt8, UInt8);
+    scilab_fill_dotdiv(Int8, Int16, M_M, Int8, Int16, Int16);
+    scilab_fill_dotdiv(Int8, UInt16, M_M, Int8, UInt16, UInt16);
+    scilab_fill_dotdiv(Int8, Int32, M_M, Int8, Int32, Int32);
+    scilab_fill_dotdiv(Int8, UInt32, M_M, Int8, UInt32, UInt32);
+    scilab_fill_dotdiv(Int8, Int64, M_M, Int8, Int64, Int64);
+    scilab_fill_dotdiv(Int8, UInt64, M_M, Int8, UInt64, UInt64);
+    scilab_fill_dotdiv(Int8, Bool, M_M, Int8, Bool, Int8);
+    scilab_fill_dotdiv(Int8, Empty, M_E, Int8, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Int8, ScalarDouble, M_S, Int8, Double, Int8);
+    scilab_fill_dotdiv(Int8, ScalarInt8, M_S, Int8, Int8, Int8);
+    scilab_fill_dotdiv(Int8, ScalarUInt8, M_S, Int8, UInt8, UInt8);
+    scilab_fill_dotdiv(Int8, ScalarInt16, M_S, Int8, Int16, Int16);
+    scilab_fill_dotdiv(Int8, ScalarUInt16, M_S, Int8, UInt16, UInt16);
+    scilab_fill_dotdiv(Int8, ScalarInt32, M_S, Int8, Int32, Int32);
+    scilab_fill_dotdiv(Int8, ScalarUInt32, M_S, Int8, UInt32, UInt32);
+    scilab_fill_dotdiv(Int8, ScalarInt64, M_S, Int8, Int64, Int64);
+    scilab_fill_dotdiv(Int8, ScalarUInt64, M_S, Int8, UInt64, UInt64);
+    scilab_fill_dotdiv(Int8, ScalarBool, M_S, Int8, Bool, Int8);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarInt8, Double, S_M, Int8, Double, Int8);
+    scilab_fill_dotdiv(ScalarInt8, Int8, S_M, Int8, Int8, Int8);
+    scilab_fill_dotdiv(ScalarInt8, UInt8, S_M, Int8, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarInt8, Int16, S_M, Int8, Int16, Int16);
+    scilab_fill_dotdiv(ScalarInt8, UInt16, S_M, Int8, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarInt8, Int32, S_M, Int8, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt8, UInt32, S_M, Int8, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt8, Int64, S_M, Int8, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt8, UInt64, S_M, Int8, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt8, Bool, S_M, Int8, Bool, Int8);
+    scilab_fill_dotdiv(ScalarInt8, Empty, M_E, Int8, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarInt8, ScalarDouble, S_S, Int8, Double, Int8);
+    scilab_fill_dotdiv(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Int8);
+    scilab_fill_dotdiv(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Int16);
+    scilab_fill_dotdiv(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt8, ScalarBool, S_S, Int8, Bool, Int8);
+
+    //UInt8
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(UInt8, Double, M_M, UInt8, Double, UInt8);
+    scilab_fill_dotdiv(UInt8, Int8, M_M, UInt8, Int8, UInt8);
+    scilab_fill_dotdiv(UInt8, UInt8, M_M, UInt8, UInt8, UInt8);
+    scilab_fill_dotdiv(UInt8, Int16, M_M, UInt8, Int16, UInt16);
+    scilab_fill_dotdiv(UInt8, UInt16, M_M, UInt8, UInt16, UInt16);
+    scilab_fill_dotdiv(UInt8, Int32, M_M, UInt8, Int32, UInt32);
+    scilab_fill_dotdiv(UInt8, UInt32, M_M, UInt8, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt8, Int64, M_M, UInt8, Int64, UInt64);
+    scilab_fill_dotdiv(UInt8, UInt64, M_M, UInt8, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt8, Bool, M_M, UInt8, Bool, UInt8);
+    scilab_fill_dotdiv(UInt8, Empty, M_E, UInt8, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(UInt8, ScalarDouble, M_S, UInt8, Double, UInt8);
+    scilab_fill_dotdiv(UInt8, ScalarInt8, M_S, UInt8, Int8, UInt8);
+    scilab_fill_dotdiv(UInt8, ScalarUInt8, M_S, UInt8, UInt8, UInt8);
+    scilab_fill_dotdiv(UInt8, ScalarInt16, M_S, UInt8, Int16, UInt16);
+    scilab_fill_dotdiv(UInt8, ScalarUInt16, M_S, UInt8, UInt16, UInt16);
+    scilab_fill_dotdiv(UInt8, ScalarInt32, M_S, UInt8, Int32, UInt32);
+    scilab_fill_dotdiv(UInt8, ScalarUInt32, M_S, UInt8, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt8, ScalarInt64, M_S, UInt8, Int64, UInt64);
+    scilab_fill_dotdiv(UInt8, ScalarUInt64, M_S, UInt8, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt8, ScalarBool, M_S, UInt8, Bool, UInt8);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarUInt8, Double, S_M, UInt8, Double, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, Int8, S_M, UInt8, Int8, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, UInt8, S_M, UInt8, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, Int16, S_M, UInt8, Int16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt8, UInt16, S_M, UInt8, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt8, Int32, S_M, UInt8, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt8, UInt32, S_M, UInt8, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt8, Int64, S_M, UInt8, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt8, UInt64, S_M, UInt8, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt8, Bool, S_M, UInt8, Bool, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, Empty, M_E, UInt8, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt8, ScalarBool, S_S, UInt8, Bool, UInt8);
+
+    //Int16
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Int16, Double, M_M, Int16, Double, Int16);
+    scilab_fill_dotdiv(Int16, Int8, M_M, Int16, Int8, Int16);
+    scilab_fill_dotdiv(Int16, UInt8, M_M, Int16, UInt8, UInt16);
+    scilab_fill_dotdiv(Int16, Int16, M_M, Int16, Int16, Int16);
+    scilab_fill_dotdiv(Int16, UInt16, M_M, Int16, UInt16, UInt16);
+    scilab_fill_dotdiv(Int16, Int32, M_M, Int16, Int32, Int32);
+    scilab_fill_dotdiv(Int16, UInt32, M_M, Int16, UInt32, UInt32);
+    scilab_fill_dotdiv(Int16, Int64, M_M, Int16, Int64, Int64);
+    scilab_fill_dotdiv(Int16, UInt64, M_M, Int16, UInt64, UInt64);
+    scilab_fill_dotdiv(Int16, Bool, M_M, Int16, Bool, Int16);
+    scilab_fill_dotdiv(Int16, Empty, M_E, Int16, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Int16, ScalarDouble, M_S, Int16, Double, Int16);
+    scilab_fill_dotdiv(Int16, ScalarInt8, M_S, Int16, Int8, Int16);
+    scilab_fill_dotdiv(Int16, ScalarUInt8, M_S, Int16, UInt8, UInt16);
+    scilab_fill_dotdiv(Int16, ScalarInt16, M_S, Int16, Int16, Int16);
+    scilab_fill_dotdiv(Int16, ScalarUInt16, M_S, Int16, UInt16, UInt16);
+    scilab_fill_dotdiv(Int16, ScalarInt32, M_S, Int16, Int32, Int32);
+    scilab_fill_dotdiv(Int16, ScalarUInt32, M_S, Int16, UInt32, UInt32);
+    scilab_fill_dotdiv(Int16, ScalarInt64, M_S, Int16, Int64, Int64);
+    scilab_fill_dotdiv(Int16, ScalarUInt64, M_S, Int16, UInt64, UInt64);
+    scilab_fill_dotdiv(Int16, ScalarBool, M_E, Int16, Bool, Int16);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarInt16, Double, S_M, Int16, Double, Int16);
+    scilab_fill_dotdiv(ScalarInt16, Int8, S_M, Int16, Int8, Int16);
+    scilab_fill_dotdiv(ScalarInt16, UInt8, S_M, Int16, UInt8, UInt16);
+    scilab_fill_dotdiv(ScalarInt16, Int16, S_M, Int16, Int16, Int16);
+    scilab_fill_dotdiv(ScalarInt16, UInt16, S_M, Int16, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarInt16, Int32, S_M, Int16, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt16, UInt32, S_M, Int16, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt16, Int64, S_M, Int16, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt16, UInt64, S_M, Int16, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt16, Bool, S_M, Int16, Bool, Int16);
+    scilab_fill_dotdiv(ScalarInt16, Empty, M_E, Int16, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarInt16, ScalarDouble, S_S, Int16, Double, Int16);
+    scilab_fill_dotdiv(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Int16);
+    scilab_fill_dotdiv(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, UInt16);
+    scilab_fill_dotdiv(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Int16);
+    scilab_fill_dotdiv(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt16, ScalarBool, S_S, Int16, Bool, Int16);
+
+    //UInt16
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(UInt16, Double, M_M, UInt16, Double, UInt16);
+    scilab_fill_dotdiv(UInt16, Int8, M_M, UInt16, Int8, UInt16);
+    scilab_fill_dotdiv(UInt16, UInt8, M_M, UInt16, UInt8, UInt16);
+    scilab_fill_dotdiv(UInt16, Int16, M_M, UInt16, Int16, UInt16);
+    scilab_fill_dotdiv(UInt16, UInt16, M_M, UInt16, UInt16, UInt16);
+    scilab_fill_dotdiv(UInt16, Int32, M_M, UInt16, Int32, UInt32);
+    scilab_fill_dotdiv(UInt16, UInt32, M_M, UInt16, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt16, Int64, M_M, UInt16, Int64, UInt64);
+    scilab_fill_dotdiv(UInt16, UInt64, M_M, UInt16, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt16, Bool, M_M, UInt16, Bool, UInt16);
+    scilab_fill_dotdiv(UInt16, Empty, M_E, UInt16, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(UInt16, ScalarDouble, M_S, UInt16, Double, UInt16);
+    scilab_fill_dotdiv(UInt16, ScalarInt8, M_S, UInt16, Int8, UInt16);
+    scilab_fill_dotdiv(UInt16, ScalarUInt8, M_S, UInt16, UInt8, UInt16);
+    scilab_fill_dotdiv(UInt16, ScalarInt16, M_S, UInt16, Int16, UInt16);
+    scilab_fill_dotdiv(UInt16, ScalarUInt16, M_S, UInt16, UInt16, UInt16);
+    scilab_fill_dotdiv(UInt16, ScalarInt32, M_S, UInt16, Int32, UInt32);
+    scilab_fill_dotdiv(UInt16, ScalarUInt32, M_S, UInt16, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt16, ScalarInt64, M_S, UInt16, Int64, UInt64);
+    scilab_fill_dotdiv(UInt16, ScalarUInt64, M_S, UInt16, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt16, ScalarBool, M_S, UInt16, Bool, UInt16);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarUInt16, Double, S_M, UInt16, Double, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, Int8, S_M, UInt16, Int8, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, UInt8, S_M, UInt16, UInt8, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, Int16, S_M, UInt16, Int16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, UInt16, S_M, UInt16, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, Int32, S_M, UInt16, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt16, UInt32, S_M, UInt16, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt16, Int64, S_M, UInt16, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt16, UInt64, S_M, UInt16, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt16, Bool, S_M, UInt16, Bool, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, Empty, S_M, UInt16, Double, UInt16);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt16, ScalarBool, S_S, UInt16, Bool, UInt16);
+
+    //Int32
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Int32, Double, M_M, Int32, Double, Int32);
+    scilab_fill_dotdiv(Int32, Int8, M_M, Int32, Int8, Int32);
+    scilab_fill_dotdiv(Int32, UInt8, M_M, Int32, UInt8, UInt32);
+    scilab_fill_dotdiv(Int32, Int16, M_M, Int32, Int16, Int32);
+    scilab_fill_dotdiv(Int32, UInt16, M_M, Int32, UInt16, UInt32);
+    scilab_fill_dotdiv(Int32, Int32, M_M, Int32, Int32, Int32);
+    scilab_fill_dotdiv(Int32, UInt32, M_M, Int32, UInt32, UInt32);
+    scilab_fill_dotdiv(Int32, Int64, M_M, Int32, Int64, Int64);
+    scilab_fill_dotdiv(Int32, UInt64, M_M, Int32, UInt64, UInt64);
+    scilab_fill_dotdiv(Int32, Bool, M_M, Int32, Bool, Int32);
+    scilab_fill_dotdiv(Int32, Empty, M_E, Int32, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Int32, ScalarDouble, M_S, Int32, Double, Int32);
+    scilab_fill_dotdiv(Int32, ScalarInt8, M_S, Int32, Int8, Int32);
+    scilab_fill_dotdiv(Int32, ScalarUInt8, M_S, Int32, UInt8, UInt32);
+    scilab_fill_dotdiv(Int32, ScalarInt16, M_S, Int32, Int16, Int32);
+    scilab_fill_dotdiv(Int32, ScalarUInt16, M_S, Int32, UInt16, UInt32);
+    scilab_fill_dotdiv(Int32, ScalarInt32, M_S, Int32, Int32, Int32);
+    scilab_fill_dotdiv(Int32, ScalarUInt32, M_S, Int32, UInt32, UInt32);
+    scilab_fill_dotdiv(Int32, ScalarInt64, M_S, Int32, Int64, Int64);
+    scilab_fill_dotdiv(Int32, ScalarUInt64, M_S, Int32, UInt64, UInt64);
+    scilab_fill_dotdiv(Int32, ScalarBool, M_S, Int32, Bool, Int32);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarInt32, Double, S_M, Int32, Double, Int32);
+    scilab_fill_dotdiv(ScalarInt32, Int8, S_M, Int32, Int8, Int32);
+    scilab_fill_dotdiv(ScalarInt32, UInt8, S_M, Int32, UInt8, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, Int16, S_M, Int32, Int16, Int32);
+    scilab_fill_dotdiv(ScalarInt32, UInt16, S_M, Int32, UInt16, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, Int32, S_M, Int32, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt32, UInt32, S_M, Int32, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, Int64, S_M, Int32, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt32, UInt64, S_M, Int32, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt32, Bool, S_M, Int32, Bool, Int32);
+    scilab_fill_dotdiv(ScalarInt32, Empty, M_E, Int32, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarInt32, ScalarDouble, S_S, Int32, Double, Int32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Int32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Int32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Int32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt32, ScalarBool, S_S, Int32, Bool, Int32);
+
+    //UInt32
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(UInt32, Double, M_M, UInt32, Double, UInt32);
+    scilab_fill_dotdiv(UInt32, Int8, M_M, UInt32, Int8, UInt32);
+    scilab_fill_dotdiv(UInt32, UInt8, M_M, UInt32, UInt8, UInt32);
+    scilab_fill_dotdiv(UInt32, Int16, M_M, UInt32, Int16, UInt32);
+    scilab_fill_dotdiv(UInt32, UInt16, M_M, UInt32, UInt16, UInt32);
+    scilab_fill_dotdiv(UInt32, Int32, M_M, UInt32, Int32, UInt32);
+    scilab_fill_dotdiv(UInt32, UInt32, M_M, UInt32, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt32, Int64, M_M, UInt32, Int64, UInt64);
+    scilab_fill_dotdiv(UInt32, UInt64, M_M, UInt32, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt32, Bool, M_M, UInt32, Bool, UInt32);
+    scilab_fill_dotdiv(UInt32, Empty, M_E, UInt32, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(UInt32, ScalarDouble, M_S, UInt32, Double, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarInt8, M_S, UInt32, Int8, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarUInt8, M_S, UInt32, UInt8, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarInt16, M_S, UInt32, Int16, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarUInt16, M_S, UInt32, UInt16, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarInt32, M_S, UInt32, Int32, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarUInt32, M_S, UInt32, UInt32, UInt32);
+    scilab_fill_dotdiv(UInt32, ScalarInt64, M_S, UInt32, Int64, UInt64);
+    scilab_fill_dotdiv(UInt32, ScalarUInt64, M_S, UInt32, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt32, ScalarBool, M_S, UInt32, Bool, UInt32);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarUInt32, Double, S_M, UInt32, Double, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, Int8, S_M, UInt32, Int8, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, UInt8, S_M, UInt32, UInt8, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, Int16, S_M, UInt32, Int16, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, UInt16, S_M, UInt32, UInt16, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, Int32, S_M, UInt32, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, UInt32, S_M, UInt32, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, Int64, S_M, UInt32, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt32, UInt64, S_M, UInt32, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt32, Bool, S_M, UInt32, Bool, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, Empty, S_M, UInt32, Double, UInt32);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt32, ScalarBool, S_S, UInt32, Bool, UInt32);
+
+    //Int64
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Int64, Double, M_M, Int64, Double, Int64);
+    scilab_fill_dotdiv(Int64, Int8, M_M, Int64, Int8, Int64);
+    scilab_fill_dotdiv(Int64, UInt8, M_M, Int64, UInt8, UInt64);
+    scilab_fill_dotdiv(Int64, Int16, M_M, Int64, Int16, Int64);
+    scilab_fill_dotdiv(Int64, UInt16, M_M, Int64, UInt16, UInt64);
+    scilab_fill_dotdiv(Int64, Int32, M_M, Int64, Int32, Int64);
+    scilab_fill_dotdiv(Int64, UInt32, M_M, Int64, UInt32, UInt64);
+    scilab_fill_dotdiv(Int64, Int64, M_M, Int64, Int64, Int64);
+    scilab_fill_dotdiv(Int64, UInt64, M_M, Int64, UInt64, UInt64);
+    scilab_fill_dotdiv(Int64, Bool, M_M, Int64, Bool, Int64);
+    scilab_fill_dotdiv(Int64, Empty, M_E, Int64, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Int64, ScalarDouble, M_S, Int64, Double, Int64);
+    scilab_fill_dotdiv(Int64, ScalarInt8, M_S, Int64, Int8, Int64);
+    scilab_fill_dotdiv(Int64, ScalarUInt8, M_S, Int64, UInt8, UInt64);
+    scilab_fill_dotdiv(Int64, ScalarInt16, M_S, Int64, Int16, Int64);
+    scilab_fill_dotdiv(Int64, ScalarUInt16, M_S, Int64, UInt16, UInt64);
+    scilab_fill_dotdiv(Int64, ScalarInt32, M_S, Int64, Int32, Int64);
+    scilab_fill_dotdiv(Int64, ScalarUInt32, M_S, Int64, UInt32, UInt64);
+    scilab_fill_dotdiv(Int64, ScalarInt64, M_S, Int64, Int64, Int64);
+    scilab_fill_dotdiv(Int64, ScalarUInt64, M_S, Int64, UInt64, UInt64);
+    scilab_fill_dotdiv(Int64, ScalarBool, M_S, Int64, Bool, Int64);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarInt64, Double, S_M, Int64, Double, Int64);
+    scilab_fill_dotdiv(ScalarInt64, Int8, S_M, Int64, Int8, Int64);
+    scilab_fill_dotdiv(ScalarInt64, UInt8, S_M, Int64, UInt8, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, Int16, S_M, Int64, Int16, Int64);
+    scilab_fill_dotdiv(ScalarInt64, UInt16, S_M, Int64, UInt16, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, Int32, S_M, Int64, Int32, Int64);
+    scilab_fill_dotdiv(ScalarInt64, UInt32, S_M, Int64, UInt32, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, Int64, S_M, Int64, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt64, UInt64, S_M, Int64, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, Bool, S_M, Int64, Bool, Int64);
+    scilab_fill_dotdiv(ScalarInt64, Empty, M_E, Int64, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarInt64, ScalarDouble, S_S, Int64, Double, Int64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Int64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Int64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Int64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Int64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarInt64, ScalarBool, S_S, Int64, Bool, Int64);
+
+    //UInt64
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(UInt64, Double, M_M, UInt64, Double, UInt64);
+    scilab_fill_dotdiv(UInt64, Int8, M_M, UInt64, Int8, UInt64);
+    scilab_fill_dotdiv(UInt64, UInt8, M_M, UInt64, UInt8, UInt64);
+    scilab_fill_dotdiv(UInt64, Int16, M_M, UInt64, Int16, UInt64);
+    scilab_fill_dotdiv(UInt64, UInt16, M_M, UInt64, UInt16, UInt64);
+    scilab_fill_dotdiv(UInt64, Int32, M_M, UInt64, Int32, UInt64);
+    scilab_fill_dotdiv(UInt64, UInt32, M_M, UInt64, UInt32, UInt64);
+    scilab_fill_dotdiv(UInt64, Int64, M_M, UInt64, Int64, UInt64);
+    scilab_fill_dotdiv(UInt64, UInt64, M_M, UInt64, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt64, Bool, M_M, UInt64, Bool, UInt64);
+    scilab_fill_dotdiv(UInt64, Empty, M_E, UInt64, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(UInt64, ScalarDouble, M_S, UInt64, Double, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarInt8, M_S, UInt64, Int8, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarUInt8, M_S, UInt64, UInt8, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarInt16, M_S, UInt64, Int16, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarUInt16, M_S, UInt64, UInt16, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarInt32, M_S, UInt64, Int32, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarUInt32, M_S, UInt64, UInt32, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarInt64, M_S, UInt64, Int64, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarUInt64, M_S, UInt64, UInt64, UInt64);
+    scilab_fill_dotdiv(UInt64, ScalarBool, M_S, UInt64, Bool, UInt64);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarUInt64, Double, S_M, UInt64, Double, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Int8, S_M, UInt64, Int8, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, UInt8, S_M, UInt64, UInt8, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Int16, S_M, UInt64, Int16, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, UInt16, S_M, UInt64, UInt16, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Int32, S_M, UInt64, Int32, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, UInt32, S_M, UInt64, UInt32, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Int64, S_M, UInt64, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, UInt64, S_M, UInt64, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Bool, S_M, UInt64, Bool, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, Empty, S_M, UInt64, Double, UInt64);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarUInt64, ScalarBool, S_S, UInt64, Bool, UInt64);
+
+    //Bool
+    //Matrix ./ Matrix
+    scilab_fill_dotdiv(Bool, Double, M_M, Bool, Double, Double);
+    scilab_fill_dotdiv(Bool, Int8, M_M, Bool, Int8, Int8);
+    scilab_fill_dotdiv(Bool, UInt8, M_M, Bool, UInt8, UInt8);
+    scilab_fill_dotdiv(Bool, Int16, M_M, Bool, Int16, Int16);
+    scilab_fill_dotdiv(Bool, UInt16, M_M, Bool, UInt16, UInt16);
+    scilab_fill_dotdiv(Bool, Int32, M_M, Bool, Int32, Int32);
+    scilab_fill_dotdiv(Bool, UInt32, M_M, Bool, UInt32, UInt32);
+    scilab_fill_dotdiv(Bool, Int64, M_M, Bool, Int64, Int64);
+    scilab_fill_dotdiv(Bool, UInt64, M_M, Bool, UInt64, UInt64);
+    scilab_fill_dotdiv(Bool, Bool, M_M, Bool, Bool, Bool);
+    scilab_fill_dotdiv(Bool, Empty, M_E, Bool, Double, Double);
+
+    //Matrix ./ Scalar
+    scilab_fill_dotdiv(Bool, ScalarDouble, M_S, Bool, Double, Double);
+    scilab_fill_dotdiv(Bool, ScalarInt8, M_S, Bool, Int8, Int8);
+    scilab_fill_dotdiv(Bool, ScalarUInt8, M_S, Bool, UInt8, UInt8);
+    scilab_fill_dotdiv(Bool, ScalarInt16, M_S, Bool, Int16, Int16);
+    scilab_fill_dotdiv(Bool, ScalarUInt16, M_S, Bool, UInt16, UInt16);
+    scilab_fill_dotdiv(Bool, ScalarInt32, M_S, Bool, Int32, Int32);
+    scilab_fill_dotdiv(Bool, ScalarUInt32, M_S, Bool, UInt32, UInt32);
+    scilab_fill_dotdiv(Bool, ScalarInt64, M_S, Bool, Int64, Int64);
+    scilab_fill_dotdiv(Bool, ScalarUInt64, M_S, Bool, UInt64, UInt64);
+    scilab_fill_dotdiv(Bool, ScalarBool, M_S, Bool, Bool, Bool);
+
+    //Scalar ./ Matrix
+    scilab_fill_dotdiv(ScalarBool, Double, S_M, Bool, Double, Double);
+    scilab_fill_dotdiv(ScalarBool, Int8, S_M, Bool, Int8, Int8);
+    scilab_fill_dotdiv(ScalarBool, UInt8, S_M, Bool, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarBool, Int16, S_M, Bool, Int16, Int16);
+    scilab_fill_dotdiv(ScalarBool, UInt16, S_M, Bool, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarBool, Int32, S_M, Bool, Int32, Int32);
+    scilab_fill_dotdiv(ScalarBool, UInt32, S_M, Bool, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarBool, Int64, S_M, Bool, Int64, Int64);
+    scilab_fill_dotdiv(ScalarBool, UInt64, S_M, Bool, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarBool, Bool, S_M, Bool, Bool, Bool);
+    scilab_fill_dotdiv(ScalarBool, Empty, M_E, Bool, Double, Double);
+
+    //Scalar ./ Scalar
+    scilab_fill_dotdiv(ScalarBool, ScalarDouble, S_S, Bool, Double, Double);
+    scilab_fill_dotdiv(ScalarBool, ScalarInt8, S_S, Bool, Int8, Int8);
+    scilab_fill_dotdiv(ScalarBool, ScalarUInt8, S_S, Bool, UInt8, UInt8);
+    scilab_fill_dotdiv(ScalarBool, ScalarInt16, S_S, Bool, Int16, Int16);
+    scilab_fill_dotdiv(ScalarBool, ScalarUInt16, S_S, Bool, UInt16, UInt16);
+    scilab_fill_dotdiv(ScalarBool, ScalarInt32, S_S, Bool, Int32, Int32);
+    scilab_fill_dotdiv(ScalarBool, ScalarUInt32, S_S, Bool, UInt32, UInt32);
+    scilab_fill_dotdiv(ScalarBool, ScalarInt64, S_S, Bool, Int64, Int64);
+    scilab_fill_dotdiv(ScalarBool, ScalarUInt64, S_S, Bool, UInt64, UInt64);
+    scilab_fill_dotdiv(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
+
+    //Identity
+    scilab_fill_dotdiv(Identity, Double, I_M, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, DoubleComplex, I_MC, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, ScalarDouble, I_S, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, ScalarDoubleComplex, I_SC, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, Identity, I_I, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, IdentityComplex, I_IC, Double, Double, Double);
+    scilab_fill_dotdiv(Identity, Empty, M_E, Double, Double, Double);
+
+    scilab_fill_dotdiv(Identity, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(Identity, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(Identity, ScalarPolynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(Identity, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+    //scilab_fill_dotdiv(Identity, Sparse, M_M, Double, Sparse, Sparse);
+    //scilab_fill_dotdiv(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
+
+    scilab_fill_dotdiv(IdentityComplex, Double, IC_M, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, ScalarDouble, IC_S, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, Identity, IC_I, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Double);
+    scilab_fill_dotdiv(IdentityComplex, Empty, M_E, Double, Double, Double);
+
+    scilab_fill_dotdiv(IdentityComplex, Polynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(IdentityComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(IdentityComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
+    scilab_fill_dotdiv(IdentityComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
+    //scilab_fill_dotdiv(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
+    //scilab_fill_dotdiv(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
+
+    //Polynom
+
+    //poly ./ poly
+    scilab_fill_dotdiv(Polynom, Polynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(Polynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
+
+    //poly ./ scalar poly
+    scilab_fill_dotdiv(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
+
+    //poly ./ double
+    scilab_fill_dotdiv(Polynom, Double, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(Polynom, DoubleComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, Double, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
+
+    //poly ./ scalar double
+    scilab_fill_dotdiv(Polynom, ScalarDouble, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(Polynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
+
+    //poly ./ []
+    scilab_fill_dotdiv(Polynom, Empty, M_E, Polynom, Double, Double);
+    scilab_fill_dotdiv(PolynomComplex, Empty, M_E, Polynom, Double, Double);
+
+    //poly ./ eye
+    scilab_fill_dotdiv(Polynom, Identity, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(Polynom, IdentityComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, Identity, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(PolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
+
+    //scalar poly ./ poly
+    scilab_fill_dotdiv(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
+
+    //scalar poly ./ scalar poly
+    scilab_fill_dotdiv(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
+
+    //scalar poly ./ double
+    scilab_fill_dotdiv(ScalarPolynom, Double, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynom, DoubleComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, Double, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
+
+    //scalar poly ./ scalar double
+    scilab_fill_dotdiv(ScalarPolynom, ScalarDouble, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
+
+    //scalar poly ./ []
+    scilab_fill_dotdiv(ScalarPolynom, Empty, M_E, Polynom, Double, Double);
+    scilab_fill_dotdiv(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Double);
+
+    //scalar poly ./ eye
+    scilab_fill_dotdiv(ScalarPolynom, Identity, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynom, IdentityComplex, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, Identity, M_M, Polynom, Double, Polynom);
+    scilab_fill_dotdiv(ScalarPolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
+
+    //Sparse
+    scilab_fill_dotdiv(Sparse, Sparse, M_M, Sparse, Sparse, Sparse);
+    scilab_fill_dotdiv(Sparse, SparseComplex, M_M, Sparse, Sparse, Sparse);
+    scilab_fill_dotdiv(Sparse, Double, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(Sparse, DoubleComplex, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(Sparse, ScalarDouble, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
+
+    scilab_fill_dotdiv(Sparse, Empty, M_E, Sparse, Double, Double);
+    //scilab_fill_dotdiv(Sparse, Identity, M_M, Sparse, Double, Sparse);
+    //scilab_fill_dotdiv(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
+
+    scilab_fill_dotdiv(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
+    scilab_fill_dotdiv(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
+    scilab_fill_dotdiv(SparseComplex, Double, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(SparseComplex, DoubleComplex, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(SparseComplex, ScalarDouble, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
+
+    scilab_fill_dotdiv(SparseComplex, Empty, M_E, Sparse, Double, Double);
+    //scilab_fill_dotdiv(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
+    //scilab_fill_dotdiv(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
+
+#undef scilab_fill_dotdiv
+
+}
+
+InternalType *GenericDotLDivide(InternalType *_pLeftOperand, InternalType *_pRightOperand)
+{
+    InternalType *pResult = NULL;
+
+    dotdiv_function dotdiv = pDotDivfunction[_pRightOperand->getId()][_pLeftOperand->getId()];
+    if (dotdiv)
+    {
+        pResult = dotdiv(_pRightOperand, _pLeftOperand);
+        if (pResult)
+        {
+            return pResult;
+        }
+    }
+
+    /*
+    ** Default case : Return NULL will Call Overloading.
+    */
+    return NULL;
+}
+
+InternalType *GenericDotRDivide(InternalType *_pLeftOperand, InternalType *_pRightOperand)
+{
+    InternalType *pResult = NULL;
+
+    dotdiv_function dotdiv = pDotDivfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
+    if (dotdiv)
+    {
+        pResult = dotdiv(_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* dotdiv_M_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < iDimsL ; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL);
+    int iSize = pOut->getSize();
+
+    dotdiv(_pL->get(), iSize, _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < iDimsL ; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL, true);
+    int iSize = pOut->getSize();
+
+    dotdiv(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
+    dotdiv(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
+    dotdiv(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_I(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_IC(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_M_E(T *_pL, U *_pR)
+{
+    return _pR;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_E_M(T *_pL, U *_pR)
+{
+    return _pL;
+}
+
+//Matrix complex ./ x
+template<class T, class U, class O>
+InternalType* dotdiv_MC_M(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < iDimsL ; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL, true);
+    int iSize = pOut->getSize();
+
+    dotdiv(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_MC_MC(T *_pL, U *_pR)
+{
+    //check dims
+    int iDimsL = _pL->getDims();
+    int iDimsR = _pR->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pL->getDimsArray();
+    int* piDimsR = _pR->getDimsArray();
+
+    for (int i = 0 ; i < iDimsL ; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+    O* pOut = new O(iDimsL, piDimsL, true);
+    int iSize = pOut->getSize();
+
+    dotdiv(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_MC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
+    dotdiv(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_MC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
+    dotdiv(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_MC_I(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_MC_IC(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+//Scalar ./ x
+template<class T, class U, class O>
+InternalType* dotdiv_S_M(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
+    dotdiv(_pL->get(0), (size_t)pOut->getSize(), _pR->get(), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_S_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
+    dotdiv(_pL->get(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_S_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(0);
+    dotdiv(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_S_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(0.0, 0.0);
+    dotdiv(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_S_I(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pR->clone();
+    dotdiv(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_S_IC(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pR->clone();
+    dotdiv(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+//Scalar complex ./ x
+template<class T, class U, class O>
+InternalType* dotdiv_SC_M(T *_pL, U *_pR)
+{
+    return dotdiv_SC_MC<U, T, O>(_pR, _pL);
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_SC_MC(T *_pL, U *_pR)
+{
+    O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
+    dotdiv(_pL->get(0), _pL->getImg(0), pOut->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_SC_S(T *_pL, U *_pR)
+{
+    O* pOut = new O(0.0, 0.0);
+    dotdiv(_pL->get(0), _pL->getImg(0), 1 , _pR->get(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_SC_SC(T *_pL, U *_pR)
+{
+    O* pOut = new O(0.0, 0.0);
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_SC_I(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pR->clone();
+    pOut->setComplex(true);
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_SC_IC(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pR->clone();
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+//Identity ./ x
+template<class T, class U, class O>
+InternalType* dotdiv_I_M(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_I_MC(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_I_S(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_I_SC(T *_pL, U *_pR)
+{
+    return dotdiv_SC_I<U, T, O>(_pR, _pL);
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_I_I(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pR->get(0), pOut->get());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_I_IC(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pR->clone();
+    dotdiv(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+//Identity complex ./ x
+template<class T, class U, class O>
+InternalType* dotdiv_IC_M(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_IC_MC(T *_pL, U *_pR)
+{
+    return NULL;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_IC_S(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_IC_SC(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_IC_I(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+template<class T, class U, class O>
+InternalType* dotdiv_IC_IC(T *_pL, U *_pR)
+{
+    O* pOut = (O*)_pL->clone();
+    dotdiv(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
+    return pOut;
+}
+
+
+template<>
+InternalType* dotdiv_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
+{
+    //check dims
+    if (_pL->isScalar())
+    {
+        Sparse* pOut = NULL;
+        std::complex<double> c(_pL->getImg(0, 0));
+        Double* pL = NULL;
+        if (c.imag())
+        {
+            pL = new Double(c.real(), c.imag());
+        }
+        else
+        {
+            pL = new Double(c.real());
+        }
+        pOut = (Sparse*)dotdiv_M_M<Double, Sparse, Sparse>(pL, _pR);
+        delete pL;
+        return pOut;
+    }
+
+    if (_pR->isScalar())
+    {
+        Sparse* pOut = NULL;
+        std::complex<double> c(_pR->getImg(0, 0));
+        Double* pR = NULL;
+        if (c.imag())
+        {
+            pR = new Double(c.real(), c.imag());
+        }
+        else
+        {
+            pR = new Double(c.real());
+        }
+        pOut = (Sparse*)dotdiv_M_M<Sparse, Double, Sparse>(_pL, pR);
+        delete pR;
+        return pOut;
+    }
+
+    //check dimensions
+    if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    Sparse* pSparseOut = _pL->dotDivide(*_pR);
+    pSparseOut->finalize();
+    return pSparseOut;
+}
+
+//[] ./ SP
+template<>
+InternalType* dotdiv_M_M<Double, Sparse, Double>(Double* _pL, Sparse* _pR)
+{
+    return _pL;
+}
+
+//SP ./ []
+template<>
+InternalType* dotdiv_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _pR)
+{
+    return _pR;
+}
+//
+template<>
+InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
+{
+    //D -> SP / SP
+    if (_pL->isScalar())
+    {
+        Sparse* pOut = NULL;
+        int iSizeOut = _pR->getSize();
+        if (_pL->isComplex())
+        {
+            pOut = new Sparse(_pR->getRows(), _pR->getCols(), true);
+            std::complex<double> stComplex(_pL->get(0), _pL->getImg(0));
+            for (int i = 0 ; i < iSizeOut ; i++)
+            {
+                if (_pR->get(i) != 0)
+                {
+                    pOut->set(i, stComplex);
+                }
+            }
+        }
+        else
+        {
+            pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
+            for (int i = 0 ; i < iSizeOut ; i++)
+            {
+                if (_pR->get(i) != 0)
+                {
+                    pOut->set(i, _pL->get(0));
+                }
+            }
+        }
+        return pOut->dotDivide(*_pR);
+    }
+
+    if (_pR->isScalar())
+    {
+        //D / sp -> D ./ d
+        Double* pD = NULL;
+
+        if (_pR->isComplex())
+        {
+            std::complex<double> dbl(_pR->getImg(0, 0));
+            pD = new Double(dbl.real(), dbl.imag());
+        }
+        else
+        {
+            pD = new Double(_pR->get(0, 0));
+        }
+
+        InternalType* pIT = GenericDotRDivide(_pL, pD);
+        delete pD;
+        return pIT;
+    }
+
+
+    //check dimensions
+    if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    //get some information
+    int iNonZeros = static_cast<int>(_pR->nonZeros());
+    int* pRows = new int[iNonZeros * 2];
+    _pR->outputRowCol(pRows);
+    int* pCols = pRows + iNonZeros;
+    double* pValR = new double[iNonZeros];
+    double* pValI = new double[iNonZeros];
+    _pR->outputValues(pValR, pValI);
+    double* pdblR = _pL->get();
+    int iRows = _pL->getRows();
+
+    Sparse* pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex() || _pR->isComplex());
+
+    if (_pL->isComplex() == false)
+    {
+        if (_pR->isComplex() == false)
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                pOut->set(iRow, iCol,  pdblR[index] / pValR[i]);
+            }
+        }
+        else
+        {
+            double dDenum = 0;
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
+                c.real((pdblR[index] * pValR[i]) / dDenum);
+                c.imag(-(pdblR[index] * pValI[i]) / dDenum);
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+    }
+    else
+    {
+        double* pdblI = _pL->getImg();
+        if (_pR->isComplex() == false)
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                c.real(pdblR[index] / pValR[i]);
+                c.imag(pdblI[index] / pValR[i]);
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+        else
+        {
+            double dDenum = 0;
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
+                c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
+                c.imag((pdblI[index] * pValR[i] - pdblR[index] * pValI[i]) / dDenum);
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+    }
+
+    delete[] pRows;
+    delete[] pValR;
+    delete[] pValI;
+
+    return pOut;
+}
+
+template<>
+InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
+{
+
+    if (_pR->isScalar())
+    {
+        // SP / d-> SP
+        Sparse* pOut = NULL;
+        int iSizeOut = _pL->getSize();
+        if (_pR->isComplex())
+        {
+            pOut = new Sparse(_pL->getRows(), _pL->getCols(), true);
+            std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
+            for (int i = 0 ; i < iSizeOut ; i++)
+            {
+                if (_pL->get(i) != 0)
+                {
+                    pOut->set(i, stComplex);
+                }
+            }
+        }
+        else
+        {
+            pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
+            std::complex<double> stComplex(_pR->get(0), _pR->getImg(0));
+            for (int i = 0 ; i < iSizeOut ; i++)
+            {
+                if (_pL->get(i) != 0)
+                {
+                    pOut->set(i, _pR->get(0));
+                }
+            }
+        }
+        return _pL->dotDivide(*pOut);
+    }
+
+    if (_pL->isScalar())
+    {
+        //D / sp -> D ./ d
+        Double* pD = NULL;
+
+        if (_pL->isComplex())
+        {
+            std::complex<double> dbl(_pL->getImg(0, 0));
+            pD = new Double(dbl.real(), dbl.imag());
+        }
+        else
+        {
+            pD = new Double(_pL->get(0, 0));
+        }
+
+        InternalType* pIT = GenericDotLDivide(_pR, pD);
+        delete pD;
+        return pIT;
+    }
+
+
+    //check dimensions
+    if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    //get some information
+    int iNonZeros = static_cast<int>(_pL->nonZeros());
+    int* pRows = new int[iNonZeros * 2];
+    _pL->outputRowCol(pRows);
+    int* pCols = pRows + iNonZeros;
+    double* pValR = new double[iNonZeros];
+    double* pValI = new double[iNonZeros];
+    _pL->outputValues(pValR, pValI);
+    double* pdblR = _pR->get();
+    int iRows = _pR->getRows();
+
+    Sparse* pOut = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex() || _pL->isComplex());
+
+    if (_pR->isComplex() == false)
+    {
+        if (_pL->isComplex() == false)
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                pOut->set(iRow, iCol, pValR[i] / pdblR[index]  );
+            }
+        }
+        else
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                c.real(pValR[i] / pdblR[index]);
+                c.imag(pValR[i] / pdblR[index]);
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+    }
+    else
+    {
+        double* pdblI = _pR->getImg();
+        double dDenum = 0;
+        if (_pL->isComplex() == false)
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
+                c.real((pValR[i]*pdblR[index]) / dDenum );
+                c.imag(-(pdblI[index]*pValR[i]) / dDenum );
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+        else
+        {
+            for (int i = 0 ; i < iNonZeros ; i++)
+            {
+                int iRow = static_cast<int>(pRows[i]) - 1;
+                int iCol = static_cast<int>(pCols[i]) - 1;
+                int index = iCol * iRows + iRow;
+
+                std::complex<double> c;
+                dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
+                c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
+                c.imag((pdblR[index] * pValI[i] - pdblI[index] * pValR[i]) / dDenum);
+                pOut->set(iRow, iCol,  c);
+            }
+        }
+    }
+
+    delete[] pRows;
+    delete[] pValR;
+    delete[] pValI;
+
+    return pOut;
+}
+
+//Polynom
+template<>
+InternalType* dotdiv_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
+{
+    return NULL;
+}
+
+template<>
+InternalType* dotdiv_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
+{
+    Polynom* pOut = NULL;
+
+    bool isComplexL = _pR->isComplex();
+    bool isComplexR = _pL->isComplex();
+    bool isComplexOut = isComplexL || isComplexR;
+
+    if (_pR->isScalar())
+    {
+        pOut = (Polynom*)_pL->clone();
+        SinglePoly** pSPR = _pL->get();
+        SinglePoly** pSP = pOut->get();
+        int iSize = pOut->getSize();
+
+        double dblR = _pR->get(0);
+        if (isComplexL)
+        {
+            double dblI = _pR->getImg(0);
+            pOut->setComplex(true);
+            if (isComplexR)
+            {
+                for (int i = 0 ; i < iSize ; i++)
+                {
+                    dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
+                }
+            }
+            else
+            {
+                for (int i = 0 ; i < iSize ; i++)
+                {
+                    dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
+                }
+            }
+        }
+        else
+        {
+            if (isComplexR)
+            {
+                for (int i = 0 ; i < iSize ; i++)
+                {
+                    dotdiv(pSP[i]->get(), pSP[i]->getImg(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get(), pSP[i]->getImg());
+                }
+            }
+            else
+            {
+                //r ./ P
+                for (int i = 0 ; i < iSize ; i++)
+                {
+                    dotdiv(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get());
+                }
+            }
+        }
+
+        return pOut;
+    }
+
+    if (_pL->isScalar())
+    {
+        pOut = new Polynom(_pL->getVariableName(), _pR->getDims(), _pR->getDimsArray());
+        SinglePoly* pSPL = _pL->get(0);
+        SinglePoly** pSP = pOut->get();
+        int iSize = pOut->getSize();
+        double* pdblLR = _pR->get();
+        double* pdblLI = NULL;
+        if (isComplexL)
+        {
+            pdblLI  = _pR->getImg();
+        }
+
+        double* pdblRR = pSPL->get();
+        double* pdblRI = NULL;
+        if (isComplexR)
+        {
+            pdblRI = pSPL->getImg();
+        }
+
+        if (isComplexL)
+        {
+            if (isComplexR)
+            {
+                for (int i = 0 ; i < iSize ; ++i)
+                {
+                    SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
+                    int iSPSize = pSPOut->getSize();
+                    pSPOut->setComplex(isComplexOut);
+
+                    double* pdblOutR = pSPOut->get();
+                    double* pdblOutI = pSPOut->getImg();
+
+                    dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
+                    pSP[i] = pSPOut;
+                }
+            }
+            else
+            {
+                for (int i = 0 ; i < iSize ; ++i)
+                {
+                    SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
+                    int iSPSize = pSPOut->getSize();
+                    pSPOut->setComplex(isComplexOut);
+
+                    double* pdblOutR = pSPOut->get();
+                    double* pdblOutI = pSPOut->getImg();
+                    dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
+                    pSP[i] = pSPOut;
+                }
+            }
+        }
+        else
+        {
+            if (isComplexR)
+            {
+                for (int i = 0 ; i < iSize ; ++i)
+                {
+                    SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
+                    int iSPSize = pSPOut->getSize();
+                    pSPOut->setComplex(isComplexOut);
+
+                    double* pdblOutR = pSPOut->get();
+                    double* pdblOutI = pSPOut->getImg();
+                    dotdiv(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblOutR, pdblOutI);
+                    pSP[i] = pSPOut;
+                }
+            }
+            else
+            {
+                for (int i = 0 ; i < iSize ; ++i)
+                {
+                    SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
+                    int iSPSize = pSPOut->getSize();
+                    pSPOut->setComplex(isComplexOut);
+
+                    double* pdblOutR = pSPOut->get();
+                    dotdiv(pdblRR, (size_t)iSPSize, pdblLR[i], pdblOutR);
+                    pSP[i] = pSPOut;
+                }
+            }
+        }
+
+        return pOut;
+
+    }
+
+    //check dims
+    int iDimsL = _pR->getDims();
+    int iDimsR = _pL->getDims();
+
+    if (iDimsL != iDimsR)
+    {
+        throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+    }
+
+    int* piDimsL = _pR->getDimsArray();
+    int* piDimsR = _pL->getDimsArray();
+
+    for (int i = 0 ; i < iDimsL ; ++i)
+    {
+        if (piDimsL[i] != piDimsR[i])
+        {
+            throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
+        }
+    }
+
+
+    pOut = (Polynom*)_pL->clone();
+    pOut->setComplex(isComplexOut);
+    SinglePoly** pSPR = _pL->get();
+    SinglePoly** pSP = pOut->get();
+    int iSize = pOut->getSize();
+
+    double* pdblR = _pR->get();
+    double* pdblI = NULL;
+    if (isComplexL)
+    {
+        pdblI = _pR->getImg();
+    }
+
+    if (isComplexL)
+    {
+        if (isComplexR)
+        {
+            for (int i = 0 ; i < iSize ; i++)
+            {
+                dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
+            }
+        }
+        else
+        {
+            for (int i = 0 ; i < iSize ; i++)
+            {
+                dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
+            }
+        }
+    }
+    else
+    {
+        if (isComplexR)
+        {
+            for (int i = 0 ; i < iSize ; i++)
+            {
+                dotdiv(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get(), pSP[i]->getImg());
+            }
+        }
+        else
+        {
+            //r ./ P
+            for (int i = 0 ; i < iSize ; i++)
+            {
+                dotdiv(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get());
+            }
+        }
+    }
+
+    return pOut;
+}
+
+template<>
+InternalType* dotdiv_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
+{
+    return NULL;
+}
index bd7cce9..c738b9a 100644 (file)
@@ -80,61 +80,6 @@ InternalType *GenericLDivide(InternalType *_pLeftOperand, InternalType *_pRightO
     return pResult;
 }
 
-InternalType *GenericDotLDivide(InternalType *_pLeftOperand, InternalType *_pRightOperand)
-{
-    InternalType *pResult       = NULL;
-    GenericType::ScilabType TypeL = _pLeftOperand->getType();
-    GenericType::ScilabType TypeR = _pRightOperand->getType();
-
-    int iResult = 0;
-
-    if (_pLeftOperand->isDouble() && _pLeftOperand->getAs<Double>()->isEmpty())
-    {
-        return Double::Empty();
-    }
-
-    if (_pRightOperand->isDouble() && _pRightOperand->getAs<Double>()->isEmpty())
-    {
-        return Double::Empty();
-    }
-
-    /*
-    ** DOUBLE .\ DOUBLE
-    */
-    if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabDouble)
-    {
-        Double *pL  = _pLeftOperand->getAs<Double>();
-        Double *pR  = _pRightOperand->getAs<Double>();
-
-        // left .\ rigth => rigth ./ left
-        iResult = DotRDivideDoubleByDouble(pR, pL, (Double**)&pResult);
-    }
-
-    //manage errors
-    if (iResult)
-    {
-        switch (iResult)
-        {
-            case 1 :
-                throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
-            case 2 :
-                throw ast::ScilabError(_W("With NaN or Inf a left division by scalar expected.\n"));
-            case 3 :
-                throw ast::ScilabError(_W("Left division by zero...\n"));
-            case 4 :
-                sciprint(_("Warning : Left division by zero...\n"));
-                break;
-            default :
-                sciprint(_("Operator .\\ : Error %d not yet managed.\n"), iResult);
-        }
-    }
-
-    /*
-    ** Default case : Return NULL will Call Overloading.
-    */
-    return pResult;
-}
-
 int LDivideDoubleByDouble(Double *_pDouble1, Double *_pDouble2, Double **_pDoubleOut)
 {
     int iErr = 0;
index c8c008c..16ce5d4 100644 (file)
@@ -1740,6 +1740,30 @@ Sparse* Sparse::dotMultiply(Sparse SPARSE_CONST& o) const
     return new Sparse(realSp, cplxSp);
 }
 
+Sparse* Sparse::dotDivide(Sparse SPARSE_CONST& o) const
+{
+    RealSparse_t* realSp(0);
+    CplxSparse_t* cplxSp(0);
+    if (isComplex() == false && o.isComplex() == false)
+    {
+        realSp = new RealSparse_t(matrixReal->cwiseQuotient(*(o.matrixReal)));
+    }
+    else if (isComplex() == false && o.isComplex() == true)
+    {
+        cplxSp = new CplxSparse_t(matrixReal->cast<std::complex<double> >().cwiseQuotient( *(o.matrixCplx)));
+    }
+    else if (isComplex() == true && o.isComplex() == false)
+    {
+        cplxSp = new CplxSparse_t(matrixCplx->cwiseQuotient(o.matrixReal->cast<std::complex<double> >()));
+    }
+    else if (isComplex() == true && o.isComplex() == true)
+    {
+        cplxSp = new CplxSparse_t(matrixCplx->cwiseQuotient(*(o.matrixCplx)));
+    }
+
+    return new Sparse(realSp, cplxSp);
+}
+
 struct BoolCast
 {
     BoolCast(std::complex<double> const& c): b(c.real() || c.imag()) {}
diff --git a/scilab/modules/ast/tests/unit_tests/dotdivide.dia.ref b/scilab/modules/ast/tests/unit_tests/dotdivide.dia.ref
new file mode 100644 (file)
index 0000000..fe9e564
--- /dev/null
@@ -0,0 +1,855 @@
+// ============================================================================
+// 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, -3*p;4*p,-5*p];
+PC = [2*pc, -3*pc;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);
+SP1 = sparse([1,1],[10]);
+SPC1 = sparse([1,1],[1]) * ( 2 + 6*%i);
+i8 = int8(-8);
+ui8 = uint8(8);
+I8 = int8([-8 -16 ; -24 -32]);
+UI8 = uint8([8 16 ; 24 32]);
+I16 = int16([-16 -32 ; -48 -64]);
+UI16 = uint16([16 32 ; 48 64]);
+i16 = int16(-16);
+ui16 = uint16(16);
+i32 = int32(-32);
+ui32 = uint32(32);
+I32 = int32([-32 -64 ; -96 -128]);
+UI32 = uint32([32 64 ; 96 128]);
+assert_checkequal(empty .\empty, []);
+assert_checkequal(empty .\r, []);
+assert_checkequal(empty .\c, []);
+assert_checkequal(empty .\R, []);
+assert_checkequal(empty .\C, []);
+assert_checkequal(empty .\e, []);
+assert_checkequal(empty .\ec, []);
+assert_checkequal(empty .\p, []);
+assert_checkequal(empty .\pc, []);
+assert_checkequal(empty .\P, []);
+assert_checkequal(empty .\PC, []);
+assert_checkequal(empty .\SP, []);
+assert_checkequal(empty .\SPC, []);
+assert_checkequal(empty .\SP1, []);
+assert_checkequal(empty .\SPC1, []);
+assert_checkequal(r .\empty, []);
+assert_checkequal(r .\r,  1);
+assert_checkequal(r .\c,  0.5+%i);
+assert_checkequal(r .\R, [ 0.5, 1; 1.5, 2]);
+assert_checkequal(r .\C, [ 0.5+%i, 1+%i* 2; 1.5+%i* 3, 2+%i* 4]);
+assert_checkequal(r .\e, ( 0.5)*eye());
+assert_checkequal(r .\ec, ( 2.5+%i* 0.5)*eye());
+assert_checkequal(r .\p, 0.5+(0.5)*s+(- 0.5)*s^ 2);
+assert_checkequal(r .\pc, 0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2);
+assert_checkequal(r .\P, [1+(1)*s+(- 1)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;2+(2)*s+(- 2)*s^ 2,- 2.5+(- 2.5)*s+(2.5)*s^ 2]);
+assert_checkequal(r .\PC, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 2.5-%i* 5+(- 2.5+%i* 7.5)*s+(2.5-%i* 10)*s^ 2]);
+assert_checkequal(r .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5; 1.5; 1],[ 4, 10]));
+assert_checkequal(r .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5+%i* 2; 1.5+%i* 6; 1+%i* 4],[ 4, 10]));
+assert_checkequal(r .\SP1, sparse([ 1, 1], 5,[ 1, 1]));
+assert_checkequal(r .\SPC1, sparse([ 1, 1], 1+%i* 3,[ 1, 1]));
+assert_checkequal(r .\i8, int8( - 4));
+assert_checkequal(r .\I8, int8([ - 4, - 8; - 12, - 16]));
+assert_checkequal(r .\ui8, uint8( 4));
+assert_checkequal(r .\UI8, uint8([ 4, 8; 12, 16]));
+assert_checkequal(r .\i16, int16( - 8));
+assert_checkequal(r .\I16, int16([ - 8, - 16; - 24, - 32]));
+assert_checkequal(r .\ui16, uint16( 8));
+assert_checkequal(r .\UI16, uint16([ 8, 16; 24, 32]));
+assert_checkequal(r .\i32, int32( - 16));
+assert_checkequal(r .\I32, int32([ - 16, - 32; - 48, - 64]));
+assert_checkequal(r .\ui32, uint32( 16));
+assert_checkequal(r .\UI32, uint32([ 16, 32; 48, 64]));
+assert_checkequal(c .\empty, []);
+assert_checkequal(c .\r,  0.4-%i* 0.8);
+assert_checkequal(c .\c,  1+%i*0);
+assert_checkequal(c .\R, [ 0.2-%i* 0.4, 0.4-%i* 0.8; 0.6-%i* 1.2, 0.8-%i* 1.6]);
+assert_checkequal(c .\C, [ 1, 2; 3, 4]+%i*0);
+assert_checkequal(c .\e, ( 1+%i* 2)*eye());
+assert_checkequal(c .\ec, ( 1.4-%i* 1.8)*eye());
+assert_checkequal(c .\p, 0.2-%i* 0.08+(0.2-%i* 0.08)*s+(- 0.2+%i* 0.08)*s^ 2);
+assert_checkequal(c .\pc, 1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2);
+assert_checkequal(c .\P, [0.4-%i* 0.16+(0.4-%i* 0.16)*s+(- 0.4+%i* 0.16)*s^ 2,- 0.6+%i* 0.24+(- 0.6+%i* 0.24)*s+(0.6-%i* 0.24)*s^ 2;0.8-%i* 0.32+(0.8-%i* 0.32)*s+(- 0.8+%i* 0.32)*s^ 2,- 1+%i* 0.4+(- 1+%i* 0.4)*s+(1-%i* 0.4)*s^ 2]);
+assert_checkequal(c .\PC, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 3+(3+%i* 3)*s+(- 4.2-%i* 3.6)*s^ 2;4+(- 4-%i* 4)*s+(5.6+%i* 4.8)*s^ 2,- 5+(5+%i* 5)*s+(- 7-%i* 6)*s^ 2]);
+assert_checkequal(c .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.2-%i* 0.4; 0.6-%i* 1.2; 0.4-%i* 0.8],[ 4, 10]));
+assert_checkequal(c .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1.8+%i* 0.4; 5.4+%i* 1.2; 3.6+%i* 0.8],[ 4, 10]));
+assert_checkequal(c .\SP1, sparse([ 1, 1], 2-%i* 4,[ 1, 1]));
+assert_checkequal(c .\SPC1, sparse([ 1, 1], 2.8+%i* 0.4,[ 1, 1]));
+assert_checkequal(R .\empty, []);
+assert_checkequal(R .\r, [ 2, 1; (2/3), 0.5]);
+assert_checkequal(R .\c,  0.2-%i* 0.4);
+assert_checkequal(R .\R, [ 1, 1; 1, 1]);
+assert_checkequal(R .\C, [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(R .\p, [1+(1)*s+(- 1)*s^ 2,0.5+(0.5)*s+(- 0.5)*s^ 2;(1/3)+(1/3)*s+(- (1/3))*s^ 2,0.25+(0.25)*s+(- 0.25)*s^ 2]);
+assert_checkequal(R .\pc, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2;(1/3)+%i* (2/3)+((1/3)-%i)*s+(- (1/3)+%i* (1+1/3))*s^ 2,0.25+%i* 0.5+(0.25-%i* 0.75)*s+(- 0.25+%i)*s^ 2]);
+assert_checkequal(R .\P, [2+(2)*s+(- 2)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;(1+1/3)+(1+1/3)*s+(- (1+1/3))*s^ 2,- 1.25+(- 1.25)*s+(1.25)*s^ 2]);
+assert_checkequal(R .\PC, [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;(1+1/3)+%i* (2+2/3)+((1+1/3)-%i* 4)*s+(- (1+1/3)+%i* (5+1/3))*s^ 2,- 1.25-%i* 2.5+(- 1.25+%i* 3.75)*s+(1.25-%i* 5)*s^ 2]);
+assert_checkequal(R .\SPC1,  0.05-%i* 0.15);
+assert_checkequal(R .\i8, int8([ - 8, - 4; - 2, - 2]));
+assert_checkequal(R .\I8, int8([ - 8, - 8; - 8, - 8]));
+assert_checkequal(R .\ui8, uint8([ 8, 4; 2, 2]));
+assert_checkequal(R .\UI8, uint8([ 8, 8; 8, 8]));
+assert_checkequal(R .\i16, int16([ - 16, - 8; - 5, - 4]));
+assert_checkequal(R .\I16, int16([ - 16, - 16; - 16, - 16]));
+assert_checkequal(R .\ui16, uint16([ 16, 8; 5, 4]));
+assert_checkequal(R .\UI16, uint16([ 16, 16; 16, 16]));
+assert_checkequal(R .\i32, int32([ - 32, - 16; - 10, - 8]));
+assert_checkequal(R .\I32, int32([ - 32, - 32; - 32, - 32]));
+assert_checkequal(R .\ui32, uint32([ 32, 16; 10, 8]));
+assert_checkequal(R .\UI32, uint32([ 32, 32; 32, 32]));
+assert_checkequal(C .\empty, []);
+assert_checkequal(C .\r, [ 0.4-%i* 0.8, 0.2-%i* 0.4; 2/15-%i* 4/15, 0.1-%i* 0.2]);
+assert_checkequal(C .\c, [ 1, 0.5; (1/3), 0.25]+%i*0);
+assert_checkequal(C .\R, [ 0.2-%i* 0.4, 0.2-%i* 0.4; 0.2-%i* 0.4, 0.2-%i* 0.4]);
+assert_checkequal(C .\C, [ 1, 1; 1, 1]+%i*0);
+assert_checkequal(C .\p, [0.2-%i* 0.4+(0.2-%i* 0.4)*s+(- 0.2+%i* 0.4)*s^ 2,0.1-%i* 0.2+(0.1-%i* 0.2)*s+(- 0.1+%i* 0.2)*s^ 2;1/15-%i* 2/15+(1/15-%i* 2/15)*s+(- 1/15+%i* 2/15)*s^ 2,0.05-%i* 0.1+(0.05-%i* 0.1)*s+(- 0.05+%i* 0.1)*s^ 2]);
+assert_checkequal(C .\pc, [1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2,0.5+(- 0.5-%i* 0.5)*s+(0.7+%i* 0.6)*s^ 2;(1/3)+(- (1/3)-%i* (1/3))*s+(7/15+%i* 0.4)*s^ 2,0.25+(- 0.25-%i* 0.25)*s+(0.35+%i* 0.3)*s^ 2]);
+assert_checkequal(C .\P, [0.4-%i* 0.8+(0.4-%i* 0.8)*s+(- 0.4+%i* 0.8)*s^ 2,- 0.3+%i* 0.6+(- 0.3+%i* 0.6)*s+(0.3-%i* 0.6)*s^ 2;4/15-%i* 8/15+(4/15-%i* 8/15)*s+(- 4/15+%i* 8/15)*s^ 2,- 0.25+%i* 0.5+(- 0.25+%i* 0.5)*s+(0.25-%i* 0.5)*s^ 2]);
+assert_checkequal(C .\PC, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 1.5+(1.5+%i* 1.5)*s+(- 2.1-%i* 1.8)*s^ 2;(1+1/3)+(- (1+1/3)-%i* (1+1/3))*s+(28/15+%i* 1.6)*s^ 2,- 1.25+(1.25+%i* 1.25)*s+(- 1.75-%i* 1.5)*s^ 2]);
+assert_checkequal(C .\SPC1, [ 2.8+%i* 0.4, 1.4+%i* 0.2; 14/15+%i* 2/15, 0.7+%i* 0.1]);
+assert_checkequal(e .\empty, []);
+assert_checkequal(e .\r, ( 2)*eye());
+assert_checkequal(e .\c, ( 1+%i* 2)*eye());
+assert_checkequal(e .\e, ( 1)*eye());
+assert_checkequal(e .\ec, ( 5+%i)*eye());
+assert_checkequal(e .\SP1, ( 10)*eye());
+assert_checkequal(e .\SPC1, ( 2+%i* 6)*eye());
+assert_checkequal(e .\i8, int8(( - 8)*eye()));
+assert_checkequal(e .\ui8, uint8(( 8)*eye()));
+assert_checkequal(e .\i16, int16(( - 16)*eye()));
+assert_checkequal(e .\ui16, uint16(( 16)*eye()));
+assert_checkequal(e .\i32, int32(( - 32)*eye()));
+assert_checkequal(e .\ui32, uint32(( 32)*eye()));
+assert_checkequal(ec .\empty, []);
+assert_checkequal(ec .\r, ( 10/26-%i* 1/13)*eye());
+assert_checkequal(ec .\c, ( 7/26+%i* 9/26)*eye());
+assert_checkequal(ec .\e, ( 5/26-%i* 1/26)*eye());
+assert_checkequal(ec .\ec, ( 1+%i*0)*eye());
+assert_checkequal(p .\empty, []);
+test = p .\r;
+assert_checkequal(test(2), 2);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = p .\c;
+assert_checkequal(test(2), 1+%i* 2);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = p .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = p .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = p .\p;
+assert_checkequal(test(2), 1+s*0);
+assert_checkequal(test(3), 1+s*0);
+test = p .\pc;
+assert_checkequal(test(2), (1+%i*2) + (1-%i*3)*s + (-1+%i*4)*s^2  );
+assert_checkequal(test(3), 1+s-s^2);
+test = p .\P;
+assert_checkequal(test(2), [ 1, 1; 1, 1]+s*0);
+assert_checkequal(test(3),[0.5, - (1/3) ; 0.25 , -0.2]+s*0);
+test = p .\PC;
+assert_checkequal(test(2), [ (2+%i*4)+(2-%i*6)*s+(-2+%i*8)*s^2 , (-3-%i*6)+(-3+%i*9)*s+(3-%i*12)*s^2 ; (4+%i*8)+(4-%i*12)*s+(-4+%i*16)*s^2 , (-5-%i*10)+(-5+%i*15)*s+(5-%i*20)*s^2 ]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+assert_checkequal(pc .\empty, []);
+test = pc .\r;
+assert_checkequal(test(2), 2);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = pc .\c;
+assert_checkequal(test(2), 1+%i* 2);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = pc .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = pc .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = pc .\p;
+assert_checkequal(test(2), 1+s-s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc .\pc;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc .\P;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3),[1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = pc .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(P .\empty, []);
+test = P .\r;
+assert_checkequal(test(2), [ 2, 2; 2, 2]);
+assert_checkequal(test(3), [2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\c;
+assert_checkequal(test(2), [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(test(3), [2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\p;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3), [2,-3;4,-5]+s*0);
+test = P .\pc;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = P .\P;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3),[1,1;1,1]+s*0);
+test = P .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3),[2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(PC .\empty, []);
+test = PC .\r;
+assert_checkequal(test(2), [ 2, 2; 2, 2]);
+assert_checkequal(test(3), [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\c;
+assert_checkequal(test(2), [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(test(3), [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\p;
+assert_checkequal(test(2), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\pc;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\P;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3),[2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(SP .\empty, []);
+assert_checkequal(SP .\r, sparse([ 1, 2; 3, 10; 4, 5],[ 2; (2/3); 1],[ 4, 10]));
+assert_checkequal(SP .\c, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 2; (1/3)+%i* (2/3); 0.5+%i],[ 4, 10]));
+assert_checkequal(SP .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SP .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 4; 1+%i* 4; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SP .\SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 10; (3+1/3); 5],[ 4, 10]));
+assert_checkequal(SP .\SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 2+%i* 6; (2/3)+%i* 2; 1+%i* 3],[ 4, 10]));
+assert_checkequal(SPC .\empty, []);
+assert_checkequal(SPC .\r, sparse([ 1, 2; 3, 10; 4, 5],[ 2/17-%i* 8/17; 2/51-%i* 8/51; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SPC .\c, sparse([ 1, 2; 3, 10; 4, 5],[ 9/17-%i* 2/17; 3/17-%i* 2/51; 9/34-%i* 1/17],[ 4, 10]));
+assert_checkequal(SPC .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1/17-%i* 4/17; 1/17-%i* 4/17; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SPC .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SPC .\SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 10/17-%i* 40/17; 10/51-%i* 40/51; 10/34-%i* 20/17],[ 4, 10]));
+assert_checkequal(SPC .\SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 26/17-%i* 2/17; 26/51-%i* 2/51; 13/17-%i* 1/17],[ 4, 10]));
+assert_checkequal(SP1 .\empty, []);
+assert_checkequal(SP1 .\r, sparse([ 1, 1], 0.2,[ 1, 1]));
+assert_checkequal(SP1 .\c, sparse([ 1, 1], 0.1+%i* 0.2,[ 1, 1]));
+assert_checkequal(SP1 .\R, [ 0.1, 0.2; 0.3, 0.4]);
+assert_checkequal(SP1 .\C, [ 0.1+%i* 0.2, 0.2+%i* 0.4; 0.3+%i* 0.6, 0.4+%i* 0.8]);
+assert_checkequal(SP1 .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1; 0.3; 0.2],[ 4, 10]));
+assert_checkequal(SP1 .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1+%i* 0.4; 0.3+%i* 1.2; 0.2+%i* 0.8],[ 4, 10]));
+assert_checkequal(SP1 .\SP1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkequal(SP1 .\SPC1, sparse([ 1, 1], 0.2+%i* 0.6,[ 1, 1]));
+assert_checkequal(SPC1 .\empty, []);
+assert_checkalmostequal(SPC1 .\r, sparse([ 1, 1], 0.1-%i* 0.3,[ 1, 1]));
+assert_checkalmostequal(SPC1 .\c, sparse([ 1, 1], 0.35-%i* 0.05,[ 1, 1]));
+assert_checkequal(SPC1 .\R, [ 0.05-%i* 0.15, 0.1-%i* 0.3; 0.15-%i* 0.45, 0.2-%i* 0.6]);
+assert_checkequal(SPC1 .\C, [ 0.35-%i* 0.05, 0.7-%i* 0.1; 1.05-%i* 0.15, 1.4-%i* 0.2]);
+assert_checkalmostequal(SPC1 .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.05-%i* 0.15; 0.15-%i* 0.45; 0.1-%i* 0.3],[ 4, 10]));
+assert_checkalmostequal(SPC1 .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.65+%i* 0.05; 1.95+%i* 0.15; 1.3+%i* 0.1],[ 4, 10]));
+assert_checkalmostequal(SPC1 .\SP1, sparse([ 1, 1], 0.5-%i* 1.5,[ 1, 1]));
+assert_checkequal(SPC1 .\SPC1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkequal(i8 .\r, int8( 0));
+assert_checkequal(i8 .\R, int8([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i8, int8( 1));
+assert_checkequal(i8 .\I8, int8([ 1, 2; 3, 4]));
+assert_checkequal(i8 .\ui8, uint8( 0));
+assert_checkequal(i8 .\UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i16, int16( 2));
+assert_checkequal(i8 .\I16, int16([ 2, 4; 6, 8]));
+assert_checkequal(i8 .\ui16, uint16( 0));
+assert_checkequal(i8 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i32, int32( 4));
+assert_checkequal(i8 .\I32, int32([ 4, 8; 12, 16]));
+assert_checkequal(i8 .\ui32, uint32( 0));
+assert_checkequal(i8 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\r, int8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\R, int8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i8, int8([ 1, 0; 0, 0]));
+assert_checkequal(I8 .\I8, int8([ 1, 1; 1, 1]));
+assert_checkequal(I8 .\ui8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i16, int16([ 2, 1; 0, 0]));
+assert_checkequal(I8 .\I16, int16([ 2, 2; 2, 2]));
+assert_checkequal(I8 .\ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i32, int32([ 4, 2; 1, 1]));
+assert_checkequal(I8 .\I32, int32([ 4, 4; 4, 4]));
+assert_checkequal(I8 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui8 .\r, uint8( 0));
+assert_checkequal(ui8 .\R, uint8([ 0, 0; 0, 0]));
+assert_checkequal(ui8 .\i8, uint8( 31));
+assert_checkequal(ui8 .\I8, uint8([ 31, 30; 29, 28]));
+assert_checkequal(ui8 .\ui8, uint8( 1));
+assert_checkequal(ui8 .\UI8, uint8([ 1, 2; 3, 4]));
+assert_checkequal(ui8 .\i16, uint16( 8190));
+assert_checkequal(ui8 .\I16, uint16([ 8190, 8188; 8186, 8184]));
+assert_checkequal(ui8 .\ui16, uint16( 2));
+assert_checkequal(ui8 .\UI16, uint16([ 2, 4; 6, 8]));
+assert_checkequal(ui8 .\i32, uint32( 536870908));
+assert_checkequal(ui8 .\I32, uint32([ 536870908, 536870904; 536870900, 536870896]));
+assert_checkequal(ui8 .\ui32, uint32( 4));
+assert_checkequal(ui8 .\UI32, uint32([ 4, 8; 12, 16]));
+assert_checkequal(UI8 .\r, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 .\R, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 .\i8, uint8([ 31, 15; 10, 7]));
+assert_checkequal(UI8 .\I8, uint8([ 31, 15; 9, 7]));
+assert_checkequal(UI8 .\ui8, uint8([ 1, 0; 0, 0]));
+assert_checkequal(UI8 .\UI8, uint8([ 1, 1; 1, 1]));
+assert_checkequal(UI8 .\i16, uint16([ 8190, 4095; 2730, 2047]));
+assert_checkequal(UI8 .\I16, uint16([ 8190, 4094; 2728, 2046]));
+assert_checkequal(UI8 .\ui16, uint16([ 2, 1; 0, 0]));
+assert_checkequal(UI8 .\UI16, uint16([ 2, 2; 2, 2]));
+assert_checkequal(UI8 .\i32, uint32([ 536870908, 268435454; 178956969, 134217727]));
+assert_checkequal(UI8 .\I32, uint32([ 536870908, 268435452; 178956966, 134217724]));
+assert_checkequal(UI8 .\ui32, uint32([ 4, 2; 1, 1]));
+assert_checkequal(UI8 .\UI32, uint32([ 4, 4; 4, 4]));
+assert_checkequal(i16 .\r, int16( 0));
+assert_checkequal(i16 .\R, int16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i8, int16( 0));
+assert_checkequal(i16 .\I8, int16([ 0, 1; 1, 2]));
+assert_checkequal(i16 .\ui8, uint16( 0));
+assert_checkequal(i16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i16, int16( 1));
+assert_checkequal(i16 .\I16, int16([ 1, 2; 3, 4]));
+assert_checkequal(i16 .\ui16, uint16( 0));
+assert_checkequal(i16 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i32, int32( 2));
+assert_checkequal(i16 .\I32, int32([ 2, 4; 6, 8]));
+assert_checkequal(i16 .\ui32, uint32( 0));
+assert_checkequal(i16 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\r, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\R, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i8, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\I8, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\ui8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i16, int16([ 1, 0; 0, 0]));
+assert_checkequal(I16 .\I16, int16([ 1, 1; 1, 1]));
+assert_checkequal(I16 .\ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i32, int32([ 2, 1; 0, 0]));
+assert_checkequal(I16 .\I32, int32([ 2, 2; 2, 2]));
+assert_checkequal(I16 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui16 .\r, uint16( 0));
+assert_checkequal(ui16 .\R, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 .\i8, uint16( 4095));
+assert_checkequal(ui16 .\I8, uint16([ 4095, 4095; 4094, 4094]));
+assert_checkequal(ui16 .\ui8, uint16( 0));
+assert_checkequal(ui16 .\UI8, uint16([ 0, 1; 1, 2]));
+assert_checkequal(ui16 .\i16, uint16( 4095));
+assert_checkequal(ui16 .\I16, uint16([ 4095, 4094; 4093, 4092]));
+assert_checkequal(ui16 .\ui16, uint16( 1));
+assert_checkequal(ui16 .\UI16, uint16([ 1, 2; 3, 4]));
+assert_checkequal(ui16 .\i32, uint32( 268435454));
+assert_checkequal(ui16 .\I32, uint32([ 268435454, 268435452; 268435450, 268435448]));
+assert_checkequal(ui16 .\ui32, uint32( 2));
+assert_checkequal(ui16 .\UI32, uint32([ 2, 4; 6, 8]));
+assert_checkequal(UI16 .\r, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\R, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\i8, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(UI16 .\I8, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(UI16 .\ui8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\i16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(UI16 .\I16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(UI16 .\ui16, uint16([ 1, 0; 0, 0]));
+assert_checkequal(UI16 .\UI16, uint16([ 1, 1; 1, 1]));
+assert_checkequal(UI16 .\i32, uint32([ 268435454, 134217727; 89478484, 67108863]));
+assert_checkequal(UI16 .\I32, uint32([ 268435454, 134217726; 89478483, 67108862]));
+assert_checkequal(UI16 .\ui32, uint32([ 2, 1; 0, 0]));
+assert_checkequal(UI16 .\UI32, uint32([ 2, 2; 2, 2]));
+assert_checkequal(i32 .\r, int32( 0));
+assert_checkequal(i32 .\R, int32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i8, int32( 0));
+assert_checkequal(i32 .\I8, int32([ 0, 0; 0, 1]));
+assert_checkequal(i32 .\ui8, uint32( 0));
+assert_checkequal(i32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i16, int32( 0));
+assert_checkequal(i32 .\I16, int32([ 0, 1; 1, 2]));
+assert_checkequal(i32 .\ui16, uint32( 0));
+assert_checkequal(i32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i32, int32( 1));
+assert_checkequal(i32 .\I32, int32([ 1, 2; 3, 4]));
+assert_checkequal(i32 .\ui32, uint32( 0));
+assert_checkequal(i32 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\r, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\R, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i8, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\I8, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\ui8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i16, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\I16, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\ui16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i32, int32([ 1, 0; 0, 0]));
+assert_checkequal(I32 .\I32, int32([ 1, 1; 1, 1]));
+assert_checkequal(I32 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 .\r, uint32( 0));
+assert_checkequal(ui32 .\R, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 .\i8, uint32( 134217727));
+assert_checkequal(ui32 .\I8, uint32([ 134217727, 134217727; 134217727, 134217727]));
+assert_checkequal(ui32 .\ui8, uint32( 0));
+assert_checkequal(ui32 .\UI8, uint32([ 0, 0; 0, 1]));
+assert_checkequal(ui32 .\i16, uint32( 134217727));
+assert_checkequal(ui32 .\I16, uint32([ 134217727, 134217727; 134217726, 134217726]));
+assert_checkequal(ui32 .\ui16, uint32( 0));
+assert_checkequal(ui32 .\UI16, uint32([ 0, 1; 1, 2]));
+assert_checkequal(ui32 .\i32, uint32( 134217727));
+assert_checkequal(ui32 .\I32, uint32([ 134217727, 134217726; 134217725, 134217724]));
+assert_checkequal(ui32 .\ui32, uint32( 1));
+assert_checkequal(ui32 .\UI32, uint32([ 1, 2; 3, 4]));
+assert_checkequal(UI32 .\r, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\R, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i8, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I8, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\ui8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i16, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I16, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\ui16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I32, uint32([ 134217727, 67108863; 44739241, 33554431]));
+assert_checkequal(UI32 .\ui32, uint32([ 1, 0; 0, 0]));
+assert_checkequal(UI32 .\UI32, uint32([ 1, 1; 1, 1]));
+assert_checkequal(empty ./ empty, []);
+assert_checkequal(empty ./ r, []);
+assert_checkequal(empty ./ c, []);
+assert_checkequal(empty ./ R, []);
+assert_checkequal(empty ./ C, []);
+assert_checkequal(empty ./ e, []);
+assert_checkequal(empty ./ ec, []);
+assert_checkequal(empty ./ p, []);
+assert_checkequal(empty ./ pc, []);
+assert_checkequal(empty ./ P, []);
+assert_checkequal(empty ./ PC, []);
+assert_checkequal(empty ./ SP, []);
+assert_checkequal(empty ./ SPC, []);
+assert_checkequal(empty ./ SP1, []);
+assert_checkequal(empty ./ SPC1, []);
+assert_checkequal(r ./ empty, []);
+assert_checkequal(r ./ r,  1);
+assert_checkequal(r ./ c,  0.4-%i* 0.8);
+assert_checkequal(r ./ R, [ 2, 1; (2/3), 0.5]);
+assert_checkequal(r ./ C, [ 0.4-%i* 0.8, 0.2-%i* 0.4; 2/15-%i* 4/15, 0.1-%i* 0.2]);
+assert_checkequal(r ./ e, ( 2)*eye());
+assert_checkalmostequal(r ./ ec, ( 1/2.6-%i* 1/13)*eye());
+test = r ./ p;
+assert_checkequal(test(2), 2+0*%s);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = r ./ pc;
+assert_checkequal(test(2), 2+0*%s);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = r ./ P;
+assert_checkequal(test(2), [2,2;2,2]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = r ./ PC;
+assert_checkequal(test(2), [2,2;2,2]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(r ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 2; (2/3); 1],[ 4, 10]));
+assert_checkequal(r ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 2/17-%i* 8/17; 2/51-%i* 8/51; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(r ./ SP1, sparse([ 1, 1], 0.2,[ 1, 1]));
+assert_checkalmostequal(r ./ SPC1, sparse([ 1, 1], 0.1-%i* 0.3,[ 1, 1]));
+assert_checkequal(r ./ i8, int8( 0));
+assert_checkequal(r ./ I8, int8([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui8, uint8( 0));
+assert_checkequal(r ./ UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(r ./ i16, int16( 0));
+assert_checkequal(r ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui16, uint16( 0));
+assert_checkequal(r ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(r ./ i32, int32( 0));
+assert_checkequal(r ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui32, uint32( 0));
+assert_checkequal(r ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(c ./ empty, []);
+assert_checkequal(c ./ r,  0.5+%i);
+assert_checkequal(c ./ c,  1+%i*0);
+assert_checkequal(c ./ R,  0.2-%i* 0.4);
+assert_checkequal(c ./ C, [ 1, 0.5; (1/3), 0.25]+%i*0);
+assert_checkequal(c ./ e, ( 1+%i* 2)*eye());
+assert_checkequal(c ./ ec, ( 7/26+%i* 9/26)*eye());
+test = c ./ p;
+assert_checkequal(test(2), 1+%i*2+0*%s);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = c ./ pc;
+assert_checkequal(test(2), 1+%i*2+0*%s);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = c ./ P;
+assert_checkequal(test(2), [1,1;1,1]*(1+%i*2)+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = c ./ PC;
+assert_checkequal(test(2), [1,1;1,1]*(1+%i*2)+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(c ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 2; (1/3)+%i* (2/3); 0.5+%i],[ 4, 10]));
+assert_checkequal(c ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 9/17-%i* 2/17; 3/17-%i* 2/51; 9/34-%i* 1/17],[ 4, 10]));
+assert_checkequal(c ./ SP1, sparse([ 1, 1], 0.1+%i* 0.2,[ 1, 1]));
+assert_checkalmostequal(c ./ SPC1, sparse([ 1, 1], 0.35-%i* 0.05,[ 1, 1]));
+assert_checkequal(R ./ empty, []);
+assert_checkequal(R ./ r, [ 0.5, 1; 1.5, 2]);
+assert_checkequal(R ./ c, [ 0.2-%i* 0.4, 0.4-%i* 0.8; 0.6-%i* 1.2, 0.8-%i* 1.60]);
+assert_checkequal(R ./ R, [ 1, 1; 1, 1]);
+assert_checkequal(R ./ C, [ 0.2-%i* 0.4, 0.2-%i* 0.4; 0.2-%i* 0.4, 0.2-%i* 0.4]);
+test = R ./ p;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3), [1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = R ./ pc;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3), [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = R ./ P;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = R ./ PC;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(R ./ SP1, [ 0.1 ,0.2;0.3,0.4]);
+assert_checkequal(R ./ SPC1, [ 0.05-%i* 0.15, 0.1-%i* 0.3; 0.15-%i* 0.45, 0.2-%i* 0.6]);
+assert_checkequal(R ./ i8, int8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I8, int8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ i16, int16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ i32, int32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(C ./ empty, []);
+assert_checkequal(C ./ r, [ 0.5+%i, 1+%i* 2; 1.5+%i* 3, 2+%i* 4]);
+assert_checkequal(C ./ c, [ 1, 2; 3, 4]+%i*0);
+assert_checkequal(C ./ R, [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(C ./ C, [ 1, 1; 1, 1]+%i*0);
+test = C ./ p;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3), [1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = C ./ pc;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3), [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = C ./ P;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = C ./ PC;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(C ./ SP1, [ 0.1+0.2*%i,0.2+0.4*%i;0.3+0.6*%i,0.4+0.8*%i]);
+assert_checkequal(C ./ SPC1, [ 0.35-%i* 0.05, 0.7-%i* 0.1; 1.05-%i* 0.15, 1.4-%i* 0.2]);
+assert_checkequal(e ./ empty, []);
+assert_checkequal(e ./ r, ( 0.5)*eye());
+assert_checkequal(e ./ c, ( 1+%i* 2)*eye());
+assert_checkequal(e ./ e, ( 1)*eye());
+assert_checkequal(e ./ ec, ( 5/26-%i* 1/26)*eye());
+assert_checkequal(e ./ SP1, ( 0.1)*eye());
+assert_checkequal(e ./ SPC1, ( 2+%i* 6)*eye());
+assert_checkequal(e ./ i8, int8(( 0)*eye()));
+assert_checkequal(e ./ ui8, uint8(( 0)*eye()));
+assert_checkequal(e ./ i16, int16(( 0)*eye()));
+assert_checkequal(e ./ ui16, uint16(( 0)*eye()));
+assert_checkequal(e ./ i32, int32(( 0)*eye()));
+assert_checkequal(e ./ ui32, uint32(( 0)*eye()));
+assert_checkequal(ec ./ empty, []);
+assert_checkequal(ec ./ r, ( 2.5+%i* 0.5)*eye());
+assert_checkequal(ec ./ c, ( 1.4-%i* 1.8)*eye());
+assert_checkequal(ec ./ e, ( 5+%i)*eye());
+assert_checkequal(ec ./ ec, ( 1+%i*0)*eye());
+assert_checkequal(p ./ empty, []);
+assert_checkequal(p ./ r, 0.5+(0.5)*s+(- 0.5)*s^ 2);
+assert_checkequal(p ./ c, 0.2-%i* 0.08+(0.2-%i* 0.08)*s+(- 0.2+%i* 0.08)*s^ 2);
+assert_checkequal(p ./ R, [1+(1)*s+(- 1)*s^ 2,0.5+(0.5)*s+(- 0.5)*s^ 2;(1/3)+((1/3))*s+(- (1/3))*s^ 2,0.25+(0.25)*s+(- 0.25)*s^ 2]);
+assert_checkequal(p ./ C, [0.2-%i* 0.4+(0.2-%i* 0.4)*s+(- 0.2+%i* 0.4)*s^ 2,0.1-%i* 0.2+(0.1-%i* 0.2)*s+(- 0.1+%i* 0.2)*s^ 2;1/15-%i* 2/15+(1/15-%i* 2/15)*s+(- 1/15+%i* 2/15)*s^ 2,0.05-%i* 0.1+(0.05-%i* 0.1)*s+(- 0.05+%i* 0.1)*s^ 2]);
+test = p ./ p;
+assert_checkequal(test(2), 1+s*0);
+assert_checkequal(test(3), 1+s*0);
+test = p ./ pc;
+assert_checkequal(test(2), 1+s-s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = p ./ P;
+assert_checkequal(test(2), [0.5,-(1/3);0.25,-0.2]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+s*0);
+test = p ./ PC;
+assert_checkequal(test(2), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(pc ./ empty, []);
+assert_checkequal(pc ./ r, 0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2);
+assert_checkequal(pc ./ c, 1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2);
+assert_checkequal(pc ./ R, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2;(1/3)+%i* (2/3)+((1/3)-%i)*s+(- (1/3)+%i* (1+1/3))*s^ 2,0.25+%i* 0.5+(0.25-%i* 0.75)*s+(- 0.25+%i)*s^ 2]);
+assert_checkequal(pc ./ C, [1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2,0.5+(- 0.5-%i* 0.5)*s+(0.7+%i* 0.6)*s^ 2;(1/3)+(- (1/3)-%i* (1/3))*s+(7/15+%i* 0.4)*s^ 2,0.25+(- 0.25-%i* 0.25)*s+(0.35+%i* 0.3)*s^ 2]);
+test = pc ./ p;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+s-s^2);
+test = pc ./ pc;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc ./ P;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = pc ./ PC;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(P ./ empty, []);
+assert_checkequal(P ./ r, [1+(1)*s+(- 1)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;2+(2)*s+(- 2)*s^ 2,- 2.5+(- 2.5)*s+(2.5)*s^ 2]);
+assert_checkequal(P ./ c, [0.4-%i* 0.16+(0.4-%i* 0.16)*s+(- 0.4+%i* 0.16)*s^ 2,- 0.6+%i* 0.24+(- 0.6+%i* 0.24)*s+(0.6-%i* 0.24)*s^ 2;0.8-%i* 0.32+(0.8-%i* 0.32)*s+(- 0.8+%i* 0.32)*s^ 2,- 1+%i* 0.4+(- 1+%i* 0.4)*s+(1-%i* 0.4)*s^ 2]);
+assert_checkequal(P ./ R, [2+(2)*s+(- 2)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;(1+1/3)+((1+1/3))*s+(- (1+1/3))*s^ 2,- 1.25+(- 1.25)*s+(1.25)*s^ 2]);
+assert_checkequal(P ./ C, [0.4-%i* 0.8+(0.4-%i* 0.8)*s+(- 0.4+%i* 0.8)*s^ 2,- 0.3+%i* 0.6+(- 0.3+%i* 0.6)*s+(0.3-%i* 0.6)*s^ 2;4/15-%i* 8/15+(4/15-%i* 8/15)*s+(- 4/15+%i* 8/15)*s^ 2,- 0.25+%i* 0.5+(- 0.25+%i* 0.5)*s+(0.25-%i* 0.5)*s^ 2]);
+test = P ./ p;
+assert_checkequal(test(2), [2,-3;4,-5]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+s*0);
+test = P ./ pc;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = P ./ P;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+%s*0);
+test = P ./ PC;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(PC ./ empty, []);
+assert_checkequal(PC ./ r, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 2.5-%i* 5+(- 2.5+%i* 7.5)*s+(2.5-%i* 10)*s^ 2]);
+assert_checkequal(PC ./ c, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 3+(3+%i* 3)*s+(- 4.2-%i* 3.6)*s^ 2;4+(- 4-%i* 4)*s+(5.6+%i* 4.8)*s^ 2,- 5+(5+%i* 5)*s+(- 7-%i* 6)*s^ 2]);
+assert_checkequal(PC ./ R, [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;(1+1/3)+%i* 8/3+((1+1/3)-%i* 4)*s+(- (1+1/3)+%i* 16/3)*s^ 2,- 1.25-%i* 2.5+(- 1.25+%i* 3.75)*s+(1.25-%i* 5)*s^ 2]);
+assert_checkequal(PC ./ C, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 1.5+(1.5+%i* 1.5)*s+(- 2.1-%i* 1.8)*s^ 2;(1+1/3)+(- (1+1/3)-%i* (1+1/3))*s+(28/15+%i* 1.6)*s^ 2,- 1.25+(1.25+%i* 1.25)*s+(- 1.75-%i* 1.5)*s^ 2]);
+test = PC ./ p;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+test = PC ./ pc;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = PC ./ P;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = PC ./ PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(SP ./ empty, []);
+assert_checkequal(SP ./ r, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5; 1.5; 1],[ 4, 10]));
+assert_checkequal(SP ./ c, sparse([ 1, 2; 3, 10; 4, 5],[ 0.2-%i* 0.4; 0.6-%i* 1.2; 0.4-%i* 0.8],[ 4, 10]));
+assert_checkequal(SP ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SP ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1/17-%i* 4/17; 1/17-%i* 4/17; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SP ./ SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1; 0.3; 0.2],[ 4, 10]));
+assert_checkalmostequal(SP ./ SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.05-%i* 0.15; 0.15-%i* 0.45; 0.1-%i* 0.3],[ 4, 10]));
+assert_checkequal(SPC ./ empty, []);
+assert_checkequal(SPC ./ r, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5+%i* 2; 1.5+%i* 6; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SPC ./ c, sparse([ 1, 2; 3, 10; 4, 5],[ 1.8+%i* 0.4; 5.4+%i* 1.2; 3.6+%i* 0.8],[ 4, 10]));
+assert_checkequal(SPC ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 4; 1+%i* 4; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SPC ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SPC ./ SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1+%i* 0.4; 0.3+%i* 1.2; 0.2+%i* 0.8],[ 4, 10]));
+assert_checkalmostequal(SPC ./ SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.65+%i* 0.05; 1.95+%i* 0.15; 1.3+%i* 0.1],[ 4, 10]));
+assert_checkequal(SP1 ./ empty, []);
+assert_checkequal(SP1 ./ r, sparse([ 1, 1], 5,[ 1, 1]));
+assert_checkequal(SP1 ./ c, sparse([ 1, 1], 2-%i* 4,[ 1, 1]));
+assert_checkequal(SP1 ./ R, [ 10, 5; (3+1/3), 2.5]);
+assert_checkequal(SP1 ./ C, [ 2-%i* 4, 1-%i* 2; (2/3)-%i* (1+1/3), 0.5-%i]);
+assert_checkequal(SP1 ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 10; (3+1/3); 5],[ 4, 10]));
+assert_checkequal(SP1 ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 10/17-%i* 40/17; 10/51-%i* 40/51; 10/34-%i* 20/17],[ 4, 10]));
+assert_checkequal(SP1 ./ SP1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkalmostequal(SP1 ./ SPC1, sparse([ 1, 1], 0.5-%i* 1.5,[ 1, 1]));
+assert_checkequal(SPC1 ./ empty, []);
+assert_checkequal(SPC1 ./ r, sparse([ 1, 1], 1+%i* 3,[ 1, 1]));
+assert_checkequal(SPC1 ./ c, sparse([ 1, 1], 2.8+%i* 0.4,[ 1, 1]));
+assert_checkequal(SPC1 ./ R,  0.05-%i* 0.15);
+assert_checkequal(SPC1 ./ C, [ 2.8+%i* 0.4, 1.4+%i* 0.2; 14/15+%i* 2/15, 0.7+%i* 0.1]);
+assert_checkequal(SPC1 ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 2+%i* 6; (2/3)+%i* 2; 1+%i* 3],[ 4, 10]));
+assert_checkequal(SPC1 ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 26/17-%i* 2/17; 26/51-%i* 2/51; 13/17-%i* 1/17],[ 4, 10]));
+assert_checkequal(SPC1 ./ SP1, sparse([ 1, 1], 0.2+%i* 0.6,[ 1, 1]));
+assert_checkequal(SPC1 ./ SPC1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkequal(i8 ./ r, int8( - 4));
+assert_checkequal(i8 ./ R, int8([ - 8, - 4; - 2, - 2]));
+assert_checkequal(i8 ./ i8, int8( 1));
+assert_checkequal(i8 ./ I8, int8([ 1, 0; 0, 0]));
+assert_checkequal(i8 ./ ui8, uint8( 31));
+assert_checkequal(i8 ./ UI8, uint8([ 31, 15; 10, 7]));
+assert_checkequal(i8 ./ i16, int16( 0));
+assert_checkequal(i8 ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(i8 ./ ui16, uint16( 4095));
+assert_checkequal(i8 ./ UI16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(i8 ./ i32, int32( 0));
+assert_checkequal(i8 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(i8 ./ ui32, uint32( 134217727));
+assert_checkequal(i8 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(I8 ./ r, int8([ - 4, - 8; - 12, - 16]));
+assert_checkequal(I8 ./ R, int8([ - 8, - 8; - 8, - 8]));
+assert_checkequal(I8 ./ i8, int8([ 1, 2; 3, 4]));
+assert_checkequal(I8 ./ I8, int8([ 1, 1; 1, 1]));
+assert_checkequal(I8 ./ ui8, uint8([ 31, 30; 29, 28]));
+assert_checkequal(I8 ./ UI8, uint8([ 31, 15; 9, 7]));
+assert_checkequal(I8 ./ i16, int16([ 0, 1; 1, 2]));
+assert_checkequal(I8 ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(I8 ./ ui16, uint16([ 4095, 4095; 4094, 4094]));
+assert_checkequal(I8 ./ UI16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(I8 ./ i32, int32([ 0, 0; 0, 1]));
+assert_checkequal(I8 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(I8 ./ ui32, uint32([ 134217727, 134217727; 134217727, 134217727]));
+assert_checkequal(I8 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(ui8 ./ r, uint8( 4));
+assert_checkequal(ui8 ./ R, uint8([ 8, 4; 2, 2]));
+assert_checkequal(ui8 ./ i8, uint8( 0));
+assert_checkequal(ui8 ./ I8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui8, uint8( 1));
+assert_checkequal(ui8 ./ UI8, uint8([ 1, 0; 0, 0]));
+assert_checkequal(ui8 ./ i16, uint16( 0));
+assert_checkequal(ui8 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui16, uint16( 0));
+assert_checkequal(ui8 ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ i32, uint32( 0));
+assert_checkequal(ui8 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui32, uint32( 0));
+assert_checkequal(ui8 ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ r, uint8([ 4, 8; 12, 16]));
+assert_checkequal(UI8 ./ R, uint8([ 8, 8; 8, 8]));
+assert_checkequal(UI8 ./ i8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui8, uint8([ 1, 2; 3, 4]));
+assert_checkequal(UI8 ./ UI8, uint8([ 1, 1; 1, 1]));
+assert_checkequal(UI8 ./ i16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui16, uint16([ 0, 1; 1, 2]));
+assert_checkequal(UI8 ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui32, uint32([ 0, 0; 0, 1]));
+assert_checkequal(UI8 ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i16 ./ r, int16( - 8));
+assert_checkequal(i16 ./ R, int16([ - 16, - 8; - 5, - 4]));
+assert_checkequal(i16 ./ i8, int16( 2));
+assert_checkequal(i16 ./ I8, int16([ 2, 1; 0, 0]));
+assert_checkequal(i16 ./ ui8, uint16( 8190));
+assert_checkequal(i16 ./ UI8, uint16([ 8190, 4095; 2730, 2047]));
+assert_checkequal(i16 ./ i16, int16( 1));
+assert_checkequal(i16 ./ I16, int16([ 1, 0; 0, 0]));
+assert_checkequal(i16 ./ ui16, uint16( 4095));
+assert_checkequal(i16 ./ UI16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(i16 ./ i32, int32( 0));
+assert_checkequal(i16 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(i16 ./ ui32, uint32( 134217727));
+assert_checkequal(i16 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(I16 ./ r, int16([ - 8, - 16; - 24, - 32]));
+assert_checkequal(I16 ./ R, int16([ - 16, - 16; - 16, - 16]));
+assert_checkequal(I16 ./ i8, int16([ 2, 4; 6, 8]));
+assert_checkequal(I16 ./ I8, int16([ 2, 2; 2, 2]));
+assert_checkequal(I16 ./ ui8, uint16([ 8190, 8188; 8186, 8184]));
+assert_checkequal(I16 ./ UI8, uint16([ 8190, 4094; 2728, 2046]));
+assert_checkequal(I16 ./ i16, int16([ 1, 2; 3, 4]));
+assert_checkequal(I16 ./ I16, int16([ 1, 1; 1, 1]));
+assert_checkequal(I16 ./ ui16, uint16([ 4095, 4094; 4093, 4092]));
+assert_checkequal(I16 ./ UI16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(I16 ./ i32, int32([ 0, 1; 1, 2]));
+assert_checkequal(I16 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(I16 ./ ui32, uint32([ 134217727, 134217727; 134217726, 134217726]));
+assert_checkequal(I16 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(ui16 ./ r, uint16( 8));
+assert_checkequal(ui16 ./ R, uint16([ 16, 8; 5, 4]));
+assert_checkequal(ui16 ./ i8, uint16( 0));
+assert_checkequal(ui16 ./ I8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui8, uint16( 2));
+assert_checkequal(ui16 ./ UI8, uint16([ 2, 1; 0, 0]));
+assert_checkequal(ui16 ./ i16, uint16( 0));
+assert_checkequal(ui16 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui16, uint16( 1));
+assert_checkequal(ui16 ./ UI16, uint16([ 1, 0; 0, 0]));
+assert_checkequal(ui16 ./ i32, uint32( 0));
+assert_checkequal(ui16 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui32, uint32( 0));
+assert_checkequal(ui16 ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ r, uint16([ 8, 16; 24, 32]));
+assert_checkequal(UI16 ./ R, uint16([ 16, 16; 16, 16]));
+assert_checkequal(UI16 ./ i8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui8, uint16([ 2, 4; 6, 8]));
+assert_checkequal(UI16 ./ UI8, uint16([ 2, 2; 2, 2]));
+assert_checkequal(UI16 ./ i16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui16, uint16([ 1, 2; 3, 4]));
+assert_checkequal(UI16 ./ UI16, uint16([ 1, 1; 1, 1]));
+assert_checkequal(UI16 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui32, uint32([ 0, 1; 1, 2]));
+assert_checkequal(UI16 ./ UI32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i32 ./ r, int32( - 16));
+assert_checkequal(i32 ./ R, int32([ - 32, - 16; - 10, - 8]));
+assert_checkequal(i32 ./ i8, int32( 4));
+assert_checkequal(i32 ./ I8, int32([ 4, 2; 1, 1]));
+assert_checkequal(i32 ./ ui8, uint32( 536870908));
+assert_checkequal(i32 ./ UI8, uint32([ 536870908, 268435454; 178956969, 134217727]));
+assert_checkequal(i32 ./ i16, int32( 2));
+assert_checkequal(i32 ./ I16, int32([ 2, 1; 0, 0]));
+assert_checkequal(i32 ./ ui16, uint32( 268435454));
+assert_checkequal(i32 ./ UI16, uint32([ 268435454, 134217727; 89478484, 67108863]));
+assert_checkequal(i32 ./ i32, int32( 1));
+assert_checkequal(i32 ./ I32, int32([ 1, 0; 0, 0]));
+assert_checkequal(i32 ./ ui32, uint32( 134217727));
+assert_checkequal(i32 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(I32 ./ r, int32([ - 16, - 32; - 48, - 64]));
+assert_checkequal(I32 ./ R, int32([ - 32, - 32; - 32, - 32]));
+assert_checkequal(I32 ./ i8, int32([ 4, 8; 12, 16]));
+assert_checkequal(I32 ./ I8, int32([ 4, 4; 4, 4]));
+assert_checkequal(I32 ./ ui8, uint32([ 536870908, 536870904; 536870900, 536870896]));
+assert_checkequal(I32 ./ UI8, uint32([ 536870908, 268435452; 178956966, 134217724]));
+assert_checkequal(I32 ./ i16, int32([ 2, 4; 6, 8]));
+assert_checkequal(I32 ./ I16, int32([ 2, 2; 2, 2]));
+assert_checkequal(I32 ./ ui16, uint32([ 268435454, 268435452; 268435450, 268435448]));
+assert_checkequal(I32 ./ UI16, uint32([ 268435454, 134217726; 89478483, 67108862]));
+assert_checkequal(I32 ./ i32, int32([ 1, 2; 3, 4]));
+assert_checkequal(I32 ./ I32, int32([ 1, 1; 1, 1]));
+assert_checkequal(I32 ./ ui32, uint32([ 134217727, 134217726; 134217725, 134217724]));
+assert_checkequal(I32 ./ UI32, uint32([ 134217727, 67108863; 44739241, 33554431]));
+assert_checkequal(ui32 ./ r, uint32( 16));
+assert_checkequal(ui32 ./ R, uint32([ 32, 16; 10, 8]));
+assert_checkequal(ui32 ./ i8, uint32( 0));
+assert_checkequal(ui32 ./ I8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui8, uint32( 4));
+assert_checkequal(ui32 ./ UI8, uint32([ 4, 2; 1, 1]));
+assert_checkequal(ui32 ./ i16, uint32( 0));
+assert_checkequal(ui32 ./ I16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui16, uint32( 2));
+assert_checkequal(ui32 ./ UI16, uint32([ 2, 1; 0, 0]));
+assert_checkequal(ui32 ./ i32, uint32( 0));
+assert_checkequal(ui32 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui32, uint32( 1));
+assert_checkequal(ui32 ./ UI32, uint32([ 1, 0; 0, 0]));
+assert_checkequal(UI32 ./ r, uint32([ 16, 32; 48, 64]));
+assert_checkequal(UI32 ./ R, uint32([ 32, 32; 32, 32]));
+assert_checkequal(UI32 ./ i8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui8, uint32([ 4, 8; 12, 16]));
+assert_checkequal(UI32 ./ UI8, uint32([ 4, 4; 4, 4]));
+assert_checkequal(UI32 ./ i16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui16, uint32([ 2, 4; 6, 8]));
+assert_checkequal(UI32 ./ UI16, uint32([ 2, 2; 2, 2]));
+assert_checkequal(UI32 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui32, uint32([ 1, 2; 3, 4]));
+assert_checkequal(UI32 ./ UI32, uint32([ 1, 1; 1, 1]));
diff --git a/scilab/modules/ast/tests/unit_tests/dotdivide.tst b/scilab/modules/ast/tests/unit_tests/dotdivide.tst
new file mode 100644 (file)
index 0000000..db370af
--- /dev/null
@@ -0,0 +1,917 @@
+// ============================================================================
+// 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, -3*p;4*p,-5*p];
+PC = [2*pc, -3*pc;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);
+SP1 = sparse([1,1],[10]);
+SPC1 = sparse([1,1],[1]) * ( 2 + 6*%i);
+
+i8 = int8(-8);
+ui8 = uint8(8);
+I8 = int8([-8 -16 ; -24 -32]);
+UI8 = uint8([8 16 ; 24 32]);
+
+I16 = int16([-16 -32 ; -48 -64]);
+UI16 = uint16([16 32 ; 48 64]);
+i16 = int16(-16);
+ui16 = uint16(16);
+
+i32 = int32(-32);
+ui32 = uint32(32);
+I32 = int32([-32 -64 ; -96 -128]);
+UI32 = uint32([32 64 ; 96 128]);
+
+assert_checkequal(empty .\empty, []);
+assert_checkequal(empty .\r, []);
+assert_checkequal(empty .\c, []);
+assert_checkequal(empty .\R, []);
+assert_checkequal(empty .\C, []);
+assert_checkequal(empty .\e, []);
+assert_checkequal(empty .\ec, []);
+assert_checkequal(empty .\p, []);
+assert_checkequal(empty .\pc, []);
+assert_checkequal(empty .\P, []);
+assert_checkequal(empty .\PC, []);
+assert_checkequal(empty .\SP, []);
+assert_checkequal(empty .\SPC, []);
+assert_checkequal(empty .\SP1, []);
+assert_checkequal(empty .\SPC1, []);
+
+assert_checkequal(r .\empty, []);
+assert_checkequal(r .\r,  1);
+assert_checkequal(r .\c,  0.5+%i);
+assert_checkequal(r .\R, [ 0.5, 1; 1.5, 2]);
+assert_checkequal(r .\C, [ 0.5+%i, 1+%i* 2; 1.5+%i* 3, 2+%i* 4]);
+assert_checkequal(r .\e, ( 0.5)*eye());
+assert_checkequal(r .\ec, ( 2.5+%i* 0.5)*eye());
+assert_checkequal(r .\p, 0.5+(0.5)*s+(- 0.5)*s^ 2);
+assert_checkequal(r .\pc, 0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2);
+assert_checkequal(r .\P, [1+(1)*s+(- 1)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;2+(2)*s+(- 2)*s^ 2,- 2.5+(- 2.5)*s+(2.5)*s^ 2]);
+assert_checkequal(r .\PC, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 2.5-%i* 5+(- 2.5+%i* 7.5)*s+(2.5-%i* 10)*s^ 2]);
+assert_checkequal(r .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5; 1.5; 1],[ 4, 10]));
+assert_checkequal(r .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5+%i* 2; 1.5+%i* 6; 1+%i* 4],[ 4, 10]));
+assert_checkequal(r .\SP1, sparse([ 1, 1], 5,[ 1, 1]));
+assert_checkequal(r .\SPC1, sparse([ 1, 1], 1+%i* 3,[ 1, 1]));
+assert_checkequal(r .\i8, int8( - 4));
+assert_checkequal(r .\I8, int8([ - 4, - 8; - 12, - 16]));
+assert_checkequal(r .\ui8, uint8( 4));
+assert_checkequal(r .\UI8, uint8([ 4, 8; 12, 16]));
+assert_checkequal(r .\i16, int16( - 8));
+assert_checkequal(r .\I16, int16([ - 8, - 16; - 24, - 32]));
+assert_checkequal(r .\ui16, uint16( 8));
+assert_checkequal(r .\UI16, uint16([ 8, 16; 24, 32]));
+assert_checkequal(r .\i32, int32( - 16));
+assert_checkequal(r .\I32, int32([ - 16, - 32; - 48, - 64]));
+assert_checkequal(r .\ui32, uint32( 16));
+assert_checkequal(r .\UI32, uint32([ 16, 32; 48, 64]));
+
+assert_checkequal(c .\empty, []);
+assert_checkequal(c .\r,  0.4-%i* 0.8);
+assert_checkequal(c .\c,  1+%i*0);
+assert_checkequal(c .\R, [ 0.2-%i* 0.4, 0.4-%i* 0.8; 0.6-%i* 1.2, 0.8-%i* 1.6]);
+assert_checkequal(c .\C, [ 1, 2; 3, 4]+%i*0);
+assert_checkequal(c .\e, ( 1+%i* 2)*eye());
+assert_checkequal(c .\ec, ( 1.4-%i* 1.8)*eye());
+assert_checkequal(c .\p, 0.2-%i* 0.08+(0.2-%i* 0.08)*s+(- 0.2+%i* 0.08)*s^ 2);
+assert_checkequal(c .\pc, 1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2);
+assert_checkequal(c .\P, [0.4-%i* 0.16+(0.4-%i* 0.16)*s+(- 0.4+%i* 0.16)*s^ 2,- 0.6+%i* 0.24+(- 0.6+%i* 0.24)*s+(0.6-%i* 0.24)*s^ 2;0.8-%i* 0.32+(0.8-%i* 0.32)*s+(- 0.8+%i* 0.32)*s^ 2,- 1+%i* 0.4+(- 1+%i* 0.4)*s+(1-%i* 0.4)*s^ 2]);
+assert_checkequal(c .\PC, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 3+(3+%i* 3)*s+(- 4.2-%i* 3.6)*s^ 2;4+(- 4-%i* 4)*s+(5.6+%i* 4.8)*s^ 2,- 5+(5+%i* 5)*s+(- 7-%i* 6)*s^ 2]);
+assert_checkequal(c .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.2-%i* 0.4; 0.6-%i* 1.2; 0.4-%i* 0.8],[ 4, 10]));
+assert_checkequal(c .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1.8+%i* 0.4; 5.4+%i* 1.2; 3.6+%i* 0.8],[ 4, 10]));
+assert_checkequal(c .\SP1, sparse([ 1, 1], 2-%i* 4,[ 1, 1]));
+assert_checkequal(c .\SPC1, sparse([ 1, 1], 2.8+%i* 0.4,[ 1, 1]));
+
+assert_checkequal(R .\empty, []);
+assert_checkequal(R .\r, [ 2, 1; (2/3), 0.5]);
+assert_checkequal(R .\c,  0.2-%i* 0.4);
+assert_checkequal(R .\R, [ 1, 1; 1, 1]);
+assert_checkequal(R .\C, [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(R .\p, [1+(1)*s+(- 1)*s^ 2,0.5+(0.5)*s+(- 0.5)*s^ 2;(1/3)+(1/3)*s+(- (1/3))*s^ 2,0.25+(0.25)*s+(- 0.25)*s^ 2]);
+assert_checkequal(R .\pc, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2;(1/3)+%i* (2/3)+((1/3)-%i)*s+(- (1/3)+%i* (1+1/3))*s^ 2,0.25+%i* 0.5+(0.25-%i* 0.75)*s+(- 0.25+%i)*s^ 2]);
+assert_checkequal(R .\P, [2+(2)*s+(- 2)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;(1+1/3)+(1+1/3)*s+(- (1+1/3))*s^ 2,- 1.25+(- 1.25)*s+(1.25)*s^ 2]);
+assert_checkequal(R .\PC, [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;(1+1/3)+%i* (2+2/3)+((1+1/3)-%i* 4)*s+(- (1+1/3)+%i* (5+1/3))*s^ 2,- 1.25-%i* 2.5+(- 1.25+%i* 3.75)*s+(1.25-%i* 5)*s^ 2]);
+assert_checkequal(R .\SPC1,  0.05-%i* 0.15);
+assert_checkequal(R .\i8, int8([ - 8, - 4; - 2, - 2]));
+assert_checkequal(R .\I8, int8([ - 8, - 8; - 8, - 8]));
+assert_checkequal(R .\ui8, uint8([ 8, 4; 2, 2]));
+assert_checkequal(R .\UI8, uint8([ 8, 8; 8, 8]));
+assert_checkequal(R .\i16, int16([ - 16, - 8; - 5, - 4]));
+assert_checkequal(R .\I16, int16([ - 16, - 16; - 16, - 16]));
+assert_checkequal(R .\ui16, uint16([ 16, 8; 5, 4]));
+assert_checkequal(R .\UI16, uint16([ 16, 16; 16, 16]));
+assert_checkequal(R .\i32, int32([ - 32, - 16; - 10, - 8]));
+assert_checkequal(R .\I32, int32([ - 32, - 32; - 32, - 32]));
+assert_checkequal(R .\ui32, uint32([ 32, 16; 10, 8]));
+assert_checkequal(R .\UI32, uint32([ 32, 32; 32, 32]));
+
+assert_checkequal(C .\empty, []);
+assert_checkequal(C .\r, [ 0.4-%i* 0.8, 0.2-%i* 0.4; 2/15-%i* 4/15, 0.1-%i* 0.2]);
+assert_checkequal(C .\c, [ 1, 0.5; (1/3), 0.25]+%i*0);
+assert_checkequal(C .\R, [ 0.2-%i* 0.4, 0.2-%i* 0.4; 0.2-%i* 0.4, 0.2-%i* 0.4]);
+assert_checkequal(C .\C, [ 1, 1; 1, 1]+%i*0);
+assert_checkequal(C .\p, [0.2-%i* 0.4+(0.2-%i* 0.4)*s+(- 0.2+%i* 0.4)*s^ 2,0.1-%i* 0.2+(0.1-%i* 0.2)*s+(- 0.1+%i* 0.2)*s^ 2;1/15-%i* 2/15+(1/15-%i* 2/15)*s+(- 1/15+%i* 2/15)*s^ 2,0.05-%i* 0.1+(0.05-%i* 0.1)*s+(- 0.05+%i* 0.1)*s^ 2]);
+assert_checkequal(C .\pc, [1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2,0.5+(- 0.5-%i* 0.5)*s+(0.7+%i* 0.6)*s^ 2;(1/3)+(- (1/3)-%i* (1/3))*s+(7/15+%i* 0.4)*s^ 2,0.25+(- 0.25-%i* 0.25)*s+(0.35+%i* 0.3)*s^ 2]);
+assert_checkequal(C .\P, [0.4-%i* 0.8+(0.4-%i* 0.8)*s+(- 0.4+%i* 0.8)*s^ 2,- 0.3+%i* 0.6+(- 0.3+%i* 0.6)*s+(0.3-%i* 0.6)*s^ 2;4/15-%i* 8/15+(4/15-%i* 8/15)*s+(- 4/15+%i* 8/15)*s^ 2,- 0.25+%i* 0.5+(- 0.25+%i* 0.5)*s+(0.25-%i* 0.5)*s^ 2]);
+assert_checkequal(C .\PC, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 1.5+(1.5+%i* 1.5)*s+(- 2.1-%i* 1.8)*s^ 2;(1+1/3)+(- (1+1/3)-%i* (1+1/3))*s+(28/15+%i* 1.6)*s^ 2,- 1.25+(1.25+%i* 1.25)*s+(- 1.75-%i* 1.5)*s^ 2]);
+assert_checkequal(C .\SPC1, [ 2.8+%i* 0.4, 1.4+%i* 0.2; 14/15+%i* 2/15, 0.7+%i* 0.1]);
+
+assert_checkequal(e .\empty, []);
+assert_checkequal(e .\r, ( 2)*eye());
+assert_checkequal(e .\c, ( 1+%i* 2)*eye());
+assert_checkequal(e .\e, ( 1)*eye());
+assert_checkequal(e .\ec, ( 5+%i)*eye());
+assert_checkequal(e .\SP1, ( 10)*eye());
+assert_checkequal(e .\SPC1, ( 2+%i* 6)*eye());
+assert_checkequal(e .\i8, int8(( - 8)*eye()));
+assert_checkequal(e .\ui8, uint8(( 8)*eye()));
+assert_checkequal(e .\i16, int16(( - 16)*eye()));
+assert_checkequal(e .\ui16, uint16(( 16)*eye()));
+assert_checkequal(e .\i32, int32(( - 32)*eye()));
+assert_checkequal(e .\ui32, uint32(( 32)*eye()));
+
+assert_checkequal(ec .\empty, []);
+assert_checkequal(ec .\r, ( 10/26-%i* 1/13)*eye());
+assert_checkequal(ec .\c, ( 7/26+%i* 9/26)*eye());
+assert_checkequal(ec .\e, ( 5/26-%i* 1/26)*eye());
+assert_checkequal(ec .\ec, ( 1+%i*0)*eye());
+
+assert_checkequal(p .\empty, []);
+test = p .\r;
+assert_checkequal(test(2), 2);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = p .\c;
+assert_checkequal(test(2), 1+%i* 2);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = p .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = p .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = p .\p;
+assert_checkequal(test(2), 1+s*0);
+assert_checkequal(test(3), 1+s*0);
+test = p .\pc;
+assert_checkequal(test(2), (1+%i*2) + (1-%i*3)*s + (-1+%i*4)*s^2  );
+assert_checkequal(test(3), 1+s-s^2);
+test = p .\P;
+assert_checkequal(test(2), [ 1, 1; 1, 1]+s*0);
+assert_checkequal(test(3),[0.5, - (1/3) ; 0.25 , -0.2]+s*0);
+test = p .\PC;
+assert_checkequal(test(2), [ (2+%i*4)+(2-%i*6)*s+(-2+%i*8)*s^2 , (-3-%i*6)+(-3+%i*9)*s+(3-%i*12)*s^2 ; (4+%i*8)+(4-%i*12)*s+(-4+%i*16)*s^2 , (-5-%i*10)+(-5+%i*15)*s+(5-%i*20)*s^2 ]);
+assert_checkequal(test(3),[1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+
+assert_checkequal(pc .\empty, []);
+test = pc .\r;
+assert_checkequal(test(2), 2);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = pc .\c;
+assert_checkequal(test(2), 1+%i* 2);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = pc .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = pc .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+
+test = pc .\p;
+assert_checkequal(test(2), 1+s-s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc .\pc;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc .\P;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3),[1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = pc .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+
+assert_checkequal(P .\empty, []);
+test = P .\r;
+assert_checkequal(test(2), [ 2, 2; 2, 2]);
+assert_checkequal(test(3), [2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\c;
+assert_checkequal(test(2), [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(test(3), [2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = P .\p;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3), [2,-3;4,-5]+s*0);
+test = P .\pc;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = P .\P;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3),[1,1;1,1]+s*0);
+test = P .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3),[2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+
+assert_checkequal(PC .\empty, []);
+test = PC .\r;
+assert_checkequal(test(2), [ 2, 2; 2, 2]);
+assert_checkequal(test(3), [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\c;
+assert_checkequal(test(2), [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(test(3), [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\R;
+assert_checkequal(test(2), [ 1, 2; 3, 4]);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\C;
+assert_checkequal(test(2), [ 1+%i* 2, 2+%i* 4; 3+%i* 6, 4+%i* 8]);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+test = PC .\p;
+assert_checkequal(test(2), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\pc;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\P;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3),[2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+test = PC .\PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+
+assert_checkequal(SP .\empty, []);
+assert_checkequal(SP .\r, sparse([ 1, 2; 3, 10; 4, 5],[ 2; (2/3); 1],[ 4, 10]));
+assert_checkequal(SP .\c, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 2; (1/3)+%i* (2/3); 0.5+%i],[ 4, 10]));
+assert_checkequal(SP .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SP .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 4; 1+%i* 4; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SP .\SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 10; (3+1/3); 5],[ 4, 10]));
+assert_checkequal(SP .\SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 2+%i* 6; (2/3)+%i* 2; 1+%i* 3],[ 4, 10]));
+
+assert_checkequal(SPC .\empty, []);
+assert_checkequal(SPC .\r, sparse([ 1, 2; 3, 10; 4, 5],[ 2/17-%i* 8/17; 2/51-%i* 8/51; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SPC .\c, sparse([ 1, 2; 3, 10; 4, 5],[ 9/17-%i* 2/17; 3/17-%i* 2/51; 9/34-%i* 1/17],[ 4, 10]));
+assert_checkequal(SPC .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1/17-%i* 4/17; 1/17-%i* 4/17; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SPC .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SPC .\SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 10/17-%i* 40/17; 10/51-%i* 40/51; 10/34-%i* 20/17],[ 4, 10]));
+assert_checkequal(SPC .\SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 26/17-%i* 2/17; 26/51-%i* 2/51; 13/17-%i* 1/17],[ 4, 10]));
+
+assert_checkequal(SP1 .\empty, []);
+assert_checkequal(SP1 .\r, sparse([ 1, 1], 0.2,[ 1, 1]));
+assert_checkequal(SP1 .\c, sparse([ 1, 1], 0.1+%i* 0.2,[ 1, 1]));
+assert_checkequal(SP1 .\R, [ 0.1, 0.2; 0.3, 0.4]);
+assert_checkequal(SP1 .\C, [ 0.1+%i* 0.2, 0.2+%i* 0.4; 0.3+%i* 0.6, 0.4+%i* 0.8]);
+assert_checkequal(SP1 .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1; 0.3; 0.2],[ 4, 10]));
+assert_checkequal(SP1 .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1+%i* 0.4; 0.3+%i* 1.2; 0.2+%i* 0.8],[ 4, 10]));
+assert_checkequal(SP1 .\SP1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkequal(SP1 .\SPC1, sparse([ 1, 1], 0.2+%i* 0.6,[ 1, 1]));
+
+assert_checkequal(SPC1 .\empty, []);
+assert_checkalmostequal(SPC1 .\r, sparse([ 1, 1], 0.1-%i* 0.3,[ 1, 1]));
+assert_checkalmostequal(SPC1 .\c, sparse([ 1, 1], 0.35-%i* 0.05,[ 1, 1]));
+assert_checkequal(SPC1 .\R, [ 0.05-%i* 0.15, 0.1-%i* 0.3; 0.15-%i* 0.45, 0.2-%i* 0.6]);
+assert_checkequal(SPC1 .\C, [ 0.35-%i* 0.05, 0.7-%i* 0.1; 1.05-%i* 0.15, 1.4-%i* 0.2]);
+assert_checkalmostequal(SPC1 .\SP, sparse([ 1, 2; 3, 10; 4, 5],[ 0.05-%i* 0.15; 0.15-%i* 0.45; 0.1-%i* 0.3],[ 4, 10]));
+assert_checkalmostequal(SPC1 .\SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 0.65+%i* 0.05; 1.95+%i* 0.15; 1.3+%i* 0.1],[ 4, 10]));
+assert_checkalmostequal(SPC1 .\SP1, sparse([ 1, 1], 0.5-%i* 1.5,[ 1, 1]));
+assert_checkequal(SPC1 .\SPC1, sparse([ 1, 1], 1,[ 1, 1]));
+
+assert_checkequal(i8 .\r, int8( 0));
+assert_checkequal(i8 .\R, int8([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i8, int8( 1));
+assert_checkequal(i8 .\I8, int8([ 1, 2; 3, 4]));
+assert_checkequal(i8 .\ui8, uint8( 0));
+assert_checkequal(i8 .\UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i16, int16( 2));
+assert_checkequal(i8 .\I16, int16([ 2, 4; 6, 8]));
+assert_checkequal(i8 .\ui16, uint16( 0));
+assert_checkequal(i8 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i8 .\i32, int32( 4));
+assert_checkequal(i8 .\I32, int32([ 4, 8; 12, 16]));
+assert_checkequal(i8 .\ui32, uint32( 0));
+assert_checkequal(i8 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(I8 .\r, int8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\R, int8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i8, int8([ 1, 0; 0, 0]));
+assert_checkequal(I8 .\I8, int8([ 1, 1; 1, 1]));
+assert_checkequal(I8 .\ui8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i16, int16([ 2, 1; 0, 0]));
+assert_checkequal(I8 .\I16, int16([ 2, 2; 2, 2]));
+assert_checkequal(I8 .\ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\i32, int32([ 4, 2; 1, 1]));
+assert_checkequal(I8 .\I32, int32([ 4, 4; 4, 4]));
+assert_checkequal(I8 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I8 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(ui8 .\r, uint8( 0));
+assert_checkequal(ui8 .\R, uint8([ 0, 0; 0, 0]));
+assert_checkequal(ui8 .\i8, uint8( 31));
+assert_checkequal(ui8 .\I8, uint8([ 31, 30; 29, 28]));
+assert_checkequal(ui8 .\ui8, uint8( 1));
+assert_checkequal(ui8 .\UI8, uint8([ 1, 2; 3, 4]));
+assert_checkequal(ui8 .\i16, uint16( 8190));
+assert_checkequal(ui8 .\I16, uint16([ 8190, 8188; 8186, 8184]));
+assert_checkequal(ui8 .\ui16, uint16( 2));
+assert_checkequal(ui8 .\UI16, uint16([ 2, 4; 6, 8]));
+assert_checkequal(ui8 .\i32, uint32( 536870908));
+assert_checkequal(ui8 .\I32, uint32([ 536870908, 536870904; 536870900, 536870896]));
+assert_checkequal(ui8 .\ui32, uint32( 4));
+assert_checkequal(ui8 .\UI32, uint32([ 4, 8; 12, 16]));
+
+assert_checkequal(UI8 .\r, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 .\R, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 .\i8, uint8([ 31, 15; 10, 7]));
+assert_checkequal(UI8 .\I8, uint8([ 31, 15; 9, 7]));
+assert_checkequal(UI8 .\ui8, uint8([ 1, 0; 0, 0]));
+assert_checkequal(UI8 .\UI8, uint8([ 1, 1; 1, 1]));
+assert_checkequal(UI8 .\i16, uint16([ 8190, 4095; 2730, 2047]));
+assert_checkequal(UI8 .\I16, uint16([ 8190, 4094; 2728, 2046]));
+assert_checkequal(UI8 .\ui16, uint16([ 2, 1; 0, 0]));
+assert_checkequal(UI8 .\UI16, uint16([ 2, 2; 2, 2]));
+assert_checkequal(UI8 .\i32, uint32([ 536870908, 268435454; 178956969, 134217727]));
+assert_checkequal(UI8 .\I32, uint32([ 536870908, 268435452; 178956966, 134217724]));
+assert_checkequal(UI8 .\ui32, uint32([ 4, 2; 1, 1]));
+assert_checkequal(UI8 .\UI32, uint32([ 4, 4; 4, 4]));
+
+assert_checkequal(i16 .\r, int16( 0));
+assert_checkequal(i16 .\R, int16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i8, int16( 0));
+assert_checkequal(i16 .\I8, int16([ 0, 1; 1, 2]));
+assert_checkequal(i16 .\ui8, uint16( 0));
+assert_checkequal(i16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i16, int16( 1));
+assert_checkequal(i16 .\I16, int16([ 1, 2; 3, 4]));
+assert_checkequal(i16 .\ui16, uint16( 0));
+assert_checkequal(i16 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(i16 .\i32, int32( 2));
+assert_checkequal(i16 .\I32, int32([ 2, 4; 6, 8]));
+assert_checkequal(i16 .\ui32, uint32( 0));
+assert_checkequal(i16 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(I16 .\r, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\R, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i8, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\I8, int16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\ui8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i16, int16([ 1, 0; 0, 0]));
+assert_checkequal(I16 .\I16, int16([ 1, 1; 1, 1]));
+assert_checkequal(I16 .\ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\i32, int32([ 2, 1; 0, 0]));
+assert_checkequal(I16 .\I32, int32([ 2, 2; 2, 2]));
+assert_checkequal(I16 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I16 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(ui16 .\r, uint16( 0));
+assert_checkequal(ui16 .\R, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 .\i8, uint16( 4095));
+assert_checkequal(ui16 .\I8, uint16([ 4095, 4095; 4094, 4094]));
+assert_checkequal(ui16 .\ui8, uint16( 0));
+assert_checkequal(ui16 .\UI8, uint16([ 0, 1; 1, 2]));
+assert_checkequal(ui16 .\i16, uint16( 4095));
+assert_checkequal(ui16 .\I16, uint16([ 4095, 4094; 4093, 4092]));
+assert_checkequal(ui16 .\ui16, uint16( 1));
+assert_checkequal(ui16 .\UI16, uint16([ 1, 2; 3, 4]));
+assert_checkequal(ui16 .\i32, uint32( 268435454));
+assert_checkequal(ui16 .\I32, uint32([ 268435454, 268435452; 268435450, 268435448]));
+assert_checkequal(ui16 .\ui32, uint32( 2));
+assert_checkequal(ui16 .\UI32, uint32([ 2, 4; 6, 8]));
+
+assert_checkequal(UI16 .\r, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\R, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\i8, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(UI16 .\I8, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(UI16 .\ui8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\UI8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 .\i16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(UI16 .\I16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(UI16 .\ui16, uint16([ 1, 0; 0, 0]));
+assert_checkequal(UI16 .\UI16, uint16([ 1, 1; 1, 1]));
+assert_checkequal(UI16 .\i32, uint32([ 268435454, 134217727; 89478484, 67108863]));
+assert_checkequal(UI16 .\I32, uint32([ 268435454, 134217726; 89478483, 67108862]));
+assert_checkequal(UI16 .\ui32, uint32([ 2, 1; 0, 0]));
+assert_checkequal(UI16 .\UI32, uint32([ 2, 2; 2, 2]));
+
+assert_checkequal(i32 .\r, int32( 0));
+assert_checkequal(i32 .\R, int32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i8, int32( 0));
+assert_checkequal(i32 .\I8, int32([ 0, 0; 0, 1]));
+assert_checkequal(i32 .\ui8, uint32( 0));
+assert_checkequal(i32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i16, int32( 0));
+assert_checkequal(i32 .\I16, int32([ 0, 1; 1, 2]));
+assert_checkequal(i32 .\ui16, uint32( 0));
+assert_checkequal(i32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(i32 .\i32, int32( 1));
+assert_checkequal(i32 .\I32, int32([ 1, 2; 3, 4]));
+assert_checkequal(i32 .\ui32, uint32( 0));
+assert_checkequal(i32 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(I32 .\r, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\R, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i8, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\I8, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\ui8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i16, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\I16, int32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\ui16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\i32, int32([ 1, 0; 0, 0]));
+assert_checkequal(I32 .\I32, int32([ 1, 1; 1, 1]));
+assert_checkequal(I32 .\ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(I32 .\UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(ui32 .\r, uint32( 0));
+assert_checkequal(ui32 .\R, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 .\i8, uint32( 134217727));
+assert_checkequal(ui32 .\I8, uint32([ 134217727, 134217727; 134217727, 134217727]));
+assert_checkequal(ui32 .\ui8, uint32( 0));
+assert_checkequal(ui32 .\UI8, uint32([ 0, 0; 0, 1]));
+assert_checkequal(ui32 .\i16, uint32( 134217727));
+assert_checkequal(ui32 .\I16, uint32([ 134217727, 134217727; 134217726, 134217726]));
+assert_checkequal(ui32 .\ui16, uint32( 0));
+assert_checkequal(ui32 .\UI16, uint32([ 0, 1; 1, 2]));
+assert_checkequal(ui32 .\i32, uint32( 134217727));
+assert_checkequal(ui32 .\I32, uint32([ 134217727, 134217726; 134217725, 134217724]));
+assert_checkequal(ui32 .\ui32, uint32( 1));
+assert_checkequal(ui32 .\UI32, uint32([ 1, 2; 3, 4]));
+
+assert_checkequal(UI32 .\r, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\R, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i8, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I8, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\ui8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\UI8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i16, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I16, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\ui16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\UI16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 .\i32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+assert_checkequal(UI32 .\I32, uint32([ 134217727, 67108863; 44739241, 33554431]));
+assert_checkequal(UI32 .\ui32, uint32([ 1, 0; 0, 0]));
+assert_checkequal(UI32 .\UI32, uint32([ 1, 1; 1, 1]));
+
+assert_checkequal(empty ./ empty, []);
+assert_checkequal(empty ./ r, []);
+assert_checkequal(empty ./ c, []);
+assert_checkequal(empty ./ R, []);
+assert_checkequal(empty ./ C, []);
+assert_checkequal(empty ./ e, []);
+assert_checkequal(empty ./ ec, []);
+assert_checkequal(empty ./ p, []);
+assert_checkequal(empty ./ pc, []);
+assert_checkequal(empty ./ P, []);
+assert_checkequal(empty ./ PC, []);
+assert_checkequal(empty ./ SP, []);
+assert_checkequal(empty ./ SPC, []);
+assert_checkequal(empty ./ SP1, []);
+assert_checkequal(empty ./ SPC1, []);
+
+assert_checkequal(r ./ empty, []);
+assert_checkequal(r ./ r,  1);
+assert_checkequal(r ./ c,  0.4-%i* 0.8);
+assert_checkequal(r ./ R, [ 2, 1; (2/3), 0.5]);
+assert_checkequal(r ./ C, [ 0.4-%i* 0.8, 0.2-%i* 0.4; 2/15-%i* 4/15, 0.1-%i* 0.2]);
+assert_checkequal(r ./ e, ( 2)*eye());
+assert_checkalmostequal(r ./ ec, ( 1/2.6-%i* 1/13)*eye());
+
+test = r ./ p;
+assert_checkequal(test(2), 2+0*%s);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = r ./ pc;
+assert_checkequal(test(2), 2+0*%s);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = r ./ P;
+assert_checkequal(test(2), [2,2;2,2]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = r ./ PC;
+assert_checkequal(test(2), [2,2;2,2]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(r ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 2; (2/3); 1],[ 4, 10]));
+assert_checkequal(r ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 2/17-%i* 8/17; 2/51-%i* 8/51; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(r ./ SP1, sparse([ 1, 1], 0.2,[ 1, 1]));
+assert_checkalmostequal(r ./ SPC1, sparse([ 1, 1], 0.1-%i* 0.3,[ 1, 1]));
+assert_checkequal(r ./ i8, int8( 0));
+assert_checkequal(r ./ I8, int8([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui8, uint8( 0));
+assert_checkequal(r ./ UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(r ./ i16, int16( 0));
+assert_checkequal(r ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui16, uint16( 0));
+assert_checkequal(r ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(r ./ i32, int32( 0));
+assert_checkequal(r ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(r ./ ui32, uint32( 0));
+assert_checkequal(r ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(c ./ empty, []);
+assert_checkequal(c ./ r,  0.5+%i);
+assert_checkequal(c ./ c,  1+%i*0);
+assert_checkequal(c ./ R,  0.2-%i* 0.4);
+assert_checkequal(c ./ C, [ 1, 0.5; (1/3), 0.25]+%i*0);
+assert_checkequal(c ./ e, ( 1+%i* 2)*eye());
+assert_checkequal(c ./ ec, ( 7/26+%i* 9/26)*eye());
+test = c ./ p;
+assert_checkequal(test(2), 1+%i*2+0*%s);
+assert_checkequal(test(3), 1+(1)*s+(- 1)*s^ 2);
+test = c ./ pc;
+assert_checkequal(test(2), 1+%i*2+0*%s);
+assert_checkequal(test(3), 1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2);
+test = c ./ P;
+assert_checkequal(test(2), [1,1;1,1]*(1+%i*2)+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = c ./ PC;
+assert_checkequal(test(2), [1,1;1,1]*(1+%i*2)+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(c ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 2; (1/3)+%i* (2/3); 0.5+%i],[ 4, 10]));
+assert_checkequal(c ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 9/17-%i* 2/17; 3/17-%i* 2/51; 9/34-%i* 1/17],[ 4, 10]));
+assert_checkequal(c ./ SP1, sparse([ 1, 1], 0.1+%i* 0.2,[ 1, 1]));
+assert_checkalmostequal(c ./ SPC1, sparse([ 1, 1], 0.35-%i* 0.05,[ 1, 1]));
+
+assert_checkequal(R ./ empty, []);
+assert_checkequal(R ./ r, [ 0.5, 1; 1.5, 2]);
+assert_checkequal(R ./ c, [ 0.2-%i* 0.4, 0.4-%i* 0.8; 0.6-%i* 1.2, 0.8-%i* 1.60]);
+assert_checkequal(R ./ R, [ 1, 1; 1, 1]);
+assert_checkequal(R ./ C, [ 0.2-%i* 0.4, 0.2-%i* 0.4; 0.2-%i* 0.4, 0.2-%i* 0.4]);
+test = R ./ p;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3), [1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = R ./ pc;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3), [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = R ./ P;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = R ./ PC;
+assert_checkequal(test(2), [1,2;3,4]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(R ./ SP1, [ 0.1 ,0.2;0.3,0.4]);
+assert_checkequal(R ./ SPC1, [ 0.05-%i* 0.15, 0.1-%i* 0.3; 0.15-%i* 0.45, 0.2-%i* 0.6]);
+assert_checkequal(R ./ i8, int8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I8, int8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(R ./ i16, int16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(R ./ i32, int32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ ui32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(R ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(C ./ empty, []);
+assert_checkequal(C ./ r, [ 0.5+%i, 1+%i* 2; 1.5+%i* 3, 2+%i* 4]);
+assert_checkequal(C ./ c, [ 1, 2; 3, 4]+%i*0);
+assert_checkequal(C ./ R, [ 1+%i* 2, 1+%i* 2; 1+%i* 2, 1+%i* 2]);
+assert_checkequal(C ./ C, [ 1, 1; 1, 1]+%i*0);
+test = C ./ p;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3), [1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2;1+(1)*s+(- 1)*s^ 2,1+(1)*s+(- 1)*s^ 2]);
+test = C ./ pc;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3), [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2;1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2]);
+test = C ./ P;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3),[2+(2)*s+(- 2)*s^ 2,- 3+(- 3)*s+(3)*s^ 2;4+(4)*s+(- 4)*s^ 2,- 5+(- 5)*s+(5)*s^ 2]);
+test = C ./ PC;
+assert_checkequal(test(2), [1+%i* 2,2+%i* 4;3+%i* 6,4+%i* 8]+0*%s);
+assert_checkequal(test(3),[2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 3-%i* 6+(- 3+%i* 9)*s+(3-%i* 12)*s^ 2;4+%i* 8+(4-%i* 12)*s+(- 4+%i* 16)*s^ 2,- 5-%i* 10+(- 5+%i* 15)*s+(5-%i* 20)*s^ 2]);
+assert_checkequal(C ./ SP1, [ 0.1+0.2*%i,0.2+0.4*%i;0.3+0.6*%i,0.4+0.8*%i]);
+assert_checkequal(C ./ SPC1, [ 0.35-%i* 0.05, 0.7-%i* 0.1; 1.05-%i* 0.15, 1.4-%i* 0.2]);
+
+assert_checkequal(e ./ empty, []);
+assert_checkequal(e ./ r, ( 0.5)*eye());
+assert_checkequal(e ./ c, ( 1+%i* 2)*eye());
+assert_checkequal(e ./ e, ( 1)*eye());
+assert_checkequal(e ./ ec, ( 5/26-%i* 1/26)*eye());
+assert_checkequal(e ./ SP1, ( 0.1)*eye());
+assert_checkequal(e ./ SPC1, ( 2+%i* 6)*eye());
+assert_checkequal(e ./ i8, int8(( 0)*eye()));
+assert_checkequal(e ./ ui8, uint8(( 0)*eye()));
+assert_checkequal(e ./ i16, int16(( 0)*eye()));
+assert_checkequal(e ./ ui16, uint16(( 0)*eye()));
+assert_checkequal(e ./ i32, int32(( 0)*eye()));
+assert_checkequal(e ./ ui32, uint32(( 0)*eye()));
+
+assert_checkequal(ec ./ empty, []);
+assert_checkequal(ec ./ r, ( 2.5+%i* 0.5)*eye());
+assert_checkequal(ec ./ c, ( 1.4-%i* 1.8)*eye());
+assert_checkequal(ec ./ e, ( 5+%i)*eye());
+assert_checkequal(ec ./ ec, ( 1+%i*0)*eye());
+
+assert_checkequal(p ./ empty, []);
+assert_checkequal(p ./ r, 0.5+(0.5)*s+(- 0.5)*s^ 2);
+assert_checkequal(p ./ c, 0.2-%i* 0.08+(0.2-%i* 0.08)*s+(- 0.2+%i* 0.08)*s^ 2);
+assert_checkequal(p ./ R, [1+(1)*s+(- 1)*s^ 2,0.5+(0.5)*s+(- 0.5)*s^ 2;(1/3)+((1/3))*s+(- (1/3))*s^ 2,0.25+(0.25)*s+(- 0.25)*s^ 2]);
+assert_checkequal(p ./ C, [0.2-%i* 0.4+(0.2-%i* 0.4)*s+(- 0.2+%i* 0.4)*s^ 2,0.1-%i* 0.2+(0.1-%i* 0.2)*s+(- 0.1+%i* 0.2)*s^ 2;1/15-%i* 2/15+(1/15-%i* 2/15)*s+(- 1/15+%i* 2/15)*s^ 2,0.05-%i* 0.1+(0.05-%i* 0.1)*s+(- 0.05+%i* 0.1)*s^ 2]);
+test = p ./ p;
+assert_checkequal(test(2), 1+s*0);
+assert_checkequal(test(3), 1+s*0);
+test = p ./ pc;
+assert_checkequal(test(2), 1+s-s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = p ./ P;
+assert_checkequal(test(2), [0.5,-(1/3);0.25,-0.2]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+s*0);
+test = p ./ PC;
+assert_checkequal(test(2), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+
+assert_checkequal(pc ./ empty, []);
+assert_checkequal(pc ./ r, 0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2);
+assert_checkequal(pc ./ c, 1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2);
+assert_checkequal(pc ./ R, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,0.5+%i+(0.5-%i* 1.5)*s+(- 0.5+%i* 2)*s^ 2;(1/3)+%i* (2/3)+((1/3)-%i)*s+(- (1/3)+%i* (1+1/3))*s^ 2,0.25+%i* 0.5+(0.25-%i* 0.75)*s+(- 0.25+%i)*s^ 2]);
+assert_checkequal(pc ./ C, [1+(- 1-%i)*s+(1.4+%i* 1.2)*s^ 2,0.5+(- 0.5-%i* 0.5)*s+(0.7+%i* 0.6)*s^ 2;(1/3)+(- (1/3)-%i* (1/3))*s+(7/15+%i* 0.4)*s^ 2,0.25+(- 0.25-%i* 0.25)*s+(0.35+%i* 0.3)*s^ 2]);
+test = pc ./ p;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+s-s^2);
+test = pc ./ pc;
+assert_checkequal(test(2), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+assert_checkequal(test(3), 1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2);
+test = pc ./ P;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = pc ./ PC;
+assert_checkequal(test(2), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+
+assert_checkequal(P ./ empty, []);
+assert_checkequal(P ./ r, [1+(1)*s+(- 1)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;2+(2)*s+(- 2)*s^ 2,- 2.5+(- 2.5)*s+(2.5)*s^ 2]);
+assert_checkequal(P ./ c, [0.4-%i* 0.16+(0.4-%i* 0.16)*s+(- 0.4+%i* 0.16)*s^ 2,- 0.6+%i* 0.24+(- 0.6+%i* 0.24)*s+(0.6-%i* 0.24)*s^ 2;0.8-%i* 0.32+(0.8-%i* 0.32)*s+(- 0.8+%i* 0.32)*s^ 2,- 1+%i* 0.4+(- 1+%i* 0.4)*s+(1-%i* 0.4)*s^ 2]);
+assert_checkequal(P ./ R, [2+(2)*s+(- 2)*s^ 2,- 1.5+(- 1.5)*s+(1.5)*s^ 2;(1+1/3)+((1+1/3))*s+(- (1+1/3))*s^ 2,- 1.25+(- 1.25)*s+(1.25)*s^ 2]);
+assert_checkequal(P ./ C, [0.4-%i* 0.8+(0.4-%i* 0.8)*s+(- 0.4+%i* 0.8)*s^ 2,- 0.3+%i* 0.6+(- 0.3+%i* 0.6)*s+(0.3-%i* 0.6)*s^ 2;4/15-%i* 8/15+(4/15-%i* 8/15)*s+(- 4/15+%i* 8/15)*s^ 2,- 0.25+%i* 0.5+(- 0.25+%i* 0.5)*s+(0.25-%i* 0.5)*s^ 2]);
+test = P ./ p;
+assert_checkequal(test(2), [2,-3;4,-5]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+s*0);
+test = P ./ pc;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = P ./ P;
+assert_checkequal(test(2), [1,1;1,1]+s*0);
+assert_checkequal(test(3), [1,1;1,1]+%s*0);
+test = P ./ PC;
+assert_checkequal(test(2), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+
+assert_checkequal(PC ./ empty, []);
+assert_checkequal(PC ./ r, [1+%i* 2+(1-%i* 3)*s+(- 1+%i* 4)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 2.5-%i* 5+(- 2.5+%i* 7.5)*s+(2.5-%i* 10)*s^ 2]);
+assert_checkequal(PC ./ c, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 3+(3+%i* 3)*s+(- 4.2-%i* 3.6)*s^ 2;4+(- 4-%i* 4)*s+(5.6+%i* 4.8)*s^ 2,- 5+(5+%i* 5)*s+(- 7-%i* 6)*s^ 2]);
+assert_checkequal(PC ./ R, [2+%i* 4+(2-%i* 6)*s+(- 2+%i* 8)*s^ 2,- 1.5-%i* 3+(- 1.5+%i* 4.5)*s+(1.5-%i* 6)*s^ 2;(1+1/3)+%i* 8/3+((1+1/3)-%i* 4)*s+(- (1+1/3)+%i* 16/3)*s^ 2,- 1.25-%i* 2.5+(- 1.25+%i* 3.75)*s+(1.25-%i* 5)*s^ 2]);
+assert_checkequal(PC ./ C, [2+(- 2-%i* 2)*s+(2.8+%i* 2.4)*s^ 2,- 1.5+(1.5+%i* 1.5)*s+(- 2.1-%i* 1.8)*s^ 2;(1+1/3)+(- (1+1/3)-%i* (1+1/3))*s+(28/15+%i* 1.6)*s^ 2,- 1.25+(1.25+%i* 1.25)*s+(- 1.75-%i* 1.5)*s^ 2]);
+test = PC ./ p;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+s-s^2,1+s-s^2;1+s-s^2,1+s-s^2]);
+test = PC ./ pc;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2;1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2,1+%i*2+(1-%i*3)*s+(-1+%i*4)*s^2]);
+test = PC ./ P;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+2*s-2*s^2,-3-3*s+3*s^2;4+4*s-4*s^2,-5-5*s+5*s^2]);
+test = PC ./ PC;
+assert_checkequal(test(2), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+assert_checkequal(test(3), [2+%i*4+(2-%i*6)*s+(-2+%i*8)*s^2,-3-%i*6+(-3+%i*9)*s+(3-%i*12)*s^2;4+%i*8+(4-%i*12)*s+(-4+%i*16)*s^2,-5-%i*10+(-5+%i*15)*s+(5-%i*20)*s^2]);
+
+assert_checkequal(SP ./ empty, []);
+assert_checkequal(SP ./ r, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5; 1.5; 1],[ 4, 10]));
+assert_checkequal(SP ./ c, sparse([ 1, 2; 3, 10; 4, 5],[ 0.2-%i* 0.4; 0.6-%i* 1.2; 0.4-%i* 0.8],[ 4, 10]));
+assert_checkequal(SP ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SP ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1/17-%i* 4/17; 1/17-%i* 4/17; 1/17-%i* 4/17],[ 4, 10]));
+assert_checkequal(SP ./ SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1; 0.3; 0.2],[ 4, 10]));
+assert_checkalmostequal(SP ./ SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.05-%i* 0.15; 0.15-%i* 0.45; 0.1-%i* 0.3],[ 4, 10]));
+
+assert_checkequal(SPC ./ empty, []);
+assert_checkequal(SPC ./ r, sparse([ 1, 2; 3, 10; 4, 5],[ 0.5+%i* 2; 1.5+%i* 6; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SPC ./ c, sparse([ 1, 2; 3, 10; 4, 5],[ 1.8+%i* 0.4; 5.4+%i* 1.2; 3.6+%i* 0.8],[ 4, 10]));
+assert_checkequal(SPC ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 1+%i* 4; 1+%i* 4; 1+%i* 4],[ 4, 10]));
+assert_checkequal(SPC ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 1; 1; 1],[ 4, 10]));
+assert_checkequal(SPC ./ SP1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.1+%i* 0.4; 0.3+%i* 1.2; 0.2+%i* 0.8],[ 4, 10]));
+assert_checkalmostequal(SPC ./ SPC1, sparse([ 1, 2; 3, 10; 4, 5],[ 0.65+%i* 0.05; 1.95+%i* 0.15; 1.3+%i* 0.1],[ 4, 10]));
+
+assert_checkequal(SP1 ./ empty, []);
+assert_checkequal(SP1 ./ r, sparse([ 1, 1], 5,[ 1, 1]));
+assert_checkequal(SP1 ./ c, sparse([ 1, 1], 2-%i* 4,[ 1, 1]));
+assert_checkequal(SP1 ./ R, [ 10, 5; (3+1/3), 2.5]);
+assert_checkequal(SP1 ./ C, [ 2-%i* 4, 1-%i* 2; (2/3)-%i* (1+1/3), 0.5-%i]);
+assert_checkequal(SP1 ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 10; (3+1/3); 5],[ 4, 10]));
+assert_checkequal(SP1 ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 10/17-%i* 40/17; 10/51-%i* 40/51; 10/34-%i* 20/17],[ 4, 10]));
+assert_checkequal(SP1 ./ SP1, sparse([ 1, 1], 1,[ 1, 1]));
+assert_checkalmostequal(SP1 ./ SPC1, sparse([ 1, 1], 0.5-%i* 1.5,[ 1, 1]));
+
+assert_checkequal(SPC1 ./ empty, []);
+assert_checkequal(SPC1 ./ r, sparse([ 1, 1], 1+%i* 3,[ 1, 1]));
+assert_checkequal(SPC1 ./ c, sparse([ 1, 1], 2.8+%i* 0.4,[ 1, 1]));
+assert_checkequal(SPC1 ./ R,  0.05-%i* 0.15);
+assert_checkequal(SPC1 ./ C, [ 2.8+%i* 0.4, 1.4+%i* 0.2; 14/15+%i* 2/15, 0.7+%i* 0.1]);
+assert_checkequal(SPC1 ./ SP, sparse([ 1, 2; 3, 10; 4, 5],[ 2+%i* 6; (2/3)+%i* 2; 1+%i* 3],[ 4, 10]));
+assert_checkequal(SPC1 ./ SPC, sparse([ 1, 2; 3, 10; 4, 5],[ 26/17-%i* 2/17; 26/51-%i* 2/51; 13/17-%i* 1/17],[ 4, 10]));
+assert_checkequal(SPC1 ./ SP1, sparse([ 1, 1], 0.2+%i* 0.6,[ 1, 1]));
+assert_checkequal(SPC1 ./ SPC1, sparse([ 1, 1], 1,[ 1, 1]));
+
+assert_checkequal(i8 ./ r, int8( - 4));
+assert_checkequal(i8 ./ R, int8([ - 8, - 4; - 2, - 2]));
+assert_checkequal(i8 ./ i8, int8( 1));
+assert_checkequal(i8 ./ I8, int8([ 1, 0; 0, 0]));
+assert_checkequal(i8 ./ ui8, uint8( 31));
+assert_checkequal(i8 ./ UI8, uint8([ 31, 15; 10, 7]));
+assert_checkequal(i8 ./ i16, int16( 0));
+assert_checkequal(i8 ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(i8 ./ ui16, uint16( 4095));
+assert_checkequal(i8 ./ UI16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(i8 ./ i32, int32( 0));
+assert_checkequal(i8 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(i8 ./ ui32, uint32( 134217727));
+assert_checkequal(i8 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+
+assert_checkequal(I8 ./ r, int8([ - 4, - 8; - 12, - 16]));
+assert_checkequal(I8 ./ R, int8([ - 8, - 8; - 8, - 8]));
+assert_checkequal(I8 ./ i8, int8([ 1, 2; 3, 4]));
+assert_checkequal(I8 ./ I8, int8([ 1, 1; 1, 1]));
+assert_checkequal(I8 ./ ui8, uint8([ 31, 30; 29, 28]));
+assert_checkequal(I8 ./ UI8, uint8([ 31, 15; 9, 7]));
+assert_checkequal(I8 ./ i16, int16([ 0, 1; 1, 2]));
+assert_checkequal(I8 ./ I16, int16([ 0, 0; 0, 0]));
+assert_checkequal(I8 ./ ui16, uint16([ 4095, 4095; 4094, 4094]));
+assert_checkequal(I8 ./ UI16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(I8 ./ i32, int32([ 0, 0; 0, 1]));
+assert_checkequal(I8 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(I8 ./ ui32, uint32([ 134217727, 134217727; 134217727, 134217727]));
+assert_checkequal(I8 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+
+assert_checkequal(ui8 ./ r, uint8( 4));
+assert_checkequal(ui8 ./ R, uint8([ 8, 4; 2, 2]));
+assert_checkequal(ui8 ./ i8, uint8( 0));
+assert_checkequal(ui8 ./ I8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui8, uint8( 1));
+assert_checkequal(ui8 ./ UI8, uint8([ 1, 0; 0, 0]));
+assert_checkequal(ui8 ./ i16, uint16( 0));
+assert_checkequal(ui8 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui16, uint16( 0));
+assert_checkequal(ui8 ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ i32, uint32( 0));
+assert_checkequal(ui8 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui8 ./ ui32, uint32( 0));
+assert_checkequal(ui8 ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(UI8 ./ r, uint8([ 4, 8; 12, 16]));
+assert_checkequal(UI8 ./ R, uint8([ 8, 8; 8, 8]));
+assert_checkequal(UI8 ./ i8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I8, uint8([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui8, uint8([ 1, 2; 3, 4]));
+assert_checkequal(UI8 ./ UI8, uint8([ 1, 1; 1, 1]));
+assert_checkequal(UI8 ./ i16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui16, uint16([ 0, 1; 1, 2]));
+assert_checkequal(UI8 ./ UI16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI8 ./ ui32, uint32([ 0, 0; 0, 1]));
+assert_checkequal(UI8 ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(i16 ./ r, int16( - 8));
+assert_checkequal(i16 ./ R, int16([ - 16, - 8; - 5, - 4]));
+assert_checkequal(i16 ./ i8, int16( 2));
+assert_checkequal(i16 ./ I8, int16([ 2, 1; 0, 0]));
+assert_checkequal(i16 ./ ui8, uint16( 8190));
+assert_checkequal(i16 ./ UI8, uint16([ 8190, 4095; 2730, 2047]));
+assert_checkequal(i16 ./ i16, int16( 1));
+assert_checkequal(i16 ./ I16, int16([ 1, 0; 0, 0]));
+assert_checkequal(i16 ./ ui16, uint16( 4095));
+assert_checkequal(i16 ./ UI16, uint16([ 4095, 2047; 1365, 1023]));
+assert_checkequal(i16 ./ i32, int32( 0));
+assert_checkequal(i16 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(i16 ./ ui32, uint32( 134217727));
+assert_checkequal(i16 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+
+assert_checkequal(I16 ./ r, int16([ - 8, - 16; - 24, - 32]));
+assert_checkequal(I16 ./ R, int16([ - 16, - 16; - 16, - 16]));
+assert_checkequal(I16 ./ i8, int16([ 2, 4; 6, 8]));
+assert_checkequal(I16 ./ I8, int16([ 2, 2; 2, 2]));
+assert_checkequal(I16 ./ ui8, uint16([ 8190, 8188; 8186, 8184]));
+assert_checkequal(I16 ./ UI8, uint16([ 8190, 4094; 2728, 2046]));
+assert_checkequal(I16 ./ i16, int16([ 1, 2; 3, 4]));
+assert_checkequal(I16 ./ I16, int16([ 1, 1; 1, 1]));
+assert_checkequal(I16 ./ ui16, uint16([ 4095, 4094; 4093, 4092]));
+assert_checkequal(I16 ./ UI16, uint16([ 4095, 2047; 1364, 1023]));
+assert_checkequal(I16 ./ i32, int32([ 0, 1; 1, 2]));
+assert_checkequal(I16 ./ I32, int32([ 0, 0; 0, 0]));
+assert_checkequal(I16 ./ ui32, uint32([ 134217727, 134217727; 134217726, 134217726]));
+assert_checkequal(I16 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+
+assert_checkequal(ui16 ./ r, uint16( 8));
+assert_checkequal(ui16 ./ R, uint16([ 16, 8; 5, 4]));
+assert_checkequal(ui16 ./ i8, uint16( 0));
+assert_checkequal(ui16 ./ I8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui8, uint16( 2));
+assert_checkequal(ui16 ./ UI8, uint16([ 2, 1; 0, 0]));
+assert_checkequal(ui16 ./ i16, uint16( 0));
+assert_checkequal(ui16 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui16, uint16( 1));
+assert_checkequal(ui16 ./ UI16, uint16([ 1, 0; 0, 0]));
+assert_checkequal(ui16 ./ i32, uint32( 0));
+assert_checkequal(ui16 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui16 ./ ui32, uint32( 0));
+assert_checkequal(ui16 ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(UI16 ./ r, uint16([ 8, 16; 24, 32]));
+assert_checkequal(UI16 ./ R, uint16([ 16, 16; 16, 16]));
+assert_checkequal(UI16 ./ i8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I8, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui8, uint16([ 2, 4; 6, 8]));
+assert_checkequal(UI16 ./ UI8, uint16([ 2, 2; 2, 2]));
+assert_checkequal(UI16 ./ i16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I16, uint16([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui16, uint16([ 1, 2; 3, 4]));
+assert_checkequal(UI16 ./ UI16, uint16([ 1, 1; 1, 1]));
+assert_checkequal(UI16 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI16 ./ ui32, uint32([ 0, 1; 1, 2]));
+assert_checkequal(UI16 ./ UI32, uint32([ 0, 0; 0, 0]));
+
+assert_checkequal(i32 ./ r, int32( - 16));
+assert_checkequal(i32 ./ R, int32([ - 32, - 16; - 10, - 8]));
+assert_checkequal(i32 ./ i8, int32( 4));
+assert_checkequal(i32 ./ I8, int32([ 4, 2; 1, 1]));
+assert_checkequal(i32 ./ ui8, uint32( 536870908));
+assert_checkequal(i32 ./ UI8, uint32([ 536870908, 268435454; 178956969, 134217727]));
+assert_checkequal(i32 ./ i16, int32( 2));
+assert_checkequal(i32 ./ I16, int32([ 2, 1; 0, 0]));
+assert_checkequal(i32 ./ ui16, uint32( 268435454));
+assert_checkequal(i32 ./ UI16, uint32([ 268435454, 134217727; 89478484, 67108863]));
+assert_checkequal(i32 ./ i32, int32( 1));
+assert_checkequal(i32 ./ I32, int32([ 1, 0; 0, 0]));
+assert_checkequal(i32 ./ ui32, uint32( 134217727));
+assert_checkequal(i32 ./ UI32, uint32([ 134217727, 67108863; 44739242, 33554431]));
+
+assert_checkequal(I32 ./ r, int32([ - 16, - 32; - 48, - 64]));
+assert_checkequal(I32 ./ R, int32([ - 32, - 32; - 32, - 32]));
+assert_checkequal(I32 ./ i8, int32([ 4, 8; 12, 16]));
+assert_checkequal(I32 ./ I8, int32([ 4, 4; 4, 4]));
+assert_checkequal(I32 ./ ui8, uint32([ 536870908, 536870904; 536870900, 536870896]));
+assert_checkequal(I32 ./ UI8, uint32([ 536870908, 268435452; 178956966, 134217724]));
+assert_checkequal(I32 ./ i16, int32([ 2, 4; 6, 8]));
+assert_checkequal(I32 ./ I16, int32([ 2, 2; 2, 2]));
+assert_checkequal(I32 ./ ui16, uint32([ 268435454, 268435452; 268435450, 268435448]));
+assert_checkequal(I32 ./ UI16, uint32([ 268435454, 134217726; 89478483, 67108862]));
+assert_checkequal(I32 ./ i32, int32([ 1, 2; 3, 4]));
+assert_checkequal(I32 ./ I32, int32([ 1, 1; 1, 1]));
+assert_checkequal(I32 ./ ui32, uint32([ 134217727, 134217726; 134217725, 134217724]));
+assert_checkequal(I32 ./ UI32, uint32([ 134217727, 67108863; 44739241, 33554431]));
+
+assert_checkequal(ui32 ./ r, uint32( 16));
+assert_checkequal(ui32 ./ R, uint32([ 32, 16; 10, 8]));
+assert_checkequal(ui32 ./ i8, uint32( 0));
+assert_checkequal(ui32 ./ I8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui8, uint32( 4));
+assert_checkequal(ui32 ./ UI8, uint32([ 4, 2; 1, 1]));
+assert_checkequal(ui32 ./ i16, uint32( 0));
+assert_checkequal(ui32 ./ I16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui16, uint32( 2));
+assert_checkequal(ui32 ./ UI16, uint32([ 2, 1; 0, 0]));
+assert_checkequal(ui32 ./ i32, uint32( 0));
+assert_checkequal(ui32 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(ui32 ./ ui32, uint32( 1));
+assert_checkequal(ui32 ./ UI32, uint32([ 1, 0; 0, 0]));
+
+assert_checkequal(UI32 ./ r, uint32([ 16, 32; 48, 64]));
+assert_checkequal(UI32 ./ R, uint32([ 32, 32; 32, 32]));
+assert_checkequal(UI32 ./ i8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I8, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui8, uint32([ 4, 8; 12, 16]));
+assert_checkequal(UI32 ./ UI8, uint32([ 4, 4; 4, 4]));
+assert_checkequal(UI32 ./ i16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I16, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui16, uint32([ 2, 4; 6, 8]));
+assert_checkequal(UI32 ./ UI16, uint32([ 2, 2; 2, 2]));
+assert_checkequal(UI32 ./ i32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ I32, uint32([ 0, 0; 0, 0]));
+assert_checkequal(UI32 ./ ui32, uint32([ 1, 2; 3, 4]));
+assert_checkequal(UI32 ./ UI32, uint32([ 1, 1; 1, 1]));
+