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