scilab/modules/ast/src/cpp/operations/types_subtraction.cpp

   1 /*
   2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
   4 *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
   5 *
   6 *  This file must be used under the terms of the CeCILL.
   7 *  This source file is licensed as described in the file COPYING, which
   8 *  you should have received as part of this distribution.  The terms
   9 *  are also available at
  10 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  11 *
  12 */
  13
  14 #include <stdio.h>
  15
  16 #include "types_subtraction.hxx"
  17 #include "types_opposite.hxx"
  18 #include "double.hxx"
  19 #include "polynom.hxx"
  20 #include "int.hxx"
  21 #include "sparse.hxx"
  22 #include "generic_operations.hxx"
  23
  24 extern "C"
  25 {
  26 #include "elem_common.h" //dset
  27 }
  28
  29 using namespace types;
  30
  31 //define arrays on operation functions
  32 static sub_function pSubfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
  33
  34 void fillSubtractFunction()
  35 {
  36 #define scilab_fill_sub(id1, id2, func, typeIn1, typeIn2, typeOut) \
  37     pSubfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (sub_function)&sub_##func<typeIn1, typeIn2, typeOut>
  38
  39     //Double
  40     //Matrix - Matrix
  41     scilab_fill_sub(Double, Double, M_M, Double, Double, Double);
  42     scilab_fill_sub(Double, Int8, M_M, Double, Int8, Int8);
  43     scilab_fill_sub(Double, UInt8, M_M, Double, UInt8, UInt8);
  44     scilab_fill_sub(Double, Int16, M_M, Double, Int16, Int16);
  45     scilab_fill_sub(Double, UInt16, M_M, Double, UInt16, UInt16);
  46     scilab_fill_sub(Double, Int32, M_M, Double, Int32, Int32);
  47     scilab_fill_sub(Double, UInt32, M_M, Double, UInt32, UInt32);
  48     scilab_fill_sub(Double, Int64, M_M, Double, Int64, Int64);
  49     scilab_fill_sub(Double, UInt64, M_M, Double, UInt64, UInt64);
  50     scilab_fill_sub(Double, Bool, M_M, Double, Bool, Double);
  51     scilab_fill_sub(Double, Polynom, M_M, Double, Polynom, Polynom);
  52     scilab_fill_sub(Double, Sparse, M_M, Double, Sparse, Double);
  53
  54     //Matrix - Matrix Complex
  55     scilab_fill_sub(Double, DoubleComplex, M_MC, Double, Double, Double);
  56     scilab_fill_sub(Double, PolynomComplex, M_M, Double, Polynom, Polynom);
  57     scilab_fill_sub(Double, SparseComplex, M_M, Double, Sparse, Double);
  58
  59     //Matrix - Scalar
  60     scilab_fill_sub(Double, ScalarDouble, M_S, Double, Double, Double);
  61     scilab_fill_sub(Double, ScalarInt8, M_S, Double, Int8, Int8);
  62     scilab_fill_sub(Double, ScalarUInt8, M_S, Double, UInt8, UInt8);
  63     scilab_fill_sub(Double, ScalarInt16, M_S, Double, Int16, Int16);
  64     scilab_fill_sub(Double, ScalarUInt16, M_S, Double, UInt16, UInt16);
  65     scilab_fill_sub(Double, ScalarInt32, M_S, Double, Int32, Int32);
  66     scilab_fill_sub(Double, ScalarUInt32, M_S, Double, UInt32, UInt32);
  67     scilab_fill_sub(Double, ScalarInt64, M_S, Double, Int64, Int64);
  68     scilab_fill_sub(Double, ScalarUInt64, M_S, Double, UInt64, UInt64);
  69     scilab_fill_sub(Double, ScalarBool, M_S, Double, Bool, Double);
  70     scilab_fill_sub(Double, ScalarPolynom, M_M, Double, Polynom, Polynom);
  71
  72     //Matrix - Scalar Complex
  73     scilab_fill_sub(Double, ScalarDoubleComplex, M_SC, Double, Double, Double);
  74     scilab_fill_sub(Double, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
  75     //Matrix - Empty
  76     scilab_fill_sub(Double, Empty, M_E, Double, Double, Double);
  77
  78
  79     //Matrix Complex - Matrix
  80     scilab_fill_sub(DoubleComplex, Double, MC_M, Double, Double, Double);
  81     scilab_fill_sub(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Double);
  82     scilab_fill_sub(DoubleComplex, ScalarDouble, MC_S, Double, Double, Double);
  83     scilab_fill_sub(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Double);
  84     scilab_fill_sub(DoubleComplex, Empty, MC_E, Double, Double, Double);
  85     scilab_fill_sub(DoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
  86     scilab_fill_sub(DoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
  87     scilab_fill_sub(DoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
  88     scilab_fill_sub(DoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
  89     scilab_fill_sub(DoubleComplex, Sparse, M_M, Double, Sparse, Double);
  90     scilab_fill_sub(DoubleComplex, SparseComplex, M_M, Double, Sparse, Double);
  91
  92     //Scalar - Matrix
  93     scilab_fill_sub(ScalarDouble, Double, S_M, Double, Double, Double);
  94     scilab_fill_sub(ScalarDouble, Int8, S_M, Double, Int8, Int8);
  95     scilab_fill_sub(ScalarDouble, UInt8, S_M, Double, UInt8, UInt8);
  96     scilab_fill_sub(ScalarDouble, Int16, S_M, Double, Int16, Int16);
  97     scilab_fill_sub(ScalarDouble, UInt16, S_M, Double, UInt16, UInt16);
  98     scilab_fill_sub(ScalarDouble, Int32, S_M, Double, Int32, Int32);
  99     scilab_fill_sub(ScalarDouble, UInt32, S_M, Double, UInt32, UInt32);
 100     scilab_fill_sub(ScalarDouble, Int64, S_M, Double, Int64, Int64);
 101     scilab_fill_sub(ScalarDouble, UInt64, S_M, Double, UInt64, UInt64);
 102     scilab_fill_sub(ScalarDouble, Bool, S_M, Double, Bool, Double);
 103     scilab_fill_sub(ScalarDouble, Polynom, M_M, Double, Polynom, Polynom);
 104     scilab_fill_sub(ScalarDouble, Sparse, M_M, Double, Sparse, Double);
 105
 106     //Scalar - Matrix Complex
 107     scilab_fill_sub(ScalarDouble, DoubleComplex, S_MC, Double, Double, Double);
 108     scilab_fill_sub(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
 109     scilab_fill_sub(ScalarDouble, SparseComplex, M_M, Double, Sparse, Double);
 110
 111     //Scalar - Scalar
 112     scilab_fill_sub(ScalarDouble, ScalarDouble, S_S, Double, Double, Double);
 113     scilab_fill_sub(ScalarDouble, ScalarInt8, S_S, Double, Int8, Int8);
 114     scilab_fill_sub(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, UInt8);
 115     scilab_fill_sub(ScalarDouble, ScalarInt16, S_S, Double, Int16, Int16);
 116     scilab_fill_sub(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, UInt16);
 117     scilab_fill_sub(ScalarDouble, ScalarInt32, S_S, Double, Int32, Int32);
 118     scilab_fill_sub(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, UInt32);
 119     scilab_fill_sub(ScalarDouble, ScalarInt64, S_S, Double, Int64, Int64);
 120     scilab_fill_sub(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, UInt64);
 121     scilab_fill_sub(ScalarDouble, ScalarBool, S_S, Double, Bool, Double);
 122     scilab_fill_sub(ScalarDouble, ScalarPolynom, M_M, Double, Polynom, Polynom);
 123
 124     //Scalar - Scalar Complex
 125     scilab_fill_sub(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Double);
 126     scilab_fill_sub(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
 127     scilab_fill_sub(ScalarDouble, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 128
 129     //Scalar - Empty
 130     scilab_fill_sub(ScalarDouble, Empty, S_E, Double, Double, Double);
 131
 132     //Scalar Complex - Matrix
 133     scilab_fill_sub(ScalarDoubleComplex, Double, SC_M, Double, Double, Double);
 134     scilab_fill_sub(ScalarDoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
 135     scilab_fill_sub(ScalarDoubleComplex, Sparse, M_M, Double, Sparse, Double);
 136     //Scalar Complex - Matrix Complex
 137     scilab_fill_sub(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Double);
 138     scilab_fill_sub(ScalarDoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
 139     scilab_fill_sub(ScalarDoubleComplex, SparseComplex, M_M, Double, Sparse, Double);
 140     //Scalar Complex - Scalar
 141     scilab_fill_sub(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Double);
 142     scilab_fill_sub(ScalarDoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
 143     //Scalar Complex - Scalar Complex
 144     scilab_fill_sub(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Double);
 145     scilab_fill_sub(ScalarDoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 146     //Scalar Complex - Empty
 147     scilab_fill_sub(ScalarDoubleComplex, Empty, SC_E, Double, Double, Double);
 148
 149     //Empty - Matrix
 150     scilab_fill_sub(Empty, Double, E_M, Double, Double, Double);
 151     scilab_fill_sub(Empty, Int8, E_M, Double, Int8, Int8);
 152     scilab_fill_sub(Empty, UInt8, E_M, Double, UInt8, UInt8);
 153     scilab_fill_sub(Empty, Int16, E_M, Double, Int16, Int16);
 154     scilab_fill_sub(Empty, UInt16, E_M, Double, UInt16, UInt16);
 155     scilab_fill_sub(Empty, Int32, E_M, Double, Int32, Int32);
 156     scilab_fill_sub(Empty, UInt32, E_M, Double, UInt32, UInt32);
 157     scilab_fill_sub(Empty, Int64, E_M, Double, Int64, Int64);
 158     scilab_fill_sub(Empty, UInt64, E_M, Double, UInt64, UInt64);
 159     //scilab_fill_sub(Empty, Bool, E_M, Double, Bool, Double);
 160     scilab_fill_sub(Empty, Polynom, E_M, Double, Polynom, Polynom);
 161     scilab_fill_sub(Empty, PolynomComplex, E_MC, Double, Polynom, Polynom);
 162     scilab_fill_sub(Empty, Sparse, E_M, Double, Sparse, Sparse);
 163     scilab_fill_sub(Empty, SparseComplex, E_MC, Double, Sparse, Sparse);
 164
 165     //Empty - Matrix Complex
 166     scilab_fill_sub(Empty, DoubleComplex, E_MC, Double, Double, Double);
 167     //Empty - Scalar
 168     scilab_fill_sub(Empty, ScalarDouble, E_M, Double, Double, Double);
 169     scilab_fill_sub(Empty, ScalarInt8, E_M, Double, Int8, Int8);
 170     scilab_fill_sub(Empty, ScalarUInt8, E_M, Double, UInt8, UInt8);
 171     scilab_fill_sub(Empty, ScalarInt16, E_M, Double, Int16, Int16);
 172     scilab_fill_sub(Empty, ScalarUInt16, E_M, Double, UInt16, UInt16);
 173     scilab_fill_sub(Empty, ScalarInt32, E_M, Double, Int32, Int32);
 174     scilab_fill_sub(Empty, ScalarUInt32, E_M, Double, UInt32, UInt32);
 175     scilab_fill_sub(Empty, ScalarInt64, E_M, Double, Int64, Int64);
 176     scilab_fill_sub(Empty, ScalarUInt64, E_M, Double, UInt64, UInt64);
 177     scilab_fill_sub(Empty, ScalarBool, E_M, Double, Bool, Double);
 178     scilab_fill_sub(Empty, ScalarPolynom, E_M, Double, Polynom, Polynom);
 179
 180     //Empty - Scalar Complex
 181     scilab_fill_sub(Empty, ScalarDoubleComplex, E_MC, Double, Double, Double);
 182     scilab_fill_sub(Empty, ScalarPolynomComplex, E_MC, Double, Polynom, Polynom);
 183     //Empty - Empty
 184     scilab_fill_sub(Empty, Empty, E_M, Double, Double, Double);
 185     //Empty - eye
 186     scilab_fill_sub(Empty, Identity, E_I, Double, Double, Double);
 187     scilab_fill_sub(Empty, IdentityComplex, E_IC, Double, Double, Double);
 188
 189     //Matrix - Identity
 190     scilab_fill_sub(Double, Identity, M_I, Double, Double, Double);
 191     scilab_fill_sub(Double, IdentityComplex, M_IC, Double, Double, Double);
 192     scilab_fill_sub(DoubleComplex, Identity, MC_I, Double, Double, Double);
 193     scilab_fill_sub(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Double);
 194     scilab_fill_sub(ScalarDouble, Identity, S_I, Double, Double, Double);
 195     scilab_fill_sub(ScalarDouble, IdentityComplex, S_IC, Double, Double, Double);
 196     scilab_fill_sub(ScalarDoubleComplex, Identity, SC_I, Double, Double, Double);
 197     scilab_fill_sub(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Double);
 198
 199     //Int8
 200     //Matrix - Matrix
 201     scilab_fill_sub(Int8, Double, M_M, Int8, Double, Int8);
 202     scilab_fill_sub(Int8, Int8, M_M, Int8, Int8, Int8);
 203     scilab_fill_sub(Int8, UInt8, M_M, Int8, UInt8, UInt8);
 204     scilab_fill_sub(Int8, Int16, M_M, Int8, Int16, Int16);
 205     scilab_fill_sub(Int8, UInt16, M_M, Int8, UInt16, UInt16);
 206     scilab_fill_sub(Int8, Int32, M_M, Int8, Int32, Int32);
 207     scilab_fill_sub(Int8, UInt32, M_M, Int8, UInt32, UInt32);
 208     scilab_fill_sub(Int8, Int64, M_M, Int8, Int64, Int64);
 209     scilab_fill_sub(Int8, UInt64, M_M, Int8, UInt64, UInt64);
 210     scilab_fill_sub(Int8, Bool, M_M, Int8, Bool, Int8);
 211     scilab_fill_sub(Int8, Empty, M_E, Int8, Double, Int8);
 212
 213     //Matrix - Scalar
 214     scilab_fill_sub(Int8, ScalarDouble, M_S, Int8, Double, Int8);
 215     scilab_fill_sub(Int8, ScalarInt8, M_S, Int8, Int8, Int8);
 216     scilab_fill_sub(Int8, ScalarUInt8, M_S, Int8, UInt8, UInt8);
 217     scilab_fill_sub(Int8, ScalarInt16, M_S, Int8, Int16, Int16);
 218     scilab_fill_sub(Int8, ScalarUInt16, M_S, Int8, UInt16, UInt16);
 219     scilab_fill_sub(Int8, ScalarInt32, M_S, Int8, Int32, Int32);
 220     scilab_fill_sub(Int8, ScalarUInt32, M_S, Int8, UInt32, UInt32);
 221     scilab_fill_sub(Int8, ScalarInt64, M_S, Int8, Int64, Int64);
 222     scilab_fill_sub(Int8, ScalarUInt64, M_S, Int8, UInt64, UInt64);
 223     scilab_fill_sub(Int8, ScalarBool, M_S, Int8, Bool, Int8);
 224
 225     //Scalar - Matrix
 226     scilab_fill_sub(ScalarInt8, Double, S_M, Int8, Double, Int8);
 227     scilab_fill_sub(ScalarInt8, Int8, S_M, Int8, Int8, Int8);
 228     scilab_fill_sub(ScalarInt8, UInt8, S_M, Int8, UInt8, UInt8);
 229     scilab_fill_sub(ScalarInt8, Int16, S_M, Int8, Int16, Int16);
 230     scilab_fill_sub(ScalarInt8, UInt16, S_M, Int8, UInt16, UInt16);
 231     scilab_fill_sub(ScalarInt8, Int32, S_M, Int8, Int32, Int32);
 232     scilab_fill_sub(ScalarInt8, UInt32, S_M, Int8, UInt32, UInt32);
 233     scilab_fill_sub(ScalarInt8, Int64, S_M, Int8, Int64, Int64);
 234     scilab_fill_sub(ScalarInt8, UInt64, S_M, Int8, UInt64, UInt64);
 235     scilab_fill_sub(ScalarInt8, Bool, S_M, Int8, Bool, Int8);
 236     scilab_fill_sub(ScalarInt8, Empty, S_E, Int8, Double, Int8);
 237
 238     //Scalar - Scalar
 239     scilab_fill_sub(ScalarInt8, ScalarDouble, S_S, Int8, Double, Int8);
 240     scilab_fill_sub(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Int8);
 241     scilab_fill_sub(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, UInt8);
 242     scilab_fill_sub(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Int16);
 243     scilab_fill_sub(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, UInt16);
 244     scilab_fill_sub(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Int32);
 245     scilab_fill_sub(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, UInt32);
 246     scilab_fill_sub(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Int64);
 247     scilab_fill_sub(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, UInt64);
 248     scilab_fill_sub(ScalarInt8, ScalarBool, S_S, Int8, Bool, Int8);
 249
 250     //UInt8
 251     //Matrix - Matrix
 252     scilab_fill_sub(UInt8, Double, M_M, UInt8, Double, UInt8);
 253     scilab_fill_sub(UInt8, Int8, M_M, UInt8, Int8, UInt8);
 254     scilab_fill_sub(UInt8, UInt8, M_M, UInt8, UInt8, UInt8);
 255     scilab_fill_sub(UInt8, Int16, M_M, UInt8, Int16, UInt16);
 256     scilab_fill_sub(UInt8, UInt16, M_M, UInt8, UInt16, UInt16);
 257     scilab_fill_sub(UInt8, Int32, M_M, UInt8, Int32, UInt32);
 258     scilab_fill_sub(UInt8, UInt32, M_M, UInt8, UInt32, UInt32);
 259     scilab_fill_sub(UInt8, Int64, M_M, UInt8, Int64, UInt64);
 260     scilab_fill_sub(UInt8, UInt64, M_M, UInt8, UInt64, UInt64);
 261     scilab_fill_sub(UInt8, Bool, M_M, UInt8, Bool, UInt8);
 262     scilab_fill_sub(UInt8, Empty, M_E, UInt8, Double, UInt8);
 263
 264     //Matrix - Scalar
 265     scilab_fill_sub(UInt8, ScalarDouble, M_S, UInt8, Double, UInt8);
 266     scilab_fill_sub(UInt8, ScalarInt8, M_S, UInt8, Int8, UInt8);
 267     scilab_fill_sub(UInt8, ScalarUInt8, M_S, UInt8, UInt8, UInt8);
 268     scilab_fill_sub(UInt8, ScalarInt16, M_S, UInt8, Int16, UInt16);
 269     scilab_fill_sub(UInt8, ScalarUInt16, M_S, UInt8, UInt16, UInt16);
 270     scilab_fill_sub(UInt8, ScalarInt32, M_S, UInt8, Int32, UInt32);
 271     scilab_fill_sub(UInt8, ScalarUInt32, M_S, UInt8, UInt32, UInt32);
 272     scilab_fill_sub(UInt8, ScalarInt64, M_S, UInt8, Int64, UInt64);
 273     scilab_fill_sub(UInt8, ScalarUInt64, M_S, UInt8, UInt64, UInt64);
 274     scilab_fill_sub(UInt8, ScalarBool, M_S, UInt8, Bool, UInt8);
 275
 276     //Scalar - Matrix
 277     scilab_fill_sub(ScalarUInt8, Double, S_M, UInt8, Double, UInt8);
 278     scilab_fill_sub(ScalarUInt8, Int8, S_M, UInt8, Int8, UInt8);
 279     scilab_fill_sub(ScalarUInt8, UInt8, S_M, UInt8, UInt8, UInt8);
 280     scilab_fill_sub(ScalarUInt8, Int16, S_M, UInt8, Int16, UInt16);
 281     scilab_fill_sub(ScalarUInt8, UInt16, S_M, UInt8, UInt16, UInt16);
 282     scilab_fill_sub(ScalarUInt8, Int32, S_M, UInt8, Int32, UInt32);
 283     scilab_fill_sub(ScalarUInt8, UInt32, S_M, UInt8, UInt32, UInt32);
 284     scilab_fill_sub(ScalarUInt8, Int64, S_M, UInt8, Int64, UInt64);
 285     scilab_fill_sub(ScalarUInt8, UInt64, S_M, UInt8, UInt64, UInt64);
 286     scilab_fill_sub(ScalarUInt8, Bool, S_M, UInt8, Bool, UInt8);
 287     scilab_fill_sub(ScalarUInt8, Empty, S_E, UInt8, Double, UInt8);
 288
 289     //Scalar - Scalar
 290     scilab_fill_sub(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, UInt8);
 291     scilab_fill_sub(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, UInt8);
 292     scilab_fill_sub(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, UInt8);
 293     scilab_fill_sub(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, UInt16);
 294     scilab_fill_sub(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, UInt16);
 295     scilab_fill_sub(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, UInt32);
 296     scilab_fill_sub(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, UInt32);
 297     scilab_fill_sub(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, UInt64);
 298     scilab_fill_sub(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, UInt64);
 299     scilab_fill_sub(ScalarUInt8, ScalarBool, S_S, UInt8, Bool, UInt8);
 300
 301     //Int16
 302     //Matrix - Matrix
 303     scilab_fill_sub(Int16, Double, M_M, Int16, Double, Int16);
 304     scilab_fill_sub(Int16, Int8, M_M, Int16, Int8, Int16);
 305     scilab_fill_sub(Int16, UInt8, M_M, Int16, UInt8, UInt16);
 306     scilab_fill_sub(Int16, Int16, M_M, Int16, Int16, Int16);
 307     scilab_fill_sub(Int16, UInt16, M_M, Int16, UInt16, UInt16);
 308     scilab_fill_sub(Int16, Int32, M_M, Int16, Int32, Int32);
 309     scilab_fill_sub(Int16, UInt32, M_M, Int16, UInt32, UInt32);
 310     scilab_fill_sub(Int16, Int64, M_M, Int16, Int64, Int64);
 311     scilab_fill_sub(Int16, UInt64, M_M, Int16, UInt64, UInt64);
 312     scilab_fill_sub(Int16, Bool, M_M, Int16, Bool, Int16);
 313     scilab_fill_sub(Int16, Empty, M_E, Int16, Double, Int16);
 314
 315     //Matrix - Scalar
 316     scilab_fill_sub(Int16, ScalarDouble, M_S, Int16, Double, Int16);
 317     scilab_fill_sub(Int16, ScalarInt8, M_S, Int16, Int8, Int16);
 318     scilab_fill_sub(Int16, ScalarUInt8, M_S, Int16, UInt8, UInt16);
 319     scilab_fill_sub(Int16, ScalarInt16, M_S, Int16, Int16, Int16);
 320     scilab_fill_sub(Int16, ScalarUInt16, M_S, Int16, UInt16, UInt16);
 321     scilab_fill_sub(Int16, ScalarInt32, M_S, Int16, Int32, Int32);
 322     scilab_fill_sub(Int16, ScalarUInt32, M_S, Int16, UInt32, UInt32);
 323     scilab_fill_sub(Int16, ScalarInt64, M_S, Int16, Int64, Int64);
 324     scilab_fill_sub(Int16, ScalarUInt64, M_S, Int16, UInt64, UInt64);
 325     scilab_fill_sub(Int16, ScalarBool, M_S, Int16, Bool, Int16);
 326
 327     //Scalar - Matrix
 328     scilab_fill_sub(ScalarInt16, Double, S_M, Int16, Double, Int16);
 329     scilab_fill_sub(ScalarInt16, Int8, S_M, Int16, Int8, Int16);
 330     scilab_fill_sub(ScalarInt16, UInt8, S_M, Int16, UInt8, UInt16);
 331     scilab_fill_sub(ScalarInt16, Int16, S_M, Int16, Int16, Int16);
 332     scilab_fill_sub(ScalarInt16, UInt16, S_M, Int16, UInt16, UInt16);
 333     scilab_fill_sub(ScalarInt16, Int32, S_M, Int16, Int32, Int32);
 334     scilab_fill_sub(ScalarInt16, UInt32, S_M, Int16, UInt32, UInt32);
 335     scilab_fill_sub(ScalarInt16, Int64, S_M, Int16, Int64, Int64);
 336     scilab_fill_sub(ScalarInt16, UInt64, S_M, Int16, UInt64, UInt64);
 337     scilab_fill_sub(ScalarInt16, Bool, S_M, Int16, Bool, Int16);
 338     scilab_fill_sub(ScalarInt16, Empty, S_E, Int16, Double, Int16);
 339
 340     //Scalar - Scalar
 341     scilab_fill_sub(ScalarInt16, ScalarDouble, S_S, Int16, Double, Int16);
 342     scilab_fill_sub(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Int16);
 343     scilab_fill_sub(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, UInt16);
 344     scilab_fill_sub(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Int16);
 345     scilab_fill_sub(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, UInt16);
 346     scilab_fill_sub(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Int32);
 347     scilab_fill_sub(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, UInt32);
 348     scilab_fill_sub(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Int64);
 349     scilab_fill_sub(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, UInt64);
 350     scilab_fill_sub(ScalarInt16, ScalarBool, S_S, Int16, Bool, Int16);
 351
 352     //UInt16
 353     //Matrix - Matrix
 354     scilab_fill_sub(UInt16, Double, M_M, UInt16, Double, UInt16);
 355     scilab_fill_sub(UInt16, Int8, M_M, UInt16, Int8, UInt16);
 356     scilab_fill_sub(UInt16, UInt8, M_M, UInt16, UInt8, UInt16);
 357     scilab_fill_sub(UInt16, Int16, M_M, UInt16, Int16, UInt16);
 358     scilab_fill_sub(UInt16, UInt16, M_M, UInt16, UInt16, UInt16);
 359     scilab_fill_sub(UInt16, Int32, M_M, UInt16, Int32, UInt32);
 360     scilab_fill_sub(UInt16, UInt32, M_M, UInt16, UInt32, UInt32);
 361     scilab_fill_sub(UInt16, Int64, M_M, UInt16, Int64, UInt64);
 362     scilab_fill_sub(UInt16, UInt64, M_M, UInt16, UInt64, UInt64);
 363     scilab_fill_sub(UInt16, Bool, M_M, UInt16, Bool, UInt16);
 364     scilab_fill_sub(UInt16, Empty, M_E, UInt16, Double, UInt16);
 365
 366     //Matrix - Scalar
 367     scilab_fill_sub(UInt16, ScalarDouble, M_S, UInt16, Double, UInt16);
 368     scilab_fill_sub(UInt16, ScalarInt8, M_S, UInt16, Int8, UInt16);
 369     scilab_fill_sub(UInt16, ScalarUInt8, M_S, UInt16, UInt8, UInt16);
 370     scilab_fill_sub(UInt16, ScalarInt16, M_S, UInt16, Int16, UInt16);
 371     scilab_fill_sub(UInt16, ScalarUInt16, M_S, UInt16, UInt16, UInt16);
 372     scilab_fill_sub(UInt16, ScalarInt32, M_S, UInt16, Int32, UInt32);
 373     scilab_fill_sub(UInt16, ScalarUInt32, M_S, UInt16, UInt32, UInt32);
 374     scilab_fill_sub(UInt16, ScalarInt64, M_S, UInt16, Int64, UInt64);
 375     scilab_fill_sub(UInt16, ScalarUInt64, M_S, UInt16, UInt64, UInt64);
 376     scilab_fill_sub(UInt16, ScalarBool, M_S, UInt16, Bool, UInt16);
 377
 378     //Scalar - Matrix
 379     scilab_fill_sub(ScalarUInt16, Double, S_M, UInt16, Double, UInt16);
 380     scilab_fill_sub(ScalarUInt16, Int8, S_M, UInt16, Int8, UInt16);
 381     scilab_fill_sub(ScalarUInt16, UInt8, S_M, UInt16, UInt8, UInt16);
 382     scilab_fill_sub(ScalarUInt16, Int16, S_M, UInt16, Int16, UInt16);
 383     scilab_fill_sub(ScalarUInt16, UInt16, S_M, UInt16, UInt16, UInt16);
 384     scilab_fill_sub(ScalarUInt16, Int32, S_M, UInt16, Int32, UInt32);
 385     scilab_fill_sub(ScalarUInt16, UInt32, S_M, UInt16, UInt32, UInt32);
 386     scilab_fill_sub(ScalarUInt16, Int64, S_M, UInt16, Int64, UInt64);
 387     scilab_fill_sub(ScalarUInt16, UInt64, S_M, UInt16, UInt64, UInt64);
 388     scilab_fill_sub(ScalarUInt16, Bool, S_M, UInt16, Bool, UInt16);
 389     scilab_fill_sub(ScalarUInt16, Empty, S_E, UInt16, Double, UInt16);
 390
 391     //Scalar - Scalar
 392     scilab_fill_sub(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, UInt16);
 393     scilab_fill_sub(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, UInt16);
 394     scilab_fill_sub(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, UInt16);
 395     scilab_fill_sub(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, UInt16);
 396     scilab_fill_sub(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, UInt16);
 397     scilab_fill_sub(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, UInt32);
 398     scilab_fill_sub(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, UInt32);
 399     scilab_fill_sub(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, UInt64);
 400     scilab_fill_sub(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, UInt64);
 401     scilab_fill_sub(ScalarUInt16, ScalarBool, S_S, UInt16, Bool, UInt16);
 402
 403     //Int32
 404     //Matrix - Matrix
 405     scilab_fill_sub(Int32, Double, M_M, Int32, Double, Int32);
 406     scilab_fill_sub(Int32, Int8, M_M, Int32, Int8, Int32);
 407     scilab_fill_sub(Int32, UInt8, M_M, Int32, UInt8, UInt32);
 408     scilab_fill_sub(Int32, Int16, M_M, Int32, Int16, Int32);
 409     scilab_fill_sub(Int32, UInt16, M_M, Int32, UInt16, UInt32);
 410     scilab_fill_sub(Int32, Int32, M_M, Int32, Int32, Int32);
 411     scilab_fill_sub(Int32, UInt32, M_M, Int32, UInt32, UInt32);
 412     scilab_fill_sub(Int32, Int64, M_M, Int32, Int64, Int64);
 413     scilab_fill_sub(Int32, UInt64, M_M, Int32, UInt64, UInt64);
 414     scilab_fill_sub(Int32, Bool, M_M, Int32, Bool, Int32);
 415     scilab_fill_sub(Int32, Empty, M_E, Int32, Double, Int32);
 416
 417     //Matrix - Scalar
 418     scilab_fill_sub(Int32, ScalarDouble, M_S, Int32, Double, Int32);
 419     scilab_fill_sub(Int32, ScalarInt8, M_S, Int32, Int8, Int32);
 420     scilab_fill_sub(Int32, ScalarUInt8, M_S, Int32, UInt8, UInt32);
 421     scilab_fill_sub(Int32, ScalarInt16, M_S, Int32, Int16, Int32);
 422     scilab_fill_sub(Int32, ScalarUInt16, M_S, Int32, UInt16, UInt32);
 423     scilab_fill_sub(Int32, ScalarInt32, M_S, Int32, Int32, Int32);
 424     scilab_fill_sub(Int32, ScalarUInt32, M_S, Int32, UInt32, UInt32);
 425     scilab_fill_sub(Int32, ScalarInt64, M_S, Int32, Int64, Int64);
 426     scilab_fill_sub(Int32, ScalarUInt64, M_S, Int32, UInt64, UInt64);
 427     scilab_fill_sub(Int32, ScalarBool, M_S, Int32, Bool, Int32);
 428
 429     //Scalar - Matrix
 430     scilab_fill_sub(ScalarInt32, Double, S_M, Int32, Double, Int32);
 431     scilab_fill_sub(ScalarInt32, Int8, S_M, Int32, Int8, Int32);
 432     scilab_fill_sub(ScalarInt32, UInt8, S_M, Int32, UInt8, UInt32);
 433     scilab_fill_sub(ScalarInt32, Int16, S_M, Int32, Int16, Int32);
 434     scilab_fill_sub(ScalarInt32, UInt16, S_M, Int32, UInt16, UInt32);
 435     scilab_fill_sub(ScalarInt32, Int32, S_M, Int32, Int32, Int32);
 436     scilab_fill_sub(ScalarInt32, UInt32, S_M, Int32, UInt32, UInt32);
 437     scilab_fill_sub(ScalarInt32, Int64, S_M, Int32, Int64, Int64);
 438     scilab_fill_sub(ScalarInt32, UInt64, S_M, Int32, UInt64, UInt64);
 439     scilab_fill_sub(ScalarInt32, Bool, S_M, Int32, Bool, Int32);
 440     scilab_fill_sub(ScalarInt32, Empty, S_E, Int32, Double, Int32);
 441
 442     //Scalar - Scalar
 443     scilab_fill_sub(ScalarInt32, ScalarDouble, S_S, Int32, Double, Int32);
 444     scilab_fill_sub(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Int32);
 445     scilab_fill_sub(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, UInt32);
 446     scilab_fill_sub(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Int32);
 447     scilab_fill_sub(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, UInt32);
 448     scilab_fill_sub(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Int32);
 449     scilab_fill_sub(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, UInt32);
 450     scilab_fill_sub(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Int64);
 451     scilab_fill_sub(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, UInt64);
 452     scilab_fill_sub(ScalarInt32, ScalarBool, S_S, Int32, Bool, Int32);
 453
 454     //UInt32
 455     //Matrix - Matrix
 456     scilab_fill_sub(UInt32, Double, M_M, UInt32, Double, UInt32);
 457     scilab_fill_sub(UInt32, Int8, M_M, UInt32, Int8, UInt32);
 458     scilab_fill_sub(UInt32, UInt8, M_M, UInt32, UInt8, UInt32);
 459     scilab_fill_sub(UInt32, Int16, M_M, UInt32, Int16, UInt32);
 460     scilab_fill_sub(UInt32, UInt16, M_M, UInt32, UInt16, UInt32);
 461     scilab_fill_sub(UInt32, Int32, M_M, UInt32, Int32, UInt32);
 462     scilab_fill_sub(UInt32, UInt32, M_M, UInt32, UInt32, UInt32);
 463     scilab_fill_sub(UInt32, Int64, M_M, UInt32, Int64, UInt64);
 464     scilab_fill_sub(UInt32, UInt64, M_M, UInt32, UInt64, UInt64);
 465     scilab_fill_sub(UInt32, Bool, M_M, UInt32, Bool, UInt32);
 466     scilab_fill_sub(UInt32, Empty, M_E, UInt32, Double, UInt32);
 467
 468     //Matrix - Scalar
 469     scilab_fill_sub(UInt32, ScalarDouble, M_S, UInt32, Double, UInt32);
 470     scilab_fill_sub(UInt32, ScalarInt8, M_S, UInt32, Int8, UInt32);
 471     scilab_fill_sub(UInt32, ScalarUInt8, M_S, UInt32, UInt8, UInt32);
 472     scilab_fill_sub(UInt32, ScalarInt16, M_S, UInt32, Int16, UInt32);
 473     scilab_fill_sub(UInt32, ScalarUInt16, M_S, UInt32, UInt16, UInt32);
 474     scilab_fill_sub(UInt32, ScalarInt32, M_S, UInt32, Int32, UInt32);
 475     scilab_fill_sub(UInt32, ScalarUInt32, M_S, UInt32, UInt32, UInt32);
 476     scilab_fill_sub(UInt32, ScalarInt64, M_S, UInt32, Int64, UInt64);
 477     scilab_fill_sub(UInt32, ScalarUInt64, M_S, UInt32, UInt64, UInt64);
 478     scilab_fill_sub(UInt32, ScalarBool, M_S, UInt32, Bool, UInt32);
 479
 480     //Scalar - Matrix
 481     scilab_fill_sub(ScalarUInt32, Double, S_M, UInt32, Double, UInt32);
 482     scilab_fill_sub(ScalarUInt32, Int8, S_M, UInt32, Int8, UInt32);
 483     scilab_fill_sub(ScalarUInt32, UInt8, S_M, UInt32, UInt8, UInt32);
 484     scilab_fill_sub(ScalarUInt32, Int16, S_M, UInt32, Int16, UInt32);
 485     scilab_fill_sub(ScalarUInt32, UInt16, S_M, UInt32, UInt16, UInt32);
 486     scilab_fill_sub(ScalarUInt32, Int32, S_M, UInt32, Int32, UInt32);
 487     scilab_fill_sub(ScalarUInt32, UInt32, S_M, UInt32, UInt32, UInt32);
 488     scilab_fill_sub(ScalarUInt32, Int64, S_M, UInt32, Int64, UInt64);
 489     scilab_fill_sub(ScalarUInt32, UInt64, S_M, UInt32, UInt64, UInt64);
 490     scilab_fill_sub(ScalarUInt32, Bool, S_M, UInt32, Bool, UInt32);
 491     scilab_fill_sub(ScalarUInt32, Empty, S_E, UInt32, Double, UInt32);
 492
 493     //Scalar - Scalar
 494     scilab_fill_sub(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, UInt32);
 495     scilab_fill_sub(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, UInt32);
 496     scilab_fill_sub(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, UInt32);
 497     scilab_fill_sub(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, UInt32);
 498     scilab_fill_sub(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, UInt32);
 499     scilab_fill_sub(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, UInt32);
 500     scilab_fill_sub(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, UInt32);
 501     scilab_fill_sub(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, UInt64);
 502     scilab_fill_sub(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, UInt64);
 503     scilab_fill_sub(ScalarUInt32, ScalarBool, S_S, UInt32, Bool, UInt32);
 504
 505     //Int64
 506     //Matrix - Matrix
 507     scilab_fill_sub(Int64, Double, M_M, Int64, Double, Int64);
 508     scilab_fill_sub(Int64, Int8, M_M, Int64, Int8, Int64);
 509     scilab_fill_sub(Int64, UInt8, M_M, Int64, UInt8, UInt64);
 510     scilab_fill_sub(Int64, Int16, M_M, Int64, Int16, Int64);
 511     scilab_fill_sub(Int64, UInt16, M_M, Int64, UInt16, UInt64);
 512     scilab_fill_sub(Int64, Int32, M_M, Int64, Int32, Int64);
 513     scilab_fill_sub(Int64, UInt32, M_M, Int64, UInt32, UInt64);
 514     scilab_fill_sub(Int64, Int64, M_M, Int64, Int64, Int64);
 515     scilab_fill_sub(Int64, UInt64, M_M, Int64, UInt64, UInt64);
 516     scilab_fill_sub(Int64, Bool, M_M, Int64, Bool, Int64);
 517     scilab_fill_sub(Int64, Empty, M_E, Int64, Double, Int64);
 518
 519     //Matrix - Scalar
 520     scilab_fill_sub(Int64, ScalarDouble, M_S, Int64, Double, Int64);
 521     scilab_fill_sub(Int64, ScalarInt8, M_S, Int64, Int8, Int64);
 522     scilab_fill_sub(Int64, ScalarUInt8, M_S, Int64, UInt8, UInt64);
 523     scilab_fill_sub(Int64, ScalarInt16, M_S, Int64, Int16, Int64);
 524     scilab_fill_sub(Int64, ScalarUInt16, M_S, Int64, UInt16, UInt64);
 525     scilab_fill_sub(Int64, ScalarInt32, M_S, Int64, Int32, Int64);
 526     scilab_fill_sub(Int64, ScalarUInt32, M_S, Int64, UInt32, UInt64);
 527     scilab_fill_sub(Int64, ScalarInt64, M_S, Int64, Int64, Int64);
 528     scilab_fill_sub(Int64, ScalarUInt64, M_S, Int64, UInt64, UInt64);
 529     scilab_fill_sub(Int64, ScalarBool, M_S, Int64, Bool, Int64);
 530
 531     //Scalar - Matrix
 532     scilab_fill_sub(ScalarInt64, Double, S_M, Int64, Double, Int64);
 533     scilab_fill_sub(ScalarInt64, Int8, S_M, Int64, Int8, Int64);
 534     scilab_fill_sub(ScalarInt64, UInt8, S_M, Int64, UInt8, UInt64);
 535     scilab_fill_sub(ScalarInt64, Int16, S_M, Int64, Int16, Int64);
 536     scilab_fill_sub(ScalarInt64, UInt16, S_M, Int64, UInt16, UInt64);
 537     scilab_fill_sub(ScalarInt64, Int32, S_M, Int64, Int32, Int64);
 538     scilab_fill_sub(ScalarInt64, UInt32, S_M, Int64, UInt32, UInt64);
 539     scilab_fill_sub(ScalarInt64, Int64, S_M, Int64, Int64, Int64);
 540     scilab_fill_sub(ScalarInt64, UInt64, S_M, Int64, UInt64, UInt64);
 541     scilab_fill_sub(ScalarInt64, Bool, S_M, Int64, Bool, Int64);
 542     scilab_fill_sub(ScalarInt64, Empty, S_E, Int64, Double, Int64);
 543
 544     //Scalar - Scalar
 545     scilab_fill_sub(ScalarInt64, ScalarDouble, S_S, Int64, Double, Int64);
 546     scilab_fill_sub(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Int64);
 547     scilab_fill_sub(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, UInt64);
 548     scilab_fill_sub(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Int64);
 549     scilab_fill_sub(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, UInt64);
 550     scilab_fill_sub(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Int64);
 551     scilab_fill_sub(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, UInt64);
 552     scilab_fill_sub(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Int64);
 553     scilab_fill_sub(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, UInt64);
 554     scilab_fill_sub(ScalarInt64, ScalarBool, S_S, Int64, Bool, Int64);
 555
 556     //UInt64
 557     //Matrix - Matrix
 558     scilab_fill_sub(UInt64, Double, M_M, UInt64, Double, UInt64);
 559     scilab_fill_sub(UInt64, Int8, M_M, UInt64, Int8, UInt64);
 560     scilab_fill_sub(UInt64, UInt8, M_M, UInt64, UInt8, UInt64);
 561     scilab_fill_sub(UInt64, Int16, M_M, UInt64, Int16, UInt64);
 562     scilab_fill_sub(UInt64, UInt16, M_M, UInt64, UInt16, UInt64);
 563     scilab_fill_sub(UInt64, Int32, M_M, UInt64, Int32, UInt64);
 564     scilab_fill_sub(UInt64, UInt32, M_M, UInt64, UInt32, UInt64);
 565     scilab_fill_sub(UInt64, Int64, M_M, UInt64, Int64, UInt64);
 566     scilab_fill_sub(UInt64, UInt64, M_M, UInt64, UInt64, UInt64);
 567     scilab_fill_sub(UInt64, Bool, M_M, UInt64, Bool, UInt64);
 568     scilab_fill_sub(UInt64, Empty, M_E, UInt64, Double, UInt64);
 569
 570     //Matrix - Scalar
 571     scilab_fill_sub(UInt64, ScalarDouble, M_S, UInt64, Double, UInt64);
 572     scilab_fill_sub(UInt64, ScalarInt8, M_S, UInt64, Int8, UInt64);
 573     scilab_fill_sub(UInt64, ScalarUInt8, M_S, UInt64, UInt8, UInt64);
 574     scilab_fill_sub(UInt64, ScalarInt16, M_S, UInt64, Int16, UInt64);
 575     scilab_fill_sub(UInt64, ScalarUInt16, M_S, UInt64, UInt16, UInt64);
 576     scilab_fill_sub(UInt64, ScalarInt32, M_S, UInt64, Int32, UInt64);
 577     scilab_fill_sub(UInt64, ScalarUInt32, M_S, UInt64, UInt32, UInt64);
 578     scilab_fill_sub(UInt64, ScalarInt64, M_S, UInt64, Int64, UInt64);
 579     scilab_fill_sub(UInt64, ScalarUInt64, M_S, UInt64, UInt64, UInt64);
 580     scilab_fill_sub(UInt64, ScalarBool, M_S, UInt64, Bool, UInt64);
 581
 582     //Scalar - Matrix
 583     scilab_fill_sub(ScalarUInt64, Double, S_M, UInt64, Double, UInt64);
 584     scilab_fill_sub(ScalarUInt64, Int8, S_M, UInt64, Int8, UInt64);
 585     scilab_fill_sub(ScalarUInt64, UInt8, S_M, UInt64, UInt8, UInt64);
 586     scilab_fill_sub(ScalarUInt64, Int16, S_M, UInt64, Int16, UInt64);
 587     scilab_fill_sub(ScalarUInt64, UInt16, S_M, UInt64, UInt16, UInt64);
 588     scilab_fill_sub(ScalarUInt64, Int32, S_M, UInt64, Int32, UInt64);
 589     scilab_fill_sub(ScalarUInt64, UInt32, S_M, UInt64, UInt32, UInt64);
 590     scilab_fill_sub(ScalarUInt64, Int64, S_M, UInt64, Int64, UInt64);
 591     scilab_fill_sub(ScalarUInt64, UInt64, S_M, UInt64, UInt64, UInt64);
 592     scilab_fill_sub(ScalarUInt64, Bool, S_M, UInt64, Bool, UInt64);
 593     scilab_fill_sub(ScalarUInt64, Empty, S_E, UInt64, Double, UInt64);
 594
 595     //Scalar - Scalar
 596     scilab_fill_sub(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, UInt64);
 597     scilab_fill_sub(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, UInt64);
 598     scilab_fill_sub(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, UInt64);
 599     scilab_fill_sub(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, UInt64);
 600     scilab_fill_sub(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, UInt64);
 601     scilab_fill_sub(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, UInt64);
 602     scilab_fill_sub(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, UInt64);
 603     scilab_fill_sub(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, UInt64);
 604     scilab_fill_sub(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, UInt64);
 605     scilab_fill_sub(ScalarUInt64, ScalarBool, S_S, UInt64, Bool, UInt64);
 606
 607     //Bool
 608     //Matrix - Matrix
 609     scilab_fill_sub(Bool, Double, M_M, Bool, Double, Double);
 610     scilab_fill_sub(Bool, Int8, M_M, Bool, Int8, Int8);
 611     scilab_fill_sub(Bool, UInt8, M_M, Bool, UInt8, UInt8);
 612     scilab_fill_sub(Bool, Int16, M_M, Bool, Int16, Int16);
 613     scilab_fill_sub(Bool, UInt16, M_M, Bool, UInt16, UInt16);
 614     scilab_fill_sub(Bool, Int32, M_M, Bool, Int32, Int32);
 615     scilab_fill_sub(Bool, UInt32, M_M, Bool, UInt32, UInt32);
 616     scilab_fill_sub(Bool, Int64, M_M, Bool, Int64, Int64);
 617     scilab_fill_sub(Bool, UInt64, M_M, Bool, UInt64, UInt64);
 618     scilab_fill_sub(Bool, Bool, M_M, Bool, Bool, Bool);
 619     scilab_fill_sub(Bool, Empty, M_E, Bool, Double, Double);
 620
 621     //Matrix - Scalar
 622     scilab_fill_sub(Bool, ScalarDouble, M_S, Bool, Double, Double);
 623     scilab_fill_sub(Bool, ScalarInt8, M_S, Bool, Int8, Int8);
 624     scilab_fill_sub(Bool, ScalarUInt8, M_S, Bool, UInt8, UInt8);
 625     scilab_fill_sub(Bool, ScalarInt16, M_S, Bool, Int16, Int16);
 626     scilab_fill_sub(Bool, ScalarUInt16, M_S, Bool, UInt16, UInt16);
 627     scilab_fill_sub(Bool, ScalarInt32, M_S, Bool, Int32, Int32);
 628     scilab_fill_sub(Bool, ScalarUInt32, M_S, Bool, UInt32, UInt32);
 629     scilab_fill_sub(Bool, ScalarInt64, M_S, Bool, Int64, Int64);
 630     scilab_fill_sub(Bool, ScalarUInt64, M_S, Bool, UInt64, UInt64);
 631     scilab_fill_sub(Bool, ScalarBool, M_S, Bool, Bool, Bool);
 632
 633     //Scalar - Matrix
 634     scilab_fill_sub(ScalarBool, Double, S_M, Bool, Double, Double);
 635     scilab_fill_sub(ScalarBool, Int8, S_M, Bool, Int8, Int8);
 636     scilab_fill_sub(ScalarBool, UInt8, S_M, Bool, UInt8, UInt8);
 637     scilab_fill_sub(ScalarBool, Int16, S_M, Bool, Int16, Int16);
 638     scilab_fill_sub(ScalarBool, UInt16, S_M, Bool, UInt16, UInt16);
 639     scilab_fill_sub(ScalarBool, Int32, S_M, Bool, Int32, Int32);
 640     scilab_fill_sub(ScalarBool, UInt32, S_M, Bool, UInt32, UInt32);
 641     scilab_fill_sub(ScalarBool, Int64, S_M, Bool, Int64, Int64);
 642     scilab_fill_sub(ScalarBool, UInt64, S_M, Bool, UInt64, UInt64);
 643     scilab_fill_sub(ScalarBool, Bool, S_M, Bool, Bool, Bool);
 644     scilab_fill_sub(ScalarBool, Empty, S_E, Bool, Double, Double);
 645
 646     //Scalar - Scalar
 647     scilab_fill_sub(ScalarBool, ScalarDouble, S_S, Bool, Double, Double);
 648     scilab_fill_sub(ScalarBool, ScalarInt8, S_S, Bool, Int8, Int8);
 649     scilab_fill_sub(ScalarBool, ScalarUInt8, S_S, Bool, UInt8, UInt8);
 650     scilab_fill_sub(ScalarBool, ScalarInt16, S_S, Bool, Int16, Int16);
 651     scilab_fill_sub(ScalarBool, ScalarUInt16, S_S, Bool, UInt16, UInt16);
 652     scilab_fill_sub(ScalarBool, ScalarInt32, S_S, Bool, Int32, Int32);
 653     scilab_fill_sub(ScalarBool, ScalarUInt32, S_S, Bool, UInt32, UInt32);
 654     scilab_fill_sub(ScalarBool, ScalarInt64, S_S, Bool, Int64, Int64);
 655     scilab_fill_sub(ScalarBool, ScalarUInt64, S_S, Bool, UInt64, UInt64);
 656     scilab_fill_sub(ScalarBool, ScalarBool, S_S, Bool, Bool, Bool);
 657
 658     //Identity
 659     scilab_fill_sub(Identity, Double, I_M, Double, Double, Double);
 660     scilab_fill_sub(Identity, DoubleComplex, I_MC, Double, Double, Double);
 661     scilab_fill_sub(Identity, ScalarDouble, I_S, Double, Double, Double);
 662     scilab_fill_sub(Identity, ScalarDoubleComplex, I_SC, Double, Double, Double);
 663     scilab_fill_sub(Identity, Identity, I_I, Double, Double, Double);
 664     scilab_fill_sub(Identity, IdentityComplex, I_IC, Double, Double, Double);
 665     scilab_fill_sub(Identity, Empty, I_E, Double, Double, Double);
 666
 667     scilab_fill_sub(Identity, Polynom, I_M, Double, Polynom, Polynom);
 668     scilab_fill_sub(Identity, PolynomComplex, I_MC, Double, Polynom, Polynom);
 669     scilab_fill_sub(Identity, ScalarPolynom, I_M, Double, Polynom, Polynom);
 670     scilab_fill_sub(Identity, ScalarPolynomComplex, I_MC, Double, Polynom, Polynom);
 671     scilab_fill_sub(Identity, Sparse, M_M, Double, Sparse, Sparse);
 672     scilab_fill_sub(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
 673
 674     scilab_fill_sub(IdentityComplex, Double, IC_M, Double, Double, Double);
 675     scilab_fill_sub(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
 676     scilab_fill_sub(IdentityComplex, ScalarDouble, IC_S, Double, Double, Double);
 677     scilab_fill_sub(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Double);
 678     scilab_fill_sub(IdentityComplex, Identity, IC_I, Double, Double, Double);
 679     scilab_fill_sub(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Double);
 680     scilab_fill_sub(IdentityComplex, Empty, IC_E, Double, Double, Double);
 681
 682     scilab_fill_sub(IdentityComplex, Polynom, IC_M, Double, Polynom, Polynom);
 683     scilab_fill_sub(IdentityComplex, PolynomComplex, IC_MC, Double, Polynom, Polynom);
 684     scilab_fill_sub(IdentityComplex, ScalarPolynom, IC_M, Double, Polynom, Polynom);
 685     scilab_fill_sub(IdentityComplex, ScalarPolynomComplex, IC_MC, Double, Polynom, Polynom);
 686     scilab_fill_sub(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
 687     scilab_fill_sub(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
 688
 689     scilab_fill_sub(Identity, ScalarInt8, I_S, Double, Int8, Int8);
 690     scilab_fill_sub(Identity, ScalarUInt8, I_S, Double, UInt8, UInt8);
 691     scilab_fill_sub(Identity, ScalarInt16, I_S, Double, Int16, Int16);
 692     scilab_fill_sub(Identity, ScalarUInt16, I_S, Double, UInt16, UInt16);
 693     scilab_fill_sub(Identity, ScalarInt32, I_S, Double, Int32, Int32);
 694     scilab_fill_sub(Identity, ScalarUInt32, I_S, Double, UInt32, UInt32);
 695     scilab_fill_sub(Identity, ScalarInt64, I_S, Double, Int64, Int64);
 696     scilab_fill_sub(Identity, ScalarUInt64, I_S, Double, UInt64, UInt64);
 697
 698     scilab_fill_sub(Identity, Int8, I_M, Double, Int8, Int8);
 699     scilab_fill_sub(Identity, UInt8, I_M, Double, UInt8, UInt8);
 700     scilab_fill_sub(Identity, Int16, I_M, Double, Int16, Int16);
 701     scilab_fill_sub(Identity, UInt16, I_M, Double, UInt16, UInt16);
 702     scilab_fill_sub(Identity, Int32, I_M, Double, Int32, Int32);
 703     scilab_fill_sub(Identity, UInt32, I_M, Double, UInt32, UInt32);
 704     scilab_fill_sub(Identity, Int64, I_M, Double, Int64, Int64);
 705     scilab_fill_sub(Identity, UInt64, I_M, Double, UInt64, UInt64);
 706
 707     //Polynom
 708
 709     //poly - poly
 710     scilab_fill_sub(Polynom, Polynom, M_M, Polynom, Polynom, Polynom);
 711     scilab_fill_sub(Polynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 712     scilab_fill_sub(PolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
 713     scilab_fill_sub(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 714
 715     //poly - scalar poly
 716     scilab_fill_sub(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 717     scilab_fill_sub(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 718     scilab_fill_sub(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 719     scilab_fill_sub(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 720
 721     //poly - double
 722     scilab_fill_sub(Polynom, Double, M_M, Polynom, Double, Polynom);
 723     scilab_fill_sub(Polynom, DoubleComplex, M_M, Polynom, Double, Polynom);
 724     scilab_fill_sub(PolynomComplex, Double, M_M, Polynom, Double, Polynom);
 725     scilab_fill_sub(PolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
 726
 727     //poly - scalar double
 728     scilab_fill_sub(Polynom, ScalarDouble, M_M, Polynom, Double, Polynom);
 729     scilab_fill_sub(Polynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 730     scilab_fill_sub(PolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
 731     scilab_fill_sub(PolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 732
 733     //poly - []
 734     scilab_fill_sub(Polynom, Empty, M_M, Polynom, Double, Polynom);
 735     scilab_fill_sub(PolynomComplex, Empty, M_M, Polynom, Double, Polynom);
 736
 737     //poly - eye
 738     scilab_fill_sub(Polynom, Identity, M_M, Polynom, Double, Polynom);
 739     scilab_fill_sub(Polynom, IdentityComplex, M_M, Polynom, Double, Polynom);
 740     scilab_fill_sub(PolynomComplex, Identity, M_M, Polynom, Double, Polynom);
 741     scilab_fill_sub(PolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
 742
 743     //scalar poly - poly
 744     scilab_fill_sub(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Polynom);
 745     scilab_fill_sub(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 746     scilab_fill_sub(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
 747     scilab_fill_sub(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 748
 749     //scalar poly - scalar poly
 750     scilab_fill_sub(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 751     scilab_fill_sub(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 752     scilab_fill_sub(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 753     scilab_fill_sub(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 754
 755     //scalar poly - double
 756     scilab_fill_sub(ScalarPolynom, Double, M_M, Polynom, Double, Polynom);
 757     scilab_fill_sub(ScalarPolynom, DoubleComplex, M_M, Polynom, Double, Polynom);
 758     scilab_fill_sub(ScalarPolynomComplex, Double, M_M, Polynom, Double, Polynom);
 759     scilab_fill_sub(ScalarPolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
 760
 761     //scalar poly - scalar double
 762     scilab_fill_sub(ScalarPolynom, ScalarDouble, M_M, Polynom, Double, Polynom);
 763     scilab_fill_sub(ScalarPolynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 764     scilab_fill_sub(ScalarPolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
 765     scilab_fill_sub(ScalarPolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 766
 767     //scalar poly - []
 768     scilab_fill_sub(ScalarPolynom, Empty, M_M, Polynom, Double, Polynom);
 769     scilab_fill_sub(ScalarPolynomComplex, Empty, M_M, Polynom, Double, Polynom);
 770
 771     //scalar poly - eye
 772     scilab_fill_sub(ScalarPolynom, Identity, M_M, Polynom, Double, Polynom);
 773     scilab_fill_sub(ScalarPolynom, IdentityComplex, M_M, Polynom, Double, Polynom);
 774     scilab_fill_sub(ScalarPolynomComplex, Identity, M_M, Polynom, Double, Polynom);
 775     scilab_fill_sub(ScalarPolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
 776
 777     //Sparse
 778     scilab_fill_sub(Sparse, Sparse, M_M, Sparse, Sparse, Sparse);
 779     scilab_fill_sub(Sparse, SparseComplex, M_M, Sparse, Sparse, Sparse);
 780     scilab_fill_sub(Sparse, Double, M_M, Sparse, Double, Double);
 781     scilab_fill_sub(Sparse, DoubleComplex, M_M, Sparse, Double, Double);
 782     scilab_fill_sub(Sparse, ScalarDouble, M_M, Sparse, Double, Double);
 783     scilab_fill_sub(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Double);
 784
 785     scilab_fill_sub(Sparse, Empty, M_M, Sparse, Double, Sparse);
 786     scilab_fill_sub(Sparse, Identity, M_M, Sparse, Double, Sparse);
 787     scilab_fill_sub(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
 788
 789     scilab_fill_sub(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
 790     scilab_fill_sub(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
 791     scilab_fill_sub(SparseComplex, Double, M_M, Sparse, Double, Double);
 792     scilab_fill_sub(SparseComplex, DoubleComplex, M_M, Sparse, Double, Double);
 793     scilab_fill_sub(SparseComplex, ScalarDouble, M_M, Sparse, Double, Double);
 794     scilab_fill_sub(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Double);
 795
 796     scilab_fill_sub(SparseComplex, Empty, M_M, Sparse, Double, Sparse);
 797     scilab_fill_sub(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
 798     scilab_fill_sub(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
 799
 800 #undef scilab_fill_sub
 801 }
 802
 803 InternalType* GenericMinus(InternalType* _pLeftOperand, InternalType* _pRightOperand)
 804 {
 805     InternalType *pResult = NULL;
 806
 807     sub_function sub = pSubfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
 808     if (sub)
 809     {
 810         pResult = sub(_pLeftOperand, _pRightOperand);
 811         if (pResult)
 812         {
 813             return pResult;
 814         }
 815     }
 816
 817     /*
 818     ** Default case : Return NULL will Call Overloading.
 819     */
 820     return NULL;
 821 }
 822
 823 template<class T, class U, class O>
 824 InternalType* sub_M_M(T *_pL, U *_pR)
 825 {
 826     int iDimsL = _pL->getDims();
 827     int iDimsR = _pR->getDims();
 828
 829     if (iDimsL != iDimsR)
 830     {
 831         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 832     }
 833
 834     int* piDimsL = _pL->getDimsArray();
 835     int* piDimsR = _pR->getDimsArray();
 836
 837     for (int i = 0 ; i < iDimsL ; ++i)
 838     {
 839         if (piDimsL[i] != piDimsR[i])
 840         {
 841             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 842         }
 843     }
 844
 845     O* pOut = new O(iDimsL, piDimsL);
 846
 847     sub(_pL->get(), (size_t)_pL->getSize(), _pR->get(), pOut->get());
 848     return pOut;
 849 }
 850
 851 template<class T, class U, class O>
 852 InternalType* sub_M_MC(T *_pL, U *_pR)
 853 {
 854     int iDimsL = _pL->getDims();
 855     int iDimsR = _pR->getDims();
 856
 857     if (iDimsL != iDimsR)
 858     {
 859         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 860     }
 861
 862     int* piDimsL = _pL->getDimsArray();
 863     int* piDimsR = _pR->getDimsArray();
 864
 865     for (int i = 0 ; i < iDimsL ; ++i)
 866     {
 867         if (piDimsL[i] != piDimsR[i])
 868         {
 869             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 870         }
 871     }
 872
 873     O* pOut = new O(iDimsL, piDimsL, true);
 874
 875     sub(_pL->get(), (size_t)_pL->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
 876     return pOut;
 877 }
 878
 879 template<class T, class U, class O>
 880 InternalType* sub_M_S(T *_pL, U *_pR)
 881 {
 882     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
 883     sub(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), pOut->get());
 884     return pOut;
 885 }
 886
 887 template<class T, class U, class O>
 888 InternalType* sub_M_SC(T *_pL, U *_pR)
 889 {
 890     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 891     sub(_pL->get(), (size_t)_pL->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
 892     return pOut;
 893 }
 894
 895 template<class T, class U, class O>
 896 InternalType* sub_M_E(T *_pL, U *_pR)
 897 {
 898     return _pL;
 899 }
 900
 901
 902 template<class T, class U, class O>
 903 InternalType* sub_MC_M(T *_pL, U *_pR)
 904 {
 905     int iDimsL = _pL->getDims();
 906     int iDimsR = _pR->getDims();
 907
 908     if (iDimsL != iDimsR)
 909     {
 910         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 911     }
 912
 913     int* piDimsL = _pL->getDimsArray();
 914     int* piDimsR = _pR->getDimsArray();
 915
 916     for (int i = 0 ; i < iDimsL ; ++i)
 917     {
 918         if (piDimsL[i] != piDimsR[i])
 919         {
 920             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 921         }
 922     }
 923
 924     O* pOut = new O(iDimsL, piDimsL, true);
 925
 926     sub(_pL->get(), _pL->getImg(), (size_t)_pL->getSize(), _pR->get(), pOut->get(), pOut->getImg());
 927     return pOut;
 928 }
 929
 930 template<class T, class U, class O>
 931 InternalType* sub_MC_MC(T *_pL, U *_pR)
 932 {
 933     int iDimsL = _pL->getDims();
 934     int iDimsR = _pR->getDims();
 935
 936     if (iDimsL != iDimsR)
 937     {
 938         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 939     }
 940
 941     int* piDimsL = _pL->getDimsArray();
 942     int* piDimsR = _pR->getDimsArray();
 943
 944     for (int i = 0 ; i < iDimsL ; ++i)
 945     {
 946         if (piDimsL[i] != piDimsR[i])
 947         {
 948             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
 949         }
 950     }
 951
 952     O* pOut = new O(iDimsL, piDimsL, true);
 953
 954     sub(_pL->get(), _pL->getImg(), (size_t)_pL->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
 955     return pOut;
 956 }
 957
 958 template<class T, class U, class O>
 959 InternalType* sub_MC_S(T *_pL, U *_pR)
 960 {
 961     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 962     sub(_pL->get(), _pL->getImg(), (size_t)_pL->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
 963     return pOut;
 964 }
 965
 966 template<class T, class U, class O>
 967 InternalType* sub_MC_SC(T *_pL, U *_pR)
 968 {
 969     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 970     sub(_pL->get(), _pL->getImg(), (size_t)_pL->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
 971     return pOut;
 972 }
 973
 974 template<class T, class U, class O>
 975 InternalType* sub_MC_E(T *_pL, U *_pR)
 976 {
 977     return _pL;
 978 }
 979
 980
 981 template<class T, class U, class O>
 982 InternalType* sub_S_M(T *_pL, U *_pR)
 983 {
 984     O* pOut = new O(_pR->getDims(), _pR->getDimsArray());
 985     sub(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), pOut->get());
 986     return pOut;
 987 }
 988
 989 template<class T, class U, class O>
 990 InternalType* sub_S_MC(T *_pL, U *_pR)
 991 {
 992     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
 993     sub(_pL->get(0), (size_t)_pR->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
 994     return pOut;
 995 }
 996
 997 template<class T, class U, class O>
 998 InternalType* sub_S_S(T *_pL, U *_pR)
 999 {
1000     O* pOut = new O(0);
1001     sub(_pL->get(0), _pR->get(0), pOut->get());
1002     return pOut;
1003 }
1004
1005 template<class T, class U, class O>
1006 InternalType* sub_S_SC(T *_pL, U *_pR)
1007 {
1008     O* pOut = new O(0.0, 0.0);
1009     sub(_pL->get(), (size_t)1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1010     return pOut;
1011 }
1012
1013 template<class T, class U, class O>
1014 InternalType* sub_S_E(T *_pL, U *_pR)
1015 {
1016     O* pOut = new O(0);
1017     sub(_pL->get(0), pOut->get());
1018     return pOut;
1019 }
1020
1021
1022 template<class T, class U, class O>
1023 InternalType* sub_SC_M(T *_pL, U *_pR)
1024 {
1025     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1026     sub(_pL->get(0), _pL->getImg(0), (size_t)_pR->getSize(), _pR->get(), pOut->get(), pOut->getImg());
1027     return pOut;
1028 }
1029
1030 template<class T, class U, class O>
1031 InternalType* sub_SC_MC(T *_pL, U *_pR)
1032 {
1033     O* pOut = new O(_pR->getDims(), _pR->getDimsArray(), true);
1034     sub(_pL->get(0), _pL->getImg(0), (size_t)_pR->getSize(), _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
1035     return pOut;
1036 }
1037
1038 template<class T, class U, class O>
1039 InternalType* sub_SC_S(T *_pL, U *_pR)
1040 {
1041     O* pOut = new O(0.0, 0.0);
1042     sub(_pL->get(), _pL->getImg(), (size_t)1, _pR->get(0), pOut->get(), pOut->getImg());
1043     return pOut;
1044 }
1045
1046 template<class T, class U, class O>
1047 InternalType* sub_SC_SC(T *_pL, U *_pR)
1048 {
1049     O* pOut = new O(0.0, 0.0);
1050     sub(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1051     return pOut;
1052 }
1053
1054 template<class T, class U, class O>
1055 InternalType* sub_SC_E(T *_pL, U *_pR)
1056 {
1057     O* pOut = new O(0.0, 0.0);
1058     sub(_pL->get(0), _pL->getImg(0), (size_t)1, pOut->get(), pOut->getImg());
1059     return pOut;
1060 }
1061
1062
1063 template<class T, class U, class O>
1064 InternalType* sub_E_M(T *_pL, U *_pR)
1065 {
1066     return opposite_M<U, O>(_pR);
1067 }
1068
1069 template<class T, class U, class O>
1070 InternalType* sub_E_MC(T *_pL, U *_pR)
1071 {
1072     return opposite_MC<U, O>(_pR);
1073 }
1074
1075 template<class T, class U, class O>
1076 InternalType* sub_E_E(T *_pL, U *_pR)
1077 {
1078     Double* pOut = Double::Empty();
1079     sub();
1080     return pOut;
1081 }
1082
1083 template<class T, class U, class O>
1084 InternalType* sub_I_M(T *_pL, U *_pR)
1085 {
1086     int iDims = _pR->getDims();
1087     int* piDims = _pR->getDimsArray();
1088     O* pOut = (O*)opposite_M<U, O>(_pR);
1089     double dblLeft = _pL->get(0);
1090     int iLeadDims = piDims[0];
1091     int* piIndex = new int[iDims];
1092     piIndex[0] = 0;
1093
1094     //find smaller dims
1095     for (int i = 1 ; i < iDims ; ++i)
1096     {
1097         //init
1098         piIndex[i] = 0;
1099
1100         if (iLeadDims > piDims[i])
1101         {
1102             iLeadDims = piDims[i];
1103         }
1104     }
1105
1106     for (int i = 0 ; i < iLeadDims ; ++i)
1107     {
1108         for (int j = 0 ; j < iDims ; ++j)
1109         {
1110             piIndex[j] = i;
1111         }
1112
1113         int index = _pR->getIndex(piIndex);
1114         sub(dblLeft, _pR->get(index), pOut->get() + index);
1115     }
1116
1117     return pOut;
1118 }
1119
1120 template<class T, class U, class O>
1121 InternalType* sub_I_MC(T *_pL, U *_pR)
1122 {
1123     int iDims = _pR->getDims();
1124     int* piDims = _pR->getDimsArray();
1125     O* pOut = (O*)opposite_MC<U, O>(_pR);
1126     double* pdblOut = pOut->get();
1127     double* pdblRight = _pR->get();
1128     double dblLeft = _pL->get(0);
1129     int iLeadDims = piDims[0];
1130     int* piIndex = new int[iDims];
1131     piIndex[0] = 0;
1132
1133     //find smaller dims
1134     for (int i = 1 ; i < iDims ; ++i)
1135     {
1136         //init
1137         piIndex[i] = 0;
1138
1139         if (iLeadDims > piDims[i])
1140         {
1141             iLeadDims = piDims[i];
1142         }
1143     }
1144
1145     for (int i = 0 ; i < iLeadDims ; ++i)
1146     {
1147         for (int j = 0 ; j < iDims ; ++j)
1148         {
1149             piIndex[j] = i;
1150         }
1151
1152         int index = _pR->getIndex(piIndex);
1153         sub(dblLeft, pdblRight[index], pdblOut + index);
1154     }
1155
1156     return pOut;
1157 }
1158
1159 template<class T, class U, class O>
1160 InternalType* sub_IC_M(T *_pL, U *_pR)
1161 {
1162     int iDims = _pR->getDims();
1163     int* piDims = _pR->getDimsArray();
1164     O* pOut = (O*)opposite_M<U, O>(_pR);
1165     pOut->setComplex(true);
1166     double* pdblOutR = pOut->get();
1167     double* pdblOutI = pOut->getImg();
1168     double* pdblRight = _pR->get();
1169     double dblLeftR = _pL->get(0);
1170     double dblLeftI = _pL->getImg(0);
1171     int iLeadDims = piDims[0];
1172     int* piIndex = new int[iDims];
1173     piIndex[0] = 0;
1174
1175     //find smaller dims
1176     for (int i = 1 ; i < iDims ; ++i)
1177     {
1178         //init
1179         piIndex[i] = 0;
1180
1181         if (iLeadDims > piDims[i])
1182         {
1183             iLeadDims = piDims[i];
1184         }
1185     }
1186
1187     for (int i = 0 ; i < iLeadDims ; ++i)
1188     {
1189         for (int j = 0 ; j < iDims ; ++j)
1190         {
1191             piIndex[j] = i;
1192         }
1193
1194         int index = _pR->getIndex(piIndex);
1195         sub(&dblLeftR, &dblLeftI, (size_t)1, pdblRight[index], pdblOutR + index, pdblOutI + index);
1196     }
1197
1198     return pOut;
1199 }
1200
1201 template<class T, class U, class O>
1202 InternalType* sub_IC_MC(T *_pL, U *_pR)
1203 {
1204     int iDims = _pR->getDims();
1205     int* piDims = _pR->getDimsArray();
1206     O* pOut = (O*)opposite_MC<U, O>(_pR);
1207     double dblLeftR = _pL->get(0);
1208     double dblLeftI = _pL->getImg(0);
1209     double* pdblOutR = pOut->get();
1210     double* pdblOutI = pOut->getImg();
1211     double* pdblRightR = _pR->get();
1212     double* pdblRightI = _pR->getImg();
1213     int iLeadDims = piDims[0];
1214     int* piIndex = new int[iDims];
1215     piIndex[0] = 0;
1216     //find smaller dims
1217     for (int i = 1 ; i < iDims ; ++i)
1218     {
1219         //init
1220         piIndex[i] = 0;
1221
1222         if (iLeadDims > piDims[i])
1223         {
1224             iLeadDims = piDims[i];
1225         }
1226     }
1227
1228     for (int i = 0 ; i < iLeadDims ; ++i)
1229     {
1230         for (int j = 0 ; j < iDims ; ++j)
1231         {
1232             piIndex[j] = i;
1233         }
1234
1235         int index = _pR->getIndex(piIndex);
1236         sub(dblLeftR, dblLeftI, pdblRightR[index], pdblRightI[index], pdblOutR + index, pdblOutI + index);
1237     }
1238
1239     return pOut;
1240 }
1241
1242 template<class T, class U, class O>
1243 InternalType* sub_I_S(T *_pL, U *_pR)
1244 {
1245     return sub_S_S<T, U, O>(_pL, _pR);
1246 }
1247
1248 template<class T, class U, class O>
1249 InternalType* sub_IC_S(T *_pL, U *_pR)
1250 {
1251     return sub_SC_S<T, U, O>(_pL, _pR);
1252 }
1253
1254 template<class T, class U, class O>
1255 InternalType* sub_I_SC(T *_pL, U *_pR)
1256 {
1257     return sub_S_SC<T, U, O>(_pL, _pR);
1258 }
1259
1260 template<class T, class U, class O>
1261 InternalType* sub_IC_SC(T *_pL, U *_pR)
1262 {
1263     return sub_SC_SC<T, U, O>(_pL, _pR);
1264 }
1265
1266 template<class T, class U, class O> InternalType* sub_M_I(T *_pL, U *_pR)
1267 {
1268     int iDims = _pL->getDims();
1269     int* piDims = _pL->getDimsArray();
1270     O* pOut = (O*)_pL->clone();
1271     double* pdblOutR = pOut->get();
1272     double* pdblLeft = _pL->get();
1273     double dblRight = _pR->get(0);
1274     int iLeadDims = piDims[0];
1275     int* piIndex = new int[iDims];
1276     piIndex[0] = 0;
1277
1278     //find smaller dims
1279     for (int i = 1 ; i < iDims ; ++i)
1280     {
1281         //init
1282         piIndex[i] = 0;
1283
1284         if (iLeadDims > piDims[i])
1285         {
1286             iLeadDims = piDims[i];
1287         }
1288     }
1289
1290     for (int i = 0 ; i < iLeadDims ; ++i)
1291     {
1292         for (int j = 0 ; j < iDims ; ++j)
1293         {
1294             piIndex[j] = i;
1295         }
1296
1297         int index = _pL->getIndex(piIndex);
1298         sub(pdblLeft[index], (size_t)1, &dblRight, pdblOutR + index);
1299     }
1300
1301     return pOut;
1302 }
1303
1304 template<class T, class U, class O> InternalType* sub_MC_I(T *_pL, U *_pR)
1305 {
1306     return sub_M_I<T, U, O>(_pL, _pR);
1307 }
1308
1309 template<class T, class U, class O> InternalType* sub_M_IC(T *_pL, U *_pR)
1310 {
1311     int iDims = _pL->getDims();
1312     int* piDims = _pL->getDimsArray();
1313     O* pOut = (O*)_pL->clone();
1314     pOut->setComplex(true);
1315     double* pdblOutR = pOut->get();
1316     double* pdblOutI = pOut->getImg();
1317     double* pdblLeft = _pL->get();
1318     double dblRightR = _pR->get(0);
1319     double dblRightI = _pR->getImg(0);
1320     int iLeadDims = piDims[0];
1321     int* piIndex = new int[iDims];
1322     piIndex[0] = 0;
1323
1324     //find smaller dims
1325     for (int i = 1 ; i < iDims ; ++i)
1326     {
1327         //init
1328         piIndex[i] = 0;
1329
1330         if (iLeadDims > piDims[i])
1331         {
1332             iLeadDims = piDims[i];
1333         }
1334     }
1335
1336     for (int i = 0 ; i < iLeadDims ; ++i)
1337     {
1338         for (int j = 0 ; j < iDims ; ++j)
1339         {
1340             piIndex[j] = i;
1341         }
1342
1343         int index = _pL->getIndex(piIndex);
1344         sub(pdblLeft[index], (size_t)1, &dblRightR, &dblRightI, pdblOutR + index, pdblOutI + index);
1345     }
1346
1347     return pOut;
1348 }
1349
1350 template<class T, class U, class O> InternalType* sub_MC_IC(T *_pL, U *_pR)
1351 {
1352     int iDims = _pL->getDims();
1353     int* piDims = _pL->getDimsArray();
1354     O* pOut = (O*)_pL->clone();
1355     pOut->setComplex(true);
1356     double* pdblOutR = pOut->get();
1357     double* pdblOutI = pOut->getImg();
1358     double* pdblLeftR = _pL->get();
1359     double* pdblLeftI = _pL->getImg();
1360     double dblRightR = _pR->get(0);
1361     double dblRightI = _pR->getImg(0);
1362     int iLeadDims = piDims[0];
1363     int* piIndex = new int[iDims];
1364     piIndex[0] = 0;
1365
1366     //find smaller dims
1367     for (int i = 1 ; i < iDims ; ++i)
1368     {
1369         //init
1370         piIndex[i] = 0;
1371
1372         if (iLeadDims > piDims[i])
1373         {
1374             iLeadDims = piDims[i];
1375         }
1376     }
1377
1378     for (int i = 0 ; i < iLeadDims ; ++i)
1379     {
1380         for (int j = 0 ; j < iDims ; ++j)
1381         {
1382             piIndex[j] = i;
1383         }
1384
1385         int index = _pL->getIndex(piIndex);
1386         sub(pdblLeftR[index], pdblLeftI[index], (size_t)1, &dblRightR, &dblRightI, pdblOutR + index, pdblOutI + index);
1387     }
1388
1389     return pOut;
1390 }
1391
1392 template<class T, class U, class O> InternalType* sub_S_I(T *_pL, U *_pR)
1393 {
1394     return sub_S_S<T, U, O>(_pL, _pR);
1395 }
1396
1397 template<class T, class U, class O> InternalType* sub_SC_I(T *_pL, U *_pR)
1398 {
1399     return sub_SC_SC<T, U, O>(_pL, _pR);
1400 }
1401
1402 template<class T, class U, class O> InternalType* sub_S_IC(T *_pL, U *_pR)
1403 {
1404     return sub_S_SC<T, U, O>(_pL, _pR);
1405 }
1406
1407 template<class T, class U, class O> InternalType* sub_SC_IC(T *_pL, U *_pR)
1408 {
1409     return sub_SC_SC<T, U, O>(_pL, _pR);
1410 }
1411
1412 template<class T, class U, class O> InternalType* sub_I_I(T *_pL, U *_pR)
1413 {
1414     O* pOut = types::Double::Identity(-1, -1);
1415     sub(_pL->get(0), _pR->get(0), pOut->get());
1416     return pOut;
1417 }
1418
1419 template<class T, class U, class O> InternalType* sub_I_IC(T *_pL, U *_pR)
1420 {
1421     O* pOut = types::Double::Identity(-1, -1);
1422     pOut->setComplex(true);
1423     sub(_pL->get(), (size_t)1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1424     return pOut;
1425 }
1426
1427 template<class T, class U, class O> InternalType* sub_IC_I(T *_pL, U *_pR)
1428 {
1429     O* pOut = types::Double::Identity(-1, -1);
1430     pOut->setComplex(true);
1431     sub(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1432     return pOut;
1433 }
1434
1435 template<class T, class U, class O> InternalType* sub_IC_IC(T *_pL, U *_pR)
1436 {
1437     O* pOut = types::Double::Identity(-1, -1);
1438     pOut->setComplex(true);
1439     sub(_pL->get(0), _pL->getImg(0), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1440     return pOut;
1441 }
1442
1443 template<class T, class U, class O> types::InternalType* sub_I_E(T *_pL, U *_pR)
1444 {
1445     return (O*)_pL;
1446 }
1447
1448 template<class T, class U, class O> types::InternalType* sub_IC_E(T *_pL, U *_pR)
1449 {
1450     return (O*)_pL;
1451 }
1452
1453 template<class T, class U, class O> types::InternalType* sub_E_I(T *_pL, U *_pR)
1454 {
1455     return opposite_I<U, O>(_pR);
1456 }
1457
1458 template<class T, class U, class O> types::InternalType* sub_E_IC(T *_pL, U *_pR)
1459 {
1460     return opposite_IC<U, O>(_pR);
1461 }
1462
1463 template<> InternalType* sub_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1464 {
1465     Polynom* pOut = NULL;
1466     if (_pL->isScalar())
1467     {
1468         SinglePoly* p1Coef  = _pL->get(0);
1469         int iRank1          = p1Coef->getRank();
1470         int* pRank2         = new int[_pR->getSize()];
1471         int* pRankOut       = new int[_pR->getSize()];
1472
1473         _pR->getRank(pRank2);
1474         for (int i = 0 ; i < _pR->getSize() ; i++)
1475         {
1476             pRankOut[i] = std::max(iRank1, pRank2[i]);
1477         }
1478
1479         pOut = new Polynom(_pR->getVariableName(), _pR->getDims(), _pR->getDimsArray(), pRankOut);
1480         bool isOutComplex = _pL->isComplex() || _pR->isComplex();
1481
1482         //Result P1(0) - P2(i)
1483         double* p1R = p1Coef->get();
1484         if (isOutComplex)
1485         {
1486             double* p1I = p1Coef->getImg();
1487             for (int i = 0 ; i < _pR->getSize() ; i++)
1488             {
1489                 SinglePoly* p2Coef   = _pR->get(i);
1490                 double* p2R          = p2Coef->get();
1491                 double* p2I          = p2Coef->getImg();
1492
1493                 SinglePoly* pOutCoef = pOut->get(i);
1494                 pOutCoef->setComplex(isOutComplex);
1495                 double* pOutR        = pOutCoef->get();
1496                 double* pOutI        = pOutCoef->getImg();
1497
1498                 for (int j = 0 ; j < pRankOut[i] + 1 ; j++)
1499                 {
1500                     if (j > iRank1)
1501                     {
1502                         pOutR[j] = - p2R[j];
1503                         pOutI[j] = - (p2I ? p2I[j] : 0);
1504                     }
1505                     else if (j > pRank2[i])
1506                     {
1507                         pOutR[j] = p1R[j];
1508                         pOutI[j] = (p1I ? p1I[j] : 0);
1509                     }
1510                     else
1511                     {
1512                         pOutR[j] = p1R[j] - p2R[j];
1513                         pOutI[j] = (p1I ? p1I[j] : 0) - (p2I ? p2I[j] : 0);
1514                     }
1515                 }
1516             }
1517         }
1518         else
1519         {
1520             for (int i = 0 ; i < _pR->getSize() ; i++)
1521             {
1522                 SinglePoly* p2Coef   = _pR->get(i);
1523                 double* p2R          = p2Coef->get();
1524
1525                 SinglePoly* pOutCoef = pOut->get(i);
1526                 double* pOutR        = pOutCoef->get();
1527
1528                 for (int j = 0 ; j < pRankOut[i] + 1 ; j++)
1529                 {
1530                     if (j > iRank1)
1531                     {
1532                         pOutR[j] = - p2R[j];
1533                     }
1534                     else if (j > pRank2[i])
1535                     {
1536                         pOutR[j] = p1R[j];
1537                     }
1538                     else
1539                     {
1540                         pOutR[j] = p1R[j] - p2R[j];
1541                     }
1542                 }
1543             }
1544         }
1545
1546         delete[] pRankOut;
1547         delete[] pRank2;
1548         pOut->updateRank();
1549         return pOut;
1550     }
1551
1552     if (_pR->isScalar())
1553     {
1554         //size(p2) == 1
1555         int *pRank1     = new int[_pL->getSize()];
1556         int iRank2      = _pR->get(0)->getRank();
1557         int *pRankOut   = new int[_pL->getSize()];
1558
1559         _pL->getRank(pRank1);
1560         for (int i = 0 ; i < _pL->getSize() ; i++)
1561         {
1562             pRankOut[i] = std::max(pRank1[i], iRank2);
1563         }
1564
1565         pOut = new Polynom(_pL->getVariableName(), _pL->getDims(), _pL->getDimsArray(), pRankOut);
1566         bool isOutComplex = _pL->isComplex() || _pR->isComplex();
1567
1568         //Result P1(i) - P2(0)
1569         SinglePoly *p2Coef          = _pR->get(0);
1570         double *p2R                 = p2Coef->get();
1571
1572         if (isOutComplex)
1573         {
1574             double *p2I             = p2Coef->getImg();
1575             for (int i = 0 ; i < _pL->getSize() ; i++)
1576             {
1577                 SinglePoly *p1Coef      = _pL->get(i);
1578                 double *p1R             = p1Coef->get();
1579                 double *p1I             = p1Coef->getImg();
1580
1581                 SinglePoly *pOutCoef    = pOut->get(i);
1582                 pOutCoef->setComplex(isOutComplex);
1583                 double *pOutR           = pOutCoef->get();
1584                 double *pOutI           = pOutCoef->getImg();
1585
1586                 for (int j = 0 ; j < pRankOut[i] + 1 ; j++)
1587                 {
1588                     if (j > pRank1[j])
1589                     {
1590                         pOutR[j] = - p2R[j];
1591                         pOutI[j] = - (p2I ? p2I[j] : 0);
1592                     }
1593                     else if (j > iRank2)
1594                     {
1595                         pOutR[j] = p1R[j];
1596                         pOutI[j] = (p1I ? p1I[j] : 0);
1597                     }
1598                     else
1599                     {
1600                         pOutR[j] = p1R[j] - p2R[j];
1601                         pOutI[j] = (p1I ? p1I[j] : 0) - (p2I ? p2I[j] : 0);
1602                     }
1603                 }
1604             }
1605         }
1606         else
1607         {
1608             for (int i = 0 ; i < _pL->getSize() ; i++)
1609             {
1610                 SinglePoly *p1Coef      = _pL->get(i);
1611                 double *p1R             = p1Coef->get();
1612
1613                 SinglePoly *pOutCoef    = pOut->get(i);
1614                 double *pOutR           = pOutCoef->get();
1615
1616                 for (int j = 0 ; j < pRankOut[i] + 1 ; j++)
1617                 {
1618                     if (j > pRank1[j])
1619                     {
1620                         pOutR[j] = - p2R[j];
1621                     }
1622                     else if (j > iRank2)
1623                     {
1624                         pOutR[j] = p1R[j];
1625                     }
1626                     else
1627                     {
1628                         pOutR[j] = p1R[j] - p2R[j];
1629                     }
1630                 }
1631             }
1632         }
1633
1634         delete[] pRankOut;
1635         delete[] pRank1;
1636         pOut->updateRank();
1637         return pOut;
1638     }
1639
1640     //check dimension compatibilities
1641     int iDims1  = _pL->getDims();
1642     int iDims2  = _pR->getDims();
1643
1644     if (iDims1 != iDims2)
1645     {
1646         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1647     }
1648
1649     int* piDims1    = _pL->getDimsArray();
1650     int* piDims2    = _pR->getDimsArray();
1651
1652     for (int i = 0 ; i < iDims1 ; i++)
1653     {
1654         if (piDims1[i] != piDims2[i])
1655         {
1656             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
1657         }
1658     }
1659
1660     int *pRankOut   = new int[_pL->getSize()];
1661     int *pRank1     = new int[_pL->getSize()];
1662     int *pRank2     = new int[_pR->getSize()];
1663
1664     _pL->getRank(pRank1);
1665     _pR->getRank(pRank2);
1666     for (int i = 0 ; i < _pL->getSize() ; i++)
1667     {
1668         pRankOut[i] = std::max(pRank1[i], pRank2[i]);
1669     }
1670
1671     pOut = new Polynom(_pR->getVariableName(), iDims1, piDims1, pRankOut);
1672     bool isOutComplex =  _pL->isComplex() || _pR->isComplex();
1673
1674     //Result P1(i) - P2(i)
1675     for (int i = 0 ; i < _pL->getSize() ; i++)
1676     {
1677         SinglePoly* pOutCoef = pOut->get(i);
1678         pOutCoef->setComplex(isOutComplex);
1679
1680         double *p1R     = _pL->get(i)->get();
1681         double *p2R     = _pR->get(i)->get();
1682         double *pOutR   = pOutCoef->get();
1683         int iMin        = std::min(pRank1[i], pRank2[i]);
1684         int iMax        = std::max(pRank1[i], pRank2[i]);
1685
1686         for (int j = 0 ; j < iMin + 1 ; j++)
1687         {
1688             pOutR[j]    = p1R[j] - p2R[j];
1689         }
1690
1691         double *pTemp   = NULL;
1692         int iCoef       = 1;
1693         if (pRank1[i] > pRank2[i])
1694         {
1695             pTemp       = p1R;
1696             iCoef       = 1;
1697         }
1698         else
1699         {
1700             pTemp       = p2R;
1701             iCoef       = -1;
1702         }
1703
1704         for (int j = iMin + 1 ; j < iMax + 1 ; j++)
1705         {
1706             pOutR[j]    = pTemp[j] * iCoef;
1707         }
1708
1709         if (isOutComplex)
1710         {
1711             double *p1I     = _pL->get(i)->getImg();
1712             double *p2I     = _pR->get(i)->getImg();
1713             double *pOutI   = pOutCoef->getImg();
1714
1715             for (int j = 0 ; j < iMin + 1 ; j++)
1716             {
1717                 pOutI[j]    = (p1I == NULL ? 0 : p1I[j]) - (p2I == NULL ? 0 : p2I[j]);
1718             }
1719
1720             for (int j = iMin + 1 ; j < iMax + 1 ; j++)
1721             {
1722                 pOutI[j]  = pTemp[j] * iCoef;
1723             }
1724         }
1725     }
1726
1727     delete[] pRankOut;
1728     delete[] pRank1;
1729     delete[] pRank2;
1730
1731     pOut->updateRank();
1732     return pOut;
1733 }
1734
1735 // P - D
1736 template<> InternalType* sub_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1737 {
1738     Polynom* pOut = NULL;
1739
1740     bool bComplex1 = _pL->isComplex();
1741     bool bComplex2 = _pR->isComplex();
1742     bool isComplexOut = bComplex2 || bComplex1;
1743
1744     // P - []
1745     if (_pR->isEmpty())
1746     {
1747         return _pL;
1748     }
1749
1750     if (_pR->isIdentity())
1751     {
1752         double dblRightR = _pR->get(0);
1753         double dblRightI = 0;
1754         if (_pR->isComplex())
1755         {
1756             dblRightI = _pR->getImg(0);
1757         }
1758
1759         int iDims = _pL->getDims();
1760         int* piDims = _pL->getDimsArray();
1761         pOut = (Polynom*)_pL->clone();
1762         pOut->setComplex(isComplexOut);
1763         SinglePoly** pSPOut = pOut->get();
1764         SinglePoly** pSPLeft = _pL->get();
1765         int iLeadDims = piDims[0];
1766         int* piIndex = new int[iDims];
1767         piIndex[0] = 0;
1768
1769         //find smaller dims
1770         for (int i = 1 ; i < iDims ; ++i)
1771         {
1772             //init
1773             piIndex[i] = 0;
1774
1775             if (iLeadDims > piDims[i])
1776             {
1777                 iLeadDims = piDims[i];
1778             }
1779         }
1780
1781         if (isComplexOut)
1782         {
1783             for (int i = 0 ; i < iLeadDims ; ++i)
1784             {
1785                 for (int j = 0 ; j < iDims ; ++j)
1786                 {
1787                     piIndex[j] = i;
1788                 }
1789
1790                 int index = _pL->getIndex(piIndex);
1791                 sub(pSPLeft[index]->get(0), pSPLeft[index]->getImg(0), (size_t)1, &dblRightR, &dblRightI, pSPOut[index]->get(), pSPOut[index]->getImg());
1792             }
1793         }
1794         else
1795         {
1796             for (int i = 0 ; i < iLeadDims ; ++i)
1797             {
1798                 for (int j = 0 ; j < iDims ; ++j)
1799                 {
1800                     piIndex[j] = i;
1801                 }
1802
1803                 int index = _pL->getIndex(piIndex);
1804                 sub(pSPLeft[index]->get(0), (size_t)1, &dblRightR, pSPOut[index]->get());
1805             }
1806         }
1807         return pOut;
1808
1809     }
1810
1811     if (_pR->isScalar())
1812     {
1813         //subtract same value to all polynoms
1814         pOut = (Polynom*)_pL->clone();
1815         pOut->setComplex(isComplexOut);
1816
1817         SinglePoly** pSP = pOut->get();
1818         int iSize = pOut->getSize();
1819
1820         double dblR = _pR->get(0);
1821         if (isComplexOut)
1822         {
1823             double dblI = _pR->getImg(0);
1824             for (int i = 0 ; i < iSize ; ++i)
1825             {
1826                 pSP[i]->get()[0] -= dblR;
1827                 pSP[i]->getImg()[0] -= dblI;
1828             }
1829         }
1830         else
1831         {
1832             for (int i = 0 ; i < iSize ; ++i)
1833             {
1834                 pSP[i]->get()[0] -= dblR;
1835             }
1836         }
1837
1838         return pOut;
1839     }
1840
1841     if (_pL->isScalar())
1842     {
1843         //and _pR is not !
1844         int iDims = _pR->getDims();
1845         int* piDims = _pR->getDimsArray();
1846         int iSize = _pR->getSize();
1847
1848         pOut = new Polynom(_pL->getVariableName(), iDims, piDims);
1849
1850         SinglePoly* pSPL = _pL->get(0);
1851         if (_pR->isComplex())
1852         {
1853             double* pdblR = _pR->get();
1854             double* pdblI = _pR->getImg();
1855
1856             for (int i = 0 ; i < iSize ; ++i)
1857             {
1858                 SinglePoly* pSPOut = pSPL->clone();
1859                 //in case of original is not complex
1860                 pSPOut->setComplex(isComplexOut);
1861                 pSPOut->get()[0] -= pdblR[i];
1862                 pSPOut->getImg()[0] -= pdblI[i];
1863                 pOut->set(i, pSPOut);
1864             }
1865         }
1866         else
1867         {
1868             double* pdblR = _pR->get();
1869
1870             for (int i = 0 ; i < iSize ; ++i)
1871             {
1872                 SinglePoly* pSPOut = pSPL->clone();
1873                 //update 0th rank value
1874                 pSPOut->get()[0] -= pdblR[i];
1875                 pOut->set(i, pSPOut);
1876             }
1877         }
1878
1879         return pOut;
1880     }
1881
1882     //P - D
1883
1884     //check dimensions
1885     int iDims1 = _pR->getDims();
1886     int iDims2 = _pL->getDims();
1887
1888     if (iDims1 != iDims2)
1889     {
1890         wchar_t pMsg[bsiz];
1891         os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"-", _pL->DimToString().c_str(), _pR->DimToString().c_str());
1892         throw ast::ScilabError(pMsg);
1893     }
1894
1895     int* piDims1 = _pR->getDimsArray();
1896     int* piDims2 = _pL->getDimsArray();
1897
1898     for (int i = 0 ; i < iDims1 ; i++)
1899     {
1900         if (piDims1[i] != piDims2[i])
1901         {
1902             wchar_t pMsg[bsiz];
1903             os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"-", _pL->DimToString().c_str(), _pR->DimToString().c_str());
1904             throw ast::ScilabError(pMsg);
1905         }
1906     }
1907
1908     double* pInDblR = _pR->get();
1909     pOut = (Polynom*)_pL->clone();
1910     if (bComplex1 && bComplex2)
1911     {
1912         double* pInDblI = _pR->getImg();
1913         for (int i = 0 ; i < pOut->getSize() ; i++)
1914         {
1915             SinglePoly *pSPOut   = pOut->get(i);
1916             double *pOutPolyR    = pSPOut->get();
1917             double *pOutPolyI    = pSPOut->getImg();
1918
1919             pOutPolyR[0] -= pInDblR[i];
1920             pOutPolyI[0] -= pInDblI[i];
1921         }
1922     }
1923     else if (bComplex2)
1924     {
1925         double* pInDblI = _pR->getImg();
1926         pOut->setComplex(true);
1927         for (int i = 0 ; i < pOut->getSize() ; i++)
1928         {
1929             SinglePoly *pSPOut   = pOut->get(i);
1930             double *pOutPolyR    = pSPOut->get();
1931             double *pOutPolyI    = pSPOut->getImg();
1932
1933             pOutPolyR[0] -= pInDblR[i];
1934             pOutPolyI[0] = -pInDblI[i];
1935         }
1936     }
1937     else
1938     {
1939         for (int i = 0 ; i < pOut->getSize() ; i++)
1940         {
1941             SinglePoly *pSPOut = pOut->get(i);
1942             double *pOutPolyR  = pSPOut->get();
1943
1944             pOutPolyR[0] -= pInDblR[i];
1945         }
1946     }
1947
1948     return pOut;
1949 }
1950
1951 template<> InternalType* sub_I_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1952 {
1953     Polynom* pOut = (Polynom*)opposite_M<Polynom, Polynom>(_pR);
1954     double dblLeft = _pL->get(0);
1955
1956     int iDims = _pR->getDims();
1957     int* piDims = _pR->getDimsArray();
1958     int iSize = _pR->getSize();
1959     int iLeadDims = piDims[0];
1960     int* piIndex = new int[iDims];
1961     SinglePoly** pSP = _pR->get();
1962     SinglePoly** pSPOut = pOut->get();
1963     piIndex[0] = 0;
1964
1965     //find smaller dims
1966     for (int i = 1 ; i < iDims ; ++i)
1967     {
1968         //init
1969         piIndex[i] = 0;
1970
1971         if (iLeadDims > piDims[i])
1972         {
1973             iLeadDims = piDims[i];
1974         }
1975     }
1976
1977     for (int i = 0 ; i < iLeadDims ; ++i)
1978     {
1979         for (int j = 0 ; j < iDims ; ++j)
1980         {
1981             piIndex[j] = i;
1982         }
1983
1984         int index = _pR->getIndex(piIndex);
1985         sub(dblLeft, pSP[index]->get(0), pSPOut[index]->get());
1986     }
1987
1988     return pOut;
1989 }
1990
1991 template<> InternalType* sub_I_MC<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1992 {
1993     Polynom* pOut = (Polynom*)opposite_MC<Polynom, Polynom>(_pR);
1994     double dblLeft = _pL->get(0);
1995
1996     int iDims = _pR->getDims();
1997     int* piDims = _pR->getDimsArray();
1998     int iSize = _pR->getSize();
1999     int iLeadDims = piDims[0];
2000     int* piIndex = new int[iDims];
2001     SinglePoly** pSP = _pR->get();
2002     SinglePoly** pSPOut = pOut->get();
2003     piIndex[0] = 0;
2004
2005     for (int i = 0 ; i < iDims ; ++i)
2006     {
2007         //init
2008         piIndex[i] = 0;
2009
2010         if (iLeadDims > piDims[i])
2011         {
2012             iLeadDims = piDims[i];
2013         }
2014     }
2015
2016     for (int i = 0 ; i < iLeadDims ; ++i)
2017     {
2018         for (int j = 0 ; j < iDims ; ++j)
2019         {
2020             piIndex[j] = i;
2021         }
2022
2023         int index = _pR->getIndex(piIndex);
2024         sub(dblLeft, pSP[index]->get(0), pSPOut[index]->get());
2025     }
2026
2027     return pOut;
2028 }
2029
2030 template<> InternalType* sub_IC_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
2031 {
2032     Polynom* pOut = (Polynom*)opposite_M<Polynom, Polynom>(_pR);
2033     pOut->setComplex(true);
2034     double dblLeftR = _pL->get(0);
2035     double dblLeftI = _pL->getImg(0);
2036
2037     int iDims = _pR->getDims();
2038     int* piDims = _pR->getDimsArray();
2039     int iSize = _pR->getSize();
2040     int iLeadDims = piDims[0];
2041     int* piIndex = new int[iDims];
2042     SinglePoly** pSP = _pR->get();
2043     SinglePoly** pSPOut = pOut->get();
2044     piIndex[0] = 0;
2045
2046     for (int i = 0 ; i < iDims ; ++i)
2047     {
2048         //init
2049         piIndex[i] = 0;
2050
2051         if (iLeadDims > piDims[i])
2052         {
2053             iLeadDims = piDims[i];
2054         }
2055     }
2056
2057     for (int i = 0 ; i < iLeadDims ; ++i)
2058     {
2059         for (int j = 0 ; j < iDims ; ++j)
2060         {
2061             piIndex[j] = i;
2062         }
2063
2064         int index = _pR->getIndex(piIndex);
2065         sub(&dblLeftR, &dblLeftI, (size_t)1, pSP[index]->get(0), pSPOut[index]->get(), pSPOut[index]->getImg());
2066     }
2067
2068     return pOut;
2069 }
2070
2071 template<> InternalType* sub_IC_MC<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
2072 {
2073     Polynom* pOut = (Polynom*)opposite_MC<Polynom, Polynom>(_pR);
2074     double dblLeftR = _pL->get(0);
2075     double dblLeftI = _pL->getImg(0);
2076
2077     int iDims = _pR->getDims();
2078     int* piDims = _pR->getDimsArray();
2079     int iSize = _pR->getSize();
2080     int iLeadDims = piDims[0];
2081     int* piIndex = new int[iDims];
2082     SinglePoly** pSP = _pR->get();
2083     SinglePoly** pSPOut = pOut->get();
2084     piIndex[0] = 0;
2085
2086     for (int i = 0 ; i < iDims ; ++i)
2087     {
2088         //init
2089         piIndex[i] = 0;
2090
2091         if (iLeadDims > piDims[i])
2092         {
2093             iLeadDims = piDims[i];
2094         }
2095     }
2096
2097     for (int i = 0 ; i < iLeadDims ; ++i)
2098     {
2099         for (int j = 0 ; j < iDims ; ++j)
2100         {
2101             piIndex[j] = i;
2102         }
2103
2104         int index = _pR->getIndex(piIndex);
2105         sub(dblLeftR, dblLeftI, pSP[index]->get(0), pSP[index]->getImg(0), pSPOut[index]->get(), pSPOut[index]->getImg());
2106     }
2107
2108     return pOut;
2109 }
2110
2111 template<> InternalType* sub_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
2112 {
2113     Polynom* pOut = NULL;
2114     bool bComplex1 = _pL->isComplex();
2115     bool bComplex2 = _pR->isComplex();
2116
2117     double *pInDblR = _pL->getReal();
2118     double *pInDblI = _pL->getImg();
2119
2120     if (_pL->isEmpty())
2121     {
2122         return _pR;
2123     }
2124
2125     if (_pR->isScalar())
2126     {
2127         int *piRank = new int[_pL->getSize()];
2128         for (int i = 0 ; i < _pL->getSize() ; i++)
2129         {
2130             piRank[i] = _pR->get(0)->getRank();
2131         }
2132
2133         pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray(), piRank);
2134         if (bComplex1 || bComplex2)
2135         {
2136             pOut->setComplex(true);
2137         }
2138
2139         for (int i = 0 ; i < pOut->getSize() ; i++)
2140         {
2141             SinglePoly *pInPoly  = _pR->get(0);
2142             SinglePoly *pOutPoly = pOut->get(i);
2143             double *pInPolyR     = pInPoly->get();
2144             double *pOutPolyR    = pOutPoly->get();
2145
2146             pOutPolyR[0] = pInDblR[i] - pInPolyR[0];
2147
2148             for (int j = 1 ; j < pInPoly->getSize() ; j++)
2149             {
2150                 pOutPolyR[j] = -pInPolyR[j];
2151             }
2152         }
2153
2154         if (pOut->isComplex())
2155         {
2156             for (int i = 0 ; i < pOut->getSize() ; i++)
2157             {
2158                 SinglePoly *pInPoly  = _pR->get(0);
2159                 SinglePoly *pOutPoly = pOut->get(i);
2160                 double *pInPolyI     = pInPoly->getImg();
2161                 double *pOutPolyI    = pOutPoly->getImg();
2162
2163                 pOutPolyI[0] = (pInDblI != NULL ? pInDblI[i] : 0) - (pInPolyI != NULL ? pInPolyI[0] : 0);
2164
2165                 for (int j = 1 ; j < pInPoly->getSize() ; j++)
2166                 {
2167                     pOutPolyI[j] = (pInPolyI != NULL ? -pInPolyI[j] : 0);
2168                 }
2169             }
2170         }
2171
2172         return pOut;
2173     }
2174
2175     if (_pL->isScalar())
2176     {
2177         if (bComplex2)
2178         {
2179             pOut = (Polynom*)opposite_MC<Polynom, Polynom>(_pR);
2180         }
2181         else
2182         {
2183             pOut = (Polynom*)opposite_M<Polynom, Polynom>(_pR);
2184         }
2185
2186         int iSize = pOut->getSize();
2187
2188         if (bComplex1 && bComplex2)
2189         {
2190             for (int i = 0 ; i < iSize ; i++)
2191             {
2192                 SinglePoly *pSPOut   = pOut->get(i);
2193                 double *pOutPolyR    = pSPOut->get();
2194                 double *pOutPolyI    = pSPOut->getImg();
2195
2196                 pOutPolyR[0] += pInDblR[0];
2197                 pOutPolyI[0] += pInDblI[0];
2198             }
2199         }
2200         else if (bComplex1)
2201         {
2202             pOut->setComplex(true);
2203             for (int i = 0 ; i < iSize ; i++)
2204             {
2205                 SinglePoly *pSPOut   = pOut->get(i);
2206                 double *pOutPolyR    = pSPOut->get();
2207                 double *pOutPolyI    = pSPOut->getImg();
2208
2209                 pOutPolyR[0] += pInDblR[0];
2210                 pOutPolyI[0] = pInDblI[0];
2211             }
2212         }
2213         else
2214         {
2215             for (int i = 0 ; i < iSize ; i++)
2216             {
2217                 SinglePoly *pSPOut = pOut->get(i);
2218                 double *pOutPolyR  = pSPOut->get();
2219
2220                 pOutPolyR[0] += pInDblR[0];
2221             }
2222         }
2223
2224         return pOut;
2225     }
2226
2227     int iDims1 = _pR->getDims();
2228     int iDims2 = _pL->getDims();
2229
2230     if (iDims1 != iDims2)
2231     {
2232         wchar_t pMsg[bsiz];
2233         os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
2234         throw ast::ScilabError(pMsg);
2235     }
2236
2237     int* piDims1 = _pR->getDimsArray();
2238     int* piDims2 = _pL->getDimsArray();
2239
2240     for (int i = 0 ; i < iDims1 ; i++)
2241     {
2242         if (piDims1[i] != piDims2[i])
2243         {
2244             wchar_t pMsg[bsiz];
2245             os_swprintf(pMsg, bsiz, _W("Error: operator %ls: Matrix dimensions must agree (op1 is %ls, op2 is %ls).\n").c_str(),  L"+", _pL->DimToString().c_str(), _pR->DimToString().c_str());
2246             throw ast::ScilabError(pMsg);
2247         }
2248     }
2249
2250     if (bComplex2)
2251     {
2252         pOut = (Polynom*)opposite_MC<Polynom, Polynom>(_pR);
2253     }
2254     else
2255     {
2256         pOut = (Polynom*)opposite_M<Polynom, Polynom>(_pR);
2257     }
2258
2259     if (bComplex1 && bComplex2)
2260     {
2261         for (int i = 0 ; i < pOut->getSize() ; i++)
2262         {
2263             SinglePoly *pSPOut   = pOut->get(i);
2264             double *pOutPolyR    = pSPOut->get();
2265             double *pOutPolyI    = pSPOut->getImg();
2266
2267             pOutPolyR[0] += pInDblR[i];
2268             pOutPolyI[0] += pInDblI[i];
2269         }
2270     }
2271     else if (bComplex1)
2272     {
2273         pOut->setComplex(true);
2274         for (int i = 0 ; i < pOut->getSize() ; i++)
2275         {
2276             SinglePoly *pSPOut   = pOut->get(i);
2277             double *pOutPolyR    = pSPOut->get();
2278             double *pOutPolyI    = pSPOut->getImg();
2279
2280             pOutPolyR[0] += pInDblR[i];
2281             pOutPolyI[0] = pInDblI[i];
2282         }
2283     }
2284     else
2285     {
2286         for (int i = 0 ; i < pOut->getSize() ; i++)
2287         {
2288             SinglePoly *pSPOut = pOut->get(i);
2289             double *pOutPolyR  = pSPOut->get();
2290
2291             pOutPolyR[0] += pInDblR[i];
2292         }
2293     }
2294
2295     return pOut;
2296 }
2297
2298 //sp - sp
2299 template<> InternalType* sub_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
2300 {
2301     Sparse* pOut = NULL;
2302     //check scalar hidden in a sparse ;)
2303     if (_pL->getRows() == 1 && _pL->getCols() == 1)
2304     {
2305         //do scalar - sp
2306         Double* pDbl = NULL;
2307         if (_pL->isComplex())
2308         {
2309             std::complex<double> dbl = _pL->getImg(0, 0);
2310             pDbl = new Double(dbl.real(), dbl.imag());
2311         }
2312         else
2313         {
2314             pDbl = new Double(_pL->get(0, 0));
2315         }
2316
2317         //AddSparseToDouble(_pR, pDbl, (GenericType**)pOut);
2318         delete pDbl;
2319         return pOut;
2320     }
2321
2322     if (_pR->getRows() == 1 && _pR->getCols() == 1)
2323     {
2324         //do sp - scalar
2325         Double* pDbl = NULL;
2326         if (_pR->isComplex())
2327         {
2328             std::complex<double> dbl = _pR->getImg(0, 0);
2329             pDbl = new Double(dbl.real(), dbl.imag());
2330         }
2331         else
2332         {
2333             pDbl = new Double(_pR->get(0, 0));
2334         }
2335
2336         //AddSparseToDouble(_pL, pDbl, (GenericType**)pOut);
2337         delete pDbl;
2338         return 0;
2339     }
2340
2341     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
2342     {
2343         //dimensions not match
2344         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
2345     }
2346
2347     if (_pL->nonZeros() == 0)
2348     {
2349         //sp([]) - sp
2350         return _pR;
2351     }
2352
2353     if (_pR->nonZeros() == 0)
2354     {
2355         //sp - sp([])
2356         return _pL;
2357     }
2358
2359     return _pL->substract(*_pR);
2360 }
2361
2362 //d - sp
2363 template<> InternalType* sub_M_M<Double, Sparse, Double>(Double* _pL, Sparse* _pR)
2364 {
2365     Double* pOut = NULL;
2366     int iOne = 1; //fortran
2367     bool bComplex1 = _pL->isComplex();
2368     bool bComplex2 = _pR->isComplex();
2369
2370     if (_pL->isScalar() && _pR->isScalar())
2371     {
2372         //d - sp
2373         pOut = (Double*)_pL->clone();
2374         pOut->setComplex(bComplex1 | bComplex2);
2375         if (bComplex2)
2376         {
2377             std::complex<double> dbl = _pR->getImg(0, 0);
2378             pOut->set(0, dbl.real() - pOut->get(0));
2379             pOut->setImg(0, pOut->getImg(0) - dbl.imag());
2380         }
2381         else
2382         {
2383             pOut->set(0, pOut->get(0) - _pL->get(0, 0));
2384         }
2385
2386         return pOut;
2387     }
2388
2389     if (_pL->isScalar())
2390     {
2391         //d - SP
2392         pOut = new Double(_pR->getRows(), _pR->getCols(), bComplex1 | bComplex2);
2393         int iSize = _pR->getSize();
2394         double dblVal = _pL->get(0);
2395         double dblValI = 0;
2396         C2F(dset)(&iSize, &dblVal, pOut->get(), &iOne);
2397         if (bComplex1)
2398         {
2399             //initialize imag part at 0
2400             dblValI = _pL->getImg(0);
2401             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2402         }
2403         else if (bComplex2)
2404         {
2405             dblValI = 0;
2406             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2407         }
2408
2409         int nonZeros = static_cast<int>(_pR->nonZeros());
2410         int* pRows = new int[nonZeros * 2];
2411         _pR->outputRowCol(pRows);
2412         int* pCols = pRows + nonZeros;
2413
2414         if (pOut->isComplex())
2415         {
2416             for (int i = 0 ; i < nonZeros ; i++)
2417             {
2418                 int iRow = static_cast<int>(pRows[i]) - 1;
2419                 int iCol = static_cast<int>(pCols[i]) - 1;
2420                 std::complex<double> dbl = _pR->getImg(iRow, iCol);
2421                 pOut->set(iRow, iCol, dblVal - dbl.real());
2422                 pOut->setImg(iRow, iCol, dblValI - dbl.imag());
2423             }
2424         }
2425         else
2426         {
2427             for (int i = 0 ; i < nonZeros ; i++)
2428             {
2429                 int iRow = static_cast<int>(pRows[i]) - 1;
2430                 int iCol = static_cast<int>(pCols[i]) - 1;
2431                 pOut->set(iRow, iCol, dblVal - _pR->get(iRow, iCol));
2432             }
2433         }
2434
2435         //clear
2436         delete[] pRows;
2437
2438         return pOut;
2439     }
2440
2441     if (_pL->isScalar())
2442     {
2443         //D - sp
2444         pOut = (Double*)_pR->clone();
2445         pOut->setComplex(bComplex1 | bComplex2);
2446
2447         if (pOut->isComplex())
2448         {
2449             double* pReal = pOut->get();
2450             double* pImg = pOut->getImg();
2451             int size = pOut->getSize();
2452             for (int i = 0 ; i < size ; i++)
2453             {
2454                 std::complex<double> dbl = _pR->getImg(0, 0);
2455                 pReal[i] -= dbl.real();
2456                 pImg[i] -= dbl.imag();
2457             }
2458         }
2459         else
2460         {
2461             double* pReal = pOut->get();
2462             int size = pOut->getSize();
2463             for (int i = 0 ; i < size ; i++)
2464             {
2465                 pReal[i] -= pReal[i];
2466             }
2467         }
2468
2469         return pOut;
2470     }
2471
2472
2473     if (_pL->getRows() == _pR->getRows() && _pL->getCols() == _pR->getCols())
2474     {
2475         //D - SP
2476         pOut = (Double*)_pL->clone();
2477         pOut->setComplex(bComplex1 | bComplex2);
2478
2479         int nonZeros = static_cast<int>(_pR->nonZeros());
2480         int* pRows = new int[nonZeros * 2];
2481         _pR->outputRowCol(pRows);
2482         int* pCols = pRows + nonZeros;
2483
2484         if (bComplex1)
2485         {
2486             for (int i = 0 ; i < nonZeros ; i++)
2487             {
2488                 int iRow = static_cast<int>(pRows[i]) - 1;
2489                 int iCol = static_cast<int>(pCols[i]) - 1;
2490                 std::complex<double> dbl = _pR->getImg(iRow, iCol);
2491                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) - dbl.real());
2492                 pOut->setImg(iRow, iCol, pOut->getImg(iRow, iCol) - dbl.imag());
2493             }
2494         }
2495         else
2496         {
2497             for (int i = 0 ; i < nonZeros ; i++)
2498             {
2499                 int iRow = static_cast<int>(pRows[i]) - 1;
2500                 int iCol = static_cast<int>(pCols[i]) - 1;
2501                 pOut->set(iRow, iCol, pOut->get(iRow, iCol) - _pR->get(iRow, iCol));
2502             }
2503         }
2504
2505         //clear
2506         delete[] pRows;
2507         return pOut;
2508     }
2509     else
2510     {
2511         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
2512     }
2513 }
2514
2515 //sp - d
2516 template<> InternalType* sub_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _pR)
2517 {
2518     Double* pOut = NULL;
2519     int iOne = 1; //fortran
2520     bool bComplex1 = _pL->isComplex();
2521     bool bComplex2 = _pR->isComplex();
2522
2523     if (_pL->isScalar() && _pR->isScalar())
2524     {
2525         //sp - d
2526         pOut = (Double*)_pR->clone();
2527         pOut->setComplex(bComplex1 | bComplex2);
2528         if (bComplex1)
2529         {
2530             std::complex<double> dbl = _pL->getImg(0, 0);
2531             pOut->set(0, pOut->get(0) - dbl.real());
2532             pOut->setImg(0, dbl.imag() - pOut->getImg(0));
2533         }
2534         else
2535         {
2536             pOut->set(0, _pL->get(0, 0) - pOut->get(0));
2537         }
2538
2539         return pOut;
2540     }
2541
2542     if (_pR->isScalar())
2543     {
2544         //SP - d
2545         pOut = new Double(_pL->getRows(), _pL->getCols(), bComplex1 | bComplex2);
2546         int iSize = _pL->getSize();
2547         double dblVal = -_pR->get(0);
2548         double dblValI = 0;
2549         C2F(dset)(&iSize, &dblVal, pOut->get(), &iOne);
2550         if (bComplex2)
2551         {
2552             dblValI = -_pR->getImg(0);
2553             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2554         }
2555         else if (bComplex1)
2556         {
2557             //initialize imag part at 0
2558             dblValI = 0;
2559             C2F(dset)(&iSize, &dblValI, pOut->getImg(), &iOne);
2560         }
2561
2562         int nonZeros = static_cast<int>(_pL->nonZeros());
2563         int* pRows = new int[nonZeros * 2];
2564         _pL->outputRowCol(pRows);
2565         int* pCols = pRows + nonZeros;
2566
2567         if (bComplex1)
2568         {
2569             for (int i = 0 ; i < nonZeros ; i++)
2570             {
2571                 int iRow = static_cast<int>(pRows[i]) - 1;
2572                 int iCol = static_cast<int>(pCols[i]) - 1;
2573                 std::complex<double> dbl = _pL->getImg(iRow, iCol);
2574                 pOut->set(iRow, iCol, dbl.real() - (-dblVal));
2575                 pOut->setImg(iRow, iCol, dbl.imag() - (-dblValI));
2576             }
2577         }
2578         else
2579         {
2580             for (int i = 0 ; i < nonZeros ; i++)
2581             {
2582                 int iRow = static_cast<int>(pRows[i]) - 1;
2583                 int iCol = static_cast<int>(pCols[i]) - 1;
2584                 pOut->set(iRow, iCol, _pL->get(iRow, iCol) - (-dblVal));
2585             }
2586         }
2587
2588         //clear
2589         delete[] pRows;
2590
2591         return pOut;
2592     }
2593
2594     if (_pL->isScalar())
2595     {
2596         //sp - D
2597         pOut = (Double*)_pR->clone();
2598         pOut->setComplex(bComplex1 | bComplex2);
2599
2600         if (bComplex1)
2601         {
2602             double* pReal = pOut->get();
2603             double* pImg = pOut->getImg();
2604             int size = pOut->getSize();
2605             for (int i = 0 ; i < size ; i++)
2606             {
2607                 std::complex<double> dbl = _pL->getImg(0, 0);
2608                 pReal[i] = dbl.real() - pReal[i];
2609                 pImg[i] = dbl.imag() - pImg[i];
2610             }
2611         }
2612         else
2613         {
2614             double* pReal = pOut->get();
2615             int size = pOut->getSize();
2616             for (int i = 0 ; i < size ; i++)
2617             {
2618                 pReal[i] = _pL->get(0, 0) - pReal[i];
2619             }
2620         }
2621
2622         return pOut;
2623     }
2624
2625
2626     if (_pL->getRows() == _pR->getRows() && _pL->getCols() == _pR->getCols())
2627     {
2628         //SP - D
2629         pOut = (Double*)_pR->clone();
2630         pOut->setComplex(bComplex1 | bComplex2);
2631
2632         int nonZeros = static_cast<int>(_pL->nonZeros());
2633         int* pRows = new int[nonZeros * 2];
2634         _pL->outputRowCol(pRows);
2635         int* pCols = pRows + nonZeros;
2636
2637         if (bComplex1)
2638         {
2639             for (int i = 0 ; i < nonZeros ; i++)
2640             {
2641                 int iRow = static_cast<int>(pRows[i]) - 1;
2642                 int iCol = static_cast<int>(pCols[i]) - 1;
2643                 std::complex<double> dbl = _pL->getImg(iRow, iCol);
2644                 pOut->set(iRow, iCol, dbl.real() - pOut->get(iRow, iCol));
2645                 pOut->setImg(iRow, iCol, dbl.imag() - pOut->getImg(iRow, iCol));
2646             }
2647         }
2648         else
2649         {
2650             for (int i = 0 ; i < nonZeros ; i++)
2651             {
2652                 int iRow = static_cast<int>(pRows[i]) - 1;
2653                 int iCol = static_cast<int>(pCols[i]) - 1;
2654                 pOut->set(iRow, iCol, _pL->get(iRow, iCol) - pOut->get(iRow, iCol));
2655             }
2656         }
2657
2658         //clear
2659         delete[] pRows;
2660         return pOut;
2661     }
2662     else
2663     {
2664         throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
2665     }
2666 }
2667
2668 //[] - sp
2669 template<> InternalType* sub_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
2670 {
2671     return sub_M_M<Sparse, Double, Sparse>(_pR, _pL);
2672 }
2673
2674 //sp - []
2675 template<> InternalType* sub_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
2676 {
2677     Sparse* pOut = NULL;
2678     if (_pR->isIdentity())
2679     {
2680         //convert to _pL
2681         Sparse* pS = new Sparse(_pL->getRows(), _pL->getCols(), _pR->isComplex());
2682         if (pS->isComplex())
2683         {
2684             int size = std::min(_pL->getRows(), _pL->getCols());
2685             for (int i = 0 ; i < size ; i++)
2686             {
2687                 pS->set(i, i, std::complex<double>(_pR->get(0), _pR->getImg(0)));
2688             }
2689         }
2690         else
2691         {
2692             int size = std::min(_pL->getRows(), _pL->getCols());
2693             for (int i = 0 ; i < size ; i++)
2694             {
2695                 pS->set(i, i, _pR->get(0));
2696             }
2697         }
2698
2699         //AddSparseToSparse(_pL, pS, (Sparse**)pOut);
2700         delete pS;
2701         return pOut;
2702     }
2703     else
2704     {
2705         //is []
2706         return _pL;
2707     }
2708 }