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

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
   4  *
   5  *  This file must be used under the terms of the CeCILL.
   6  *  This source file is licensed as described in the file COPYING, which
   7  *  you should have received as part of this distribution.  The terms
   8  *  are also available at
   9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 #include "types_dotmultiplication.hxx"
  14 #include "double.hxx"
  15 #include "int.hxx"
  16 #include "sparse.hxx"
  17 #include "polynom.hxx"
  18
  19
  20 extern "C"
  21 {
  22 #include "localization.h"
  23 }
  24
  25
  26 using namespace types;
  27 //define arrays on operation functions
  28 static dotmul_function pDotMulfunction[types::InternalType::IdLast][types::InternalType::IdLast] = {NULL};
  29
  30 void fillDotMulFunction()
  31 {
  32 #define scilab_fill_dotmul(id1, id2, func, typeIn1, typeIn2, typeOut) \
  33     pDotMulfunction[types::InternalType::Id ## id1][types::InternalType::Id ## id2] = (dotmul_function)&dotmul_##func<typeIn1, typeIn2, typeOut>
  34
  35     //Double
  36     //Matrix .* Matrix
  37     scilab_fill_dotmul(Double, Double, M_M, Double, Double, Double);
  38     scilab_fill_dotmul(Double, Int8, M_M, Double, Int8, Int8);
  39     scilab_fill_dotmul(Double, UInt8, M_M, Double, UInt8, UInt8);
  40     scilab_fill_dotmul(Double, Int16, M_M, Double, Int16, Int16);
  41     scilab_fill_dotmul(Double, UInt16, M_M, Double, UInt16, UInt16);
  42     scilab_fill_dotmul(Double, Int32, M_M, Double, Int32, Int32);
  43     scilab_fill_dotmul(Double, UInt32, M_M, Double, UInt32, UInt32);
  44     scilab_fill_dotmul(Double, Int64, M_M, Double, Int64, Int64);
  45     scilab_fill_dotmul(Double, UInt64, M_M, Double, UInt64, UInt64);
  46     scilab_fill_dotmul(Double, Bool, M_M, Double, Bool, Double);
  47     scilab_fill_dotmul(Double, Polynom, M_M, Double, Polynom, Polynom);
  48     scilab_fill_dotmul(Double, Sparse, M_M, Double, Sparse, Sparse);
  49
  50     //Matrix .* Matrix Complex
  51     scilab_fill_dotmul(Double, DoubleComplex, M_MC, Double, Double, Double);
  52     scilab_fill_dotmul(Double, PolynomComplex, M_M, Double, Polynom, Polynom);
  53     scilab_fill_dotmul(Double, SparseComplex, M_M, Double, Sparse, Sparse);
  54
  55     //Matrix .* Scalar
  56     scilab_fill_dotmul(Double, ScalarDouble, M_S, Double, Double, Double);
  57     scilab_fill_dotmul(Double, ScalarInt8, M_S, Double, Int8, Int8);
  58     scilab_fill_dotmul(Double, ScalarUInt8, M_S, Double, UInt8, UInt8);
  59     scilab_fill_dotmul(Double, ScalarInt16, M_S, Double, Int16, Int16);
  60     scilab_fill_dotmul(Double, ScalarUInt16, M_S, Double, UInt16, UInt16);
  61     scilab_fill_dotmul(Double, ScalarInt32, M_S, Double, Int32, Int32);
  62     scilab_fill_dotmul(Double, ScalarUInt32, M_S, Double, UInt32, UInt32);
  63     scilab_fill_dotmul(Double, ScalarInt64, M_S, Double, Int64, Int64);
  64     scilab_fill_dotmul(Double, ScalarUInt64, M_S, Double, UInt64, UInt64);
  65     scilab_fill_dotmul(Double, ScalarBool, M_S, Double, Bool, Double);
  66     scilab_fill_dotmul(Double, ScalarPolynom, M_M, Double, Polynom, Polynom);
  67
  68     //Matrix .* Scalar Complex
  69     scilab_fill_dotmul(Double, ScalarDoubleComplex, M_SC, Double, Double, Double);
  70     scilab_fill_dotmul(Double, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
  71     //Matrix .* Empty
  72     scilab_fill_dotmul(Double, Empty, M_E, Double, Double, Double);
  73
  74
  75     //Matrix Complex .* Matrix
  76     scilab_fill_dotmul(DoubleComplex, Double, MC_M, Double, Double, Double);
  77     scilab_fill_dotmul(DoubleComplex, DoubleComplex, MC_MC, Double, Double, Double);
  78     scilab_fill_dotmul(DoubleComplex, ScalarDouble, MC_S, Double, Double, Double);
  79     scilab_fill_dotmul(DoubleComplex, ScalarDoubleComplex, MC_SC, Double, Double, Double);
  80     scilab_fill_dotmul(DoubleComplex, Empty, M_E, Double, Double, Double);
  81     scilab_fill_dotmul(DoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
  82     scilab_fill_dotmul(DoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
  83     scilab_fill_dotmul(DoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
  84     scilab_fill_dotmul(DoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
  85     scilab_fill_dotmul(DoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
  86     scilab_fill_dotmul(DoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
  87
  88     //Scalar .* Matrix
  89     scilab_fill_dotmul(ScalarDouble, Double, S_M, Double, Double, Double);
  90     scilab_fill_dotmul(ScalarDouble, Int8, S_M, Double, Int8, Int8);
  91     scilab_fill_dotmul(ScalarDouble, UInt8, S_M, Double, UInt8, UInt8);
  92     scilab_fill_dotmul(ScalarDouble, Int16, S_M, Double, Int16, Int16);
  93     scilab_fill_dotmul(ScalarDouble, UInt16, S_M, Double, UInt16, UInt16);
  94     scilab_fill_dotmul(ScalarDouble, Int32, S_M, Double, Int32, Int32);
  95     scilab_fill_dotmul(ScalarDouble, UInt32, S_M, Double, UInt32, UInt32);
  96     scilab_fill_dotmul(ScalarDouble, Int64, S_M, Double, Int64, Int64);
  97     scilab_fill_dotmul(ScalarDouble, UInt64, S_M, Double, UInt64, UInt64);
  98     scilab_fill_dotmul(ScalarDouble, Bool, S_M, Double, Bool, Double);
  99     scilab_fill_dotmul(ScalarDouble, Polynom, M_M, Double, Polynom, Polynom);
 100     scilab_fill_dotmul(ScalarDouble, Sparse, M_M, Double, Sparse, Sparse);
 101
 102     //Scalar .* Matrix Complex
 103     scilab_fill_dotmul(ScalarDouble, DoubleComplex, S_MC, Double, Double, Double);
 104     scilab_fill_dotmul(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
 105     scilab_fill_dotmul(ScalarDouble, SparseComplex, M_M, Double, Sparse, Sparse);
 106
 107     //Scalar .* Scalar
 108     scilab_fill_dotmul(ScalarDouble, ScalarDouble, S_S, Double, Double, Double);
 109     scilab_fill_dotmul(ScalarDouble, ScalarInt8, S_S, Double, Int8, Int8);
 110     scilab_fill_dotmul(ScalarDouble, ScalarUInt8, S_S, Double, UInt8, UInt8);
 111     scilab_fill_dotmul(ScalarDouble, ScalarInt16, S_S, Double, Int16, Int16);
 112     scilab_fill_dotmul(ScalarDouble, ScalarUInt16, S_S, Double, UInt16, UInt16);
 113     scilab_fill_dotmul(ScalarDouble, ScalarInt32, S_S, Double, Int32, Int32);
 114     scilab_fill_dotmul(ScalarDouble, ScalarUInt32, S_S, Double, UInt32, UInt32);
 115     scilab_fill_dotmul(ScalarDouble, ScalarInt64, S_S, Double, Int64, Int64);
 116     scilab_fill_dotmul(ScalarDouble, ScalarUInt64, S_S, Double, UInt64, UInt64);
 117     scilab_fill_dotmul(ScalarDouble, ScalarBool, S_S, Double, Bool, Double);
 118     scilab_fill_dotmul(ScalarDouble, ScalarPolynom, M_M, Double, Polynom, Polynom);
 119
 120     //Scalar .* Scalar Complex
 121     scilab_fill_dotmul(ScalarDouble, ScalarDoubleComplex, S_SC, Double, Double, Double);
 122     scilab_fill_dotmul(ScalarDouble, PolynomComplex, M_M, Double, Polynom, Polynom);
 123     scilab_fill_dotmul(ScalarDouble, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 124
 125     //Scalar .* Empty
 126     scilab_fill_dotmul(ScalarDouble, Empty, M_E, Double, Double, Double);
 127
 128     //Scalar Complex .* Matrix
 129     scilab_fill_dotmul(ScalarDoubleComplex, Double, SC_M, Double, Double, Double);
 130     scilab_fill_dotmul(ScalarDoubleComplex, Polynom, M_M, Double, Polynom, Polynom);
 131     scilab_fill_dotmul(ScalarDoubleComplex, Sparse, M_M, Double, Sparse, Sparse);
 132     //Scalar Complex .* Matrix Complex
 133     scilab_fill_dotmul(ScalarDoubleComplex, DoubleComplex, SC_MC, Double, Double, Double);
 134     scilab_fill_dotmul(ScalarDoubleComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
 135     scilab_fill_dotmul(ScalarDoubleComplex, SparseComplex, M_M, Double, Sparse, Sparse);
 136     //Scalar Complex .* Scalar
 137     scilab_fill_dotmul(ScalarDoubleComplex, ScalarDouble, SC_S, Double, Double, Double);
 138     scilab_fill_dotmul(ScalarDoubleComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
 139     //Scalar Complex .* Scalar Complex
 140     scilab_fill_dotmul(ScalarDoubleComplex, ScalarDoubleComplex, SC_SC, Double, Double, Double);
 141     scilab_fill_dotmul(ScalarDoubleComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 142     //Scalar Complex .* Empty
 143     scilab_fill_dotmul(ScalarDoubleComplex, Empty, M_E, Double, Double, Double);
 144
 145     //Empty .* Matrix
 146     scilab_fill_dotmul(Empty, Double, E_M, Double, Double, Double);
 147     scilab_fill_dotmul(Empty, Int8, E_M, Double, Int8, Double);
 148     scilab_fill_dotmul(Empty, UInt8, E_M, Double, UInt8, Double);
 149     scilab_fill_dotmul(Empty, Int16, E_M, Double, Int16, Double);
 150     scilab_fill_dotmul(Empty, UInt16, E_M, Double, UInt16, Double);
 151     scilab_fill_dotmul(Empty, Int32, E_M, Double, Int32, Double);
 152     scilab_fill_dotmul(Empty, UInt32, E_M, Double, UInt32, Double);
 153     scilab_fill_dotmul(Empty, Int64, E_M, Double, Int64, Double);
 154     scilab_fill_dotmul(Empty, UInt64, E_M, Double, UInt64, Double);
 155     scilab_fill_dotmul(Empty, Polynom, E_M, Double, Polynom, Double);
 156     scilab_fill_dotmul(Empty, PolynomComplex, E_M, Double, Polynom, Double);
 157     scilab_fill_dotmul(Empty, Sparse, E_M, Double, Sparse, Double);
 158     scilab_fill_dotmul(Empty, SparseComplex, E_M, Double, Sparse, Double);
 159
 160     //Empty .* Matrix Complex
 161     scilab_fill_dotmul(Empty, DoubleComplex, E_M, Double, Double, Double);
 162     //Empty .* Scalar
 163     scilab_fill_dotmul(Empty, ScalarDouble, E_M, Double, Double, Double);
 164     scilab_fill_dotmul(Empty, ScalarInt8, E_M, Double, Int8, Double);
 165     scilab_fill_dotmul(Empty, ScalarUInt8, E_M, Double, UInt8, Double);
 166     scilab_fill_dotmul(Empty, ScalarInt16, E_M, Double, Int16, Double);
 167     scilab_fill_dotmul(Empty, ScalarUInt16, E_M, Double, UInt16, Double);
 168     scilab_fill_dotmul(Empty, ScalarInt32, E_M, Double, Int32, Double);
 169     scilab_fill_dotmul(Empty, ScalarUInt32, E_M, Double, UInt32, Double);
 170     scilab_fill_dotmul(Empty, ScalarInt64, E_M, Double, Int64, Double);
 171     scilab_fill_dotmul(Empty, ScalarUInt64, E_M, Double, UInt64, Double);
 172     scilab_fill_dotmul(Empty, ScalarBool, E_M, Double, Bool, Double);
 173     scilab_fill_dotmul(Empty, ScalarPolynom, E_M, Double, Polynom, Double);
 174
 175     //Empty .* Scalar Complex
 176     scilab_fill_dotmul(Empty, ScalarDoubleComplex, E_M, Double, Double, Double);
 177     scilab_fill_dotmul(Empty, ScalarPolynomComplex, E_M, Double, Polynom, Double);
 178     //Empty .* Empty
 179     scilab_fill_dotmul(Empty, Empty, E_M, Double, Double, Double);
 180     //Empty .* eye
 181     scilab_fill_dotmul(Empty, Identity, E_M, Double, Double, Double);
 182     scilab_fill_dotmul(Empty, IdentityComplex, E_M, Double, Double, Double);
 183
 184     //Matrix .* Identity
 185     scilab_fill_dotmul(Double, Identity, M_I, Double, Double, Double);
 186     scilab_fill_dotmul(Double, IdentityComplex, M_IC, Double, Double, Double);
 187     scilab_fill_dotmul(DoubleComplex, Identity, MC_I, Double, Double, Double);
 188     scilab_fill_dotmul(DoubleComplex, IdentityComplex, MC_IC, Double, Double, Double);
 189     scilab_fill_dotmul(ScalarDouble, Identity, S_I, Double, Double, Double);
 190     scilab_fill_dotmul(ScalarDouble, IdentityComplex, S_IC, Double, Double, Double);
 191     scilab_fill_dotmul(ScalarDoubleComplex, Identity, SC_I, Double, Double, Double);
 192     scilab_fill_dotmul(ScalarDoubleComplex, IdentityComplex, SC_IC, Double, Double, Double);
 193
 194     //Int8
 195     //Matrix .* Matrix
 196     scilab_fill_dotmul(Int8, Double, M_M, Int8, Double, Int8);
 197     scilab_fill_dotmul(Int8, Int8, M_M, Int8, Int8, Int8);
 198     scilab_fill_dotmul(Int8, UInt8, M_M, Int8, UInt8, UInt8);
 199     scilab_fill_dotmul(Int8, Int16, M_M, Int8, Int16, Int16);
 200     scilab_fill_dotmul(Int8, UInt16, M_M, Int8, UInt16, UInt16);
 201     scilab_fill_dotmul(Int8, Int32, M_M, Int8, Int32, Int32);
 202     scilab_fill_dotmul(Int8, UInt32, M_M, Int8, UInt32, UInt32);
 203     scilab_fill_dotmul(Int8, Int64, M_M, Int8, Int64, Int64);
 204     scilab_fill_dotmul(Int8, UInt64, M_M, Int8, UInt64, UInt64);
 205     scilab_fill_dotmul(Int8, Bool, M_M, Int8, Bool, Int8);
 206     scilab_fill_dotmul(Int8, Empty, M_E, Int8, Double, Double);
 207
 208     //Matrix .* Scalar
 209     scilab_fill_dotmul(Int8, ScalarDouble, M_S, Int8, Double, Int8);
 210     scilab_fill_dotmul(Int8, ScalarInt8, M_S, Int8, Int8, Int8);
 211     scilab_fill_dotmul(Int8, ScalarUInt8, M_S, Int8, UInt8, UInt8);
 212     scilab_fill_dotmul(Int8, ScalarInt16, M_S, Int8, Int16, Int16);
 213     scilab_fill_dotmul(Int8, ScalarUInt16, M_S, Int8, UInt16, UInt16);
 214     scilab_fill_dotmul(Int8, ScalarInt32, M_S, Int8, Int32, Int32);
 215     scilab_fill_dotmul(Int8, ScalarUInt32, M_S, Int8, UInt32, UInt32);
 216     scilab_fill_dotmul(Int8, ScalarInt64, M_S, Int8, Int64, Int64);
 217     scilab_fill_dotmul(Int8, ScalarUInt64, M_S, Int8, UInt64, UInt64);
 218     scilab_fill_dotmul(Int8, ScalarBool, M_S, Int8, Bool, Int8);
 219
 220     //Scalar .* Matrix
 221     scilab_fill_dotmul(ScalarInt8, Double, S_M, Int8, Double, Int8);
 222     scilab_fill_dotmul(ScalarInt8, Int8, S_M, Int8, Int8, Int8);
 223     scilab_fill_dotmul(ScalarInt8, UInt8, S_M, Int8, UInt8, UInt8);
 224     scilab_fill_dotmul(ScalarInt8, Int16, S_M, Int8, Int16, Int16);
 225     scilab_fill_dotmul(ScalarInt8, UInt16, S_M, Int8, UInt16, UInt16);
 226     scilab_fill_dotmul(ScalarInt8, Int32, S_M, Int8, Int32, Int32);
 227     scilab_fill_dotmul(ScalarInt8, UInt32, S_M, Int8, UInt32, UInt32);
 228     scilab_fill_dotmul(ScalarInt8, Int64, S_M, Int8, Int64, Int64);
 229     scilab_fill_dotmul(ScalarInt8, UInt64, S_M, Int8, UInt64, UInt64);
 230     scilab_fill_dotmul(ScalarInt8, Bool, S_M, Int8, Bool, Int8);
 231     scilab_fill_dotmul(ScalarInt8, Empty, M_E, Int8, Double, Double);
 232
 233     //Scalar .* Scalar
 234     scilab_fill_dotmul(ScalarInt8, ScalarDouble, S_S, Int8, Double, Int8);
 235     scilab_fill_dotmul(ScalarInt8, ScalarInt8, S_S, Int8, Int8, Int8);
 236     scilab_fill_dotmul(ScalarInt8, ScalarUInt8, S_S, Int8, UInt8, UInt8);
 237     scilab_fill_dotmul(ScalarInt8, ScalarInt16, S_S, Int8, Int16, Int16);
 238     scilab_fill_dotmul(ScalarInt8, ScalarUInt16, S_S, Int8, UInt16, UInt16);
 239     scilab_fill_dotmul(ScalarInt8, ScalarInt32, S_S, Int8, Int32, Int32);
 240     scilab_fill_dotmul(ScalarInt8, ScalarUInt32, S_S, Int8, UInt32, UInt32);
 241     scilab_fill_dotmul(ScalarInt8, ScalarInt64, S_S, Int8, Int64, Int64);
 242     scilab_fill_dotmul(ScalarInt8, ScalarUInt64, S_S, Int8, UInt64, UInt64);
 243     scilab_fill_dotmul(ScalarInt8, ScalarBool, S_S, Int8, Bool, Int8);
 244
 245     //UInt8
 246     //Matrix .* Matrix
 247     scilab_fill_dotmul(UInt8, Double, M_M, UInt8, Double, UInt8);
 248     scilab_fill_dotmul(UInt8, Int8, M_M, UInt8, Int8, UInt8);
 249     scilab_fill_dotmul(UInt8, UInt8, M_M, UInt8, UInt8, UInt8);
 250     scilab_fill_dotmul(UInt8, Int16, M_M, UInt8, Int16, UInt16);
 251     scilab_fill_dotmul(UInt8, UInt16, M_M, UInt8, UInt16, UInt16);
 252     scilab_fill_dotmul(UInt8, Int32, M_M, UInt8, Int32, UInt32);
 253     scilab_fill_dotmul(UInt8, UInt32, M_M, UInt8, UInt32, UInt32);
 254     scilab_fill_dotmul(UInt8, Int64, M_M, UInt8, Int64, UInt64);
 255     scilab_fill_dotmul(UInt8, UInt64, M_M, UInt8, UInt64, UInt64);
 256     scilab_fill_dotmul(UInt8, Bool, M_M, UInt8, Bool, UInt8);
 257     scilab_fill_dotmul(UInt8, Empty, M_E, UInt8, Double, Double);
 258
 259     //Matrix .* Scalar
 260     scilab_fill_dotmul(UInt8, ScalarDouble, M_S, UInt8, Double, UInt8);
 261     scilab_fill_dotmul(UInt8, ScalarInt8, M_S, UInt8, Int8, UInt8);
 262     scilab_fill_dotmul(UInt8, ScalarUInt8, M_S, UInt8, UInt8, UInt8);
 263     scilab_fill_dotmul(UInt8, ScalarInt16, M_S, UInt8, Int16, UInt16);
 264     scilab_fill_dotmul(UInt8, ScalarUInt16, M_S, UInt8, UInt16, UInt16);
 265     scilab_fill_dotmul(UInt8, ScalarInt32, M_S, UInt8, Int32, UInt32);
 266     scilab_fill_dotmul(UInt8, ScalarUInt32, M_S, UInt8, UInt32, UInt32);
 267     scilab_fill_dotmul(UInt8, ScalarInt64, M_S, UInt8, Int64, UInt64);
 268     scilab_fill_dotmul(UInt8, ScalarUInt64, M_S, UInt8, UInt64, UInt64);
 269     scilab_fill_dotmul(UInt8, ScalarBool, M_S, UInt8, Bool, UInt8);
 270
 271     //Scalar .* Matrix
 272     scilab_fill_dotmul(ScalarUInt8, Double, S_M, UInt8, Double, UInt8);
 273     scilab_fill_dotmul(ScalarUInt8, Int8, S_M, UInt8, Int8, UInt8);
 274     scilab_fill_dotmul(ScalarUInt8, UInt8, S_M, UInt8, UInt8, UInt8);
 275     scilab_fill_dotmul(ScalarUInt8, Int16, S_M, UInt8, Int16, UInt16);
 276     scilab_fill_dotmul(ScalarUInt8, UInt16, S_M, UInt8, UInt16, UInt16);
 277     scilab_fill_dotmul(ScalarUInt8, Int32, S_M, UInt8, Int32, UInt32);
 278     scilab_fill_dotmul(ScalarUInt8, UInt32, S_M, UInt8, UInt32, UInt32);
 279     scilab_fill_dotmul(ScalarUInt8, Int64, S_M, UInt8, Int64, UInt64);
 280     scilab_fill_dotmul(ScalarUInt8, UInt64, S_M, UInt8, UInt64, UInt64);
 281     scilab_fill_dotmul(ScalarUInt8, Bool, S_M, UInt8, Bool, UInt8);
 282     scilab_fill_dotmul(ScalarUInt8, Empty, M_E, UInt8, Double, Double);
 283
 284     //Scalar .* Scalar
 285     scilab_fill_dotmul(ScalarUInt8, ScalarDouble, S_S, UInt8, Double, UInt8);
 286     scilab_fill_dotmul(ScalarUInt8, ScalarInt8, S_S, UInt8, Int8, UInt8);
 287     scilab_fill_dotmul(ScalarUInt8, ScalarUInt8, S_S, UInt8, UInt8, UInt8);
 288     scilab_fill_dotmul(ScalarUInt8, ScalarInt16, S_S, UInt8, Int16, UInt16);
 289     scilab_fill_dotmul(ScalarUInt8, ScalarUInt16, S_S, UInt8, UInt16, UInt16);
 290     scilab_fill_dotmul(ScalarUInt8, ScalarInt32, S_S, UInt8, Int32, UInt32);
 291     scilab_fill_dotmul(ScalarUInt8, ScalarUInt32, S_S, UInt8, UInt32, UInt32);
 292     scilab_fill_dotmul(ScalarUInt8, ScalarInt64, S_S, UInt8, Int64, UInt64);
 293     scilab_fill_dotmul(ScalarUInt8, ScalarUInt64, S_S, UInt8, UInt64, UInt64);
 294     scilab_fill_dotmul(ScalarUInt8, ScalarBool, S_S, UInt8, Bool, UInt8);
 295
 296     //Int16
 297     //Matrix .* Matrix
 298     scilab_fill_dotmul(Int16, Double, M_M, Int16, Double, Int16);
 299     scilab_fill_dotmul(Int16, Int8, M_M, Int16, Int8, Int16);
 300     scilab_fill_dotmul(Int16, UInt8, M_M, Int16, UInt8, UInt16);
 301     scilab_fill_dotmul(Int16, Int16, M_M, Int16, Int16, Int16);
 302     scilab_fill_dotmul(Int16, UInt16, M_M, Int16, UInt16, UInt16);
 303     scilab_fill_dotmul(Int16, Int32, M_M, Int16, Int32, Int32);
 304     scilab_fill_dotmul(Int16, UInt32, M_M, Int16, UInt32, UInt32);
 305     scilab_fill_dotmul(Int16, Int64, M_M, Int16, Int64, Int64);
 306     scilab_fill_dotmul(Int16, UInt64, M_M, Int16, UInt64, UInt64);
 307     scilab_fill_dotmul(Int16, Bool, M_M, Int16, Bool, Int16);
 308     scilab_fill_dotmul(Int16, Empty, M_E, Int16, Double, Double);
 309
 310     //Matrix .* Scalar
 311     scilab_fill_dotmul(Int16, ScalarDouble, M_S, Int16, Double, Int16);
 312     scilab_fill_dotmul(Int16, ScalarInt8, M_S, Int16, Int8, Int16);
 313     scilab_fill_dotmul(Int16, ScalarUInt8, M_S, Int16, UInt8, UInt16);
 314     scilab_fill_dotmul(Int16, ScalarInt16, M_S, Int16, Int16, Int16);
 315     scilab_fill_dotmul(Int16, ScalarUInt16, M_S, Int16, UInt16, UInt16);
 316     scilab_fill_dotmul(Int16, ScalarInt32, M_S, Int16, Int32, Int32);
 317     scilab_fill_dotmul(Int16, ScalarUInt32, M_S, Int16, UInt32, UInt32);
 318     scilab_fill_dotmul(Int16, ScalarInt64, M_S, Int16, Int64, Int64);
 319     scilab_fill_dotmul(Int16, ScalarUInt64, M_S, Int16, UInt64, UInt64);
 320     scilab_fill_dotmul(Int16, ScalarBool, M_E, Int16, Bool, Int16);
 321
 322     //Scalar .* Matrix
 323     scilab_fill_dotmul(ScalarInt16, Double, S_M, Int16, Double, Int16);
 324     scilab_fill_dotmul(ScalarInt16, Int8, S_M, Int16, Int8, Int16);
 325     scilab_fill_dotmul(ScalarInt16, UInt8, S_M, Int16, UInt8, UInt16);
 326     scilab_fill_dotmul(ScalarInt16, Int16, S_M, Int16, Int16, Int16);
 327     scilab_fill_dotmul(ScalarInt16, UInt16, S_M, Int16, UInt16, UInt16);
 328     scilab_fill_dotmul(ScalarInt16, Int32, S_M, Int16, Int32, Int32);
 329     scilab_fill_dotmul(ScalarInt16, UInt32, S_M, Int16, UInt32, UInt32);
 330     scilab_fill_dotmul(ScalarInt16, Int64, S_M, Int16, Int64, Int64);
 331     scilab_fill_dotmul(ScalarInt16, UInt64, S_M, Int16, UInt64, UInt64);
 332     scilab_fill_dotmul(ScalarInt16, Bool, S_M, Int16, Bool, Int16);
 333     scilab_fill_dotmul(ScalarInt16, Empty, M_E, Int16, Double, Double);
 334
 335     //Scalar .* Scalar
 336     scilab_fill_dotmul(ScalarInt16, ScalarDouble, S_S, Int16, Double, Int16);
 337     scilab_fill_dotmul(ScalarInt16, ScalarInt8, S_S, Int16, Int8, Int16);
 338     scilab_fill_dotmul(ScalarInt16, ScalarUInt8, S_S, Int16, UInt8, UInt16);
 339     scilab_fill_dotmul(ScalarInt16, ScalarInt16, S_S, Int16, Int16, Int16);
 340     scilab_fill_dotmul(ScalarInt16, ScalarUInt16, S_S, Int16, UInt16, UInt16);
 341     scilab_fill_dotmul(ScalarInt16, ScalarInt32, S_S, Int16, Int32, Int32);
 342     scilab_fill_dotmul(ScalarInt16, ScalarUInt32, S_S, Int16, UInt32, UInt32);
 343     scilab_fill_dotmul(ScalarInt16, ScalarInt64, S_S, Int16, Int64, Int64);
 344     scilab_fill_dotmul(ScalarInt16, ScalarUInt64, S_S, Int16, UInt64, UInt64);
 345     scilab_fill_dotmul(ScalarInt16, ScalarBool, S_S, Int16, Bool, Int16);
 346
 347     //UInt16
 348     //Matrix .* Matrix
 349     scilab_fill_dotmul(UInt16, Double, M_M, UInt16, Double, UInt16);
 350     scilab_fill_dotmul(UInt16, Int8, M_M, UInt16, Int8, UInt16);
 351     scilab_fill_dotmul(UInt16, UInt8, M_M, UInt16, UInt8, UInt16);
 352     scilab_fill_dotmul(UInt16, Int16, M_M, UInt16, Int16, UInt16);
 353     scilab_fill_dotmul(UInt16, UInt16, M_M, UInt16, UInt16, UInt16);
 354     scilab_fill_dotmul(UInt16, Int32, M_M, UInt16, Int32, UInt32);
 355     scilab_fill_dotmul(UInt16, UInt32, M_M, UInt16, UInt32, UInt32);
 356     scilab_fill_dotmul(UInt16, Int64, M_M, UInt16, Int64, UInt64);
 357     scilab_fill_dotmul(UInt16, UInt64, M_M, UInt16, UInt64, UInt64);
 358     scilab_fill_dotmul(UInt16, Bool, M_M, UInt16, Bool, UInt16);
 359     scilab_fill_dotmul(UInt16, Empty, M_E, UInt16, Double, Double);
 360
 361     //Matrix .* Scalar
 362     scilab_fill_dotmul(UInt16, ScalarDouble, M_S, UInt16, Double, UInt16);
 363     scilab_fill_dotmul(UInt16, ScalarInt8, M_S, UInt16, Int8, UInt16);
 364     scilab_fill_dotmul(UInt16, ScalarUInt8, M_S, UInt16, UInt8, UInt16);
 365     scilab_fill_dotmul(UInt16, ScalarInt16, M_S, UInt16, Int16, UInt16);
 366     scilab_fill_dotmul(UInt16, ScalarUInt16, M_S, UInt16, UInt16, UInt16);
 367     scilab_fill_dotmul(UInt16, ScalarInt32, M_S, UInt16, Int32, UInt32);
 368     scilab_fill_dotmul(UInt16, ScalarUInt32, M_S, UInt16, UInt32, UInt32);
 369     scilab_fill_dotmul(UInt16, ScalarInt64, M_S, UInt16, Int64, UInt64);
 370     scilab_fill_dotmul(UInt16, ScalarUInt64, M_S, UInt16, UInt64, UInt64);
 371     scilab_fill_dotmul(UInt16, ScalarBool, M_S, UInt16, Bool, UInt16);
 372
 373     //Scalar .* Matrix
 374     scilab_fill_dotmul(ScalarUInt16, Double, S_M, UInt16, Double, UInt16);
 375     scilab_fill_dotmul(ScalarUInt16, Int8, S_M, UInt16, Int8, UInt16);
 376     scilab_fill_dotmul(ScalarUInt16, UInt8, S_M, UInt16, UInt8, UInt16);
 377     scilab_fill_dotmul(ScalarUInt16, Int16, S_M, UInt16, Int16, UInt16);
 378     scilab_fill_dotmul(ScalarUInt16, UInt16, S_M, UInt16, UInt16, UInt16);
 379     scilab_fill_dotmul(ScalarUInt16, Int32, S_M, UInt16, Int32, UInt32);
 380     scilab_fill_dotmul(ScalarUInt16, UInt32, S_M, UInt16, UInt32, UInt32);
 381     scilab_fill_dotmul(ScalarUInt16, Int64, S_M, UInt16, Int64, UInt64);
 382     scilab_fill_dotmul(ScalarUInt16, UInt64, S_M, UInt16, UInt64, UInt64);
 383     scilab_fill_dotmul(ScalarUInt16, Bool, S_M, UInt16, Bool, UInt16);
 384     scilab_fill_dotmul(ScalarUInt16, Empty, S_M, UInt16, Double, UInt16);
 385
 386     //Scalar .* Scalar
 387     scilab_fill_dotmul(ScalarUInt16, ScalarDouble, S_S, UInt16, Double, UInt16);
 388     scilab_fill_dotmul(ScalarUInt16, ScalarInt8, S_S, UInt16, Int8, UInt16);
 389     scilab_fill_dotmul(ScalarUInt16, ScalarUInt8, S_S, UInt16, UInt8, UInt16);
 390     scilab_fill_dotmul(ScalarUInt16, ScalarInt16, S_S, UInt16, Int16, UInt16);
 391     scilab_fill_dotmul(ScalarUInt16, ScalarUInt16, S_S, UInt16, UInt16, UInt16);
 392     scilab_fill_dotmul(ScalarUInt16, ScalarInt32, S_S, UInt16, Int32, UInt32);
 393     scilab_fill_dotmul(ScalarUInt16, ScalarUInt32, S_S, UInt16, UInt32, UInt32);
 394     scilab_fill_dotmul(ScalarUInt16, ScalarInt64, S_S, UInt16, Int64, UInt64);
 395     scilab_fill_dotmul(ScalarUInt16, ScalarUInt64, S_S, UInt16, UInt64, UInt64);
 396     scilab_fill_dotmul(ScalarUInt16, ScalarBool, S_S, UInt16, Bool, UInt16);
 397
 398     //Int32
 399     //Matrix .* Matrix
 400     scilab_fill_dotmul(Int32, Double, M_M, Int32, Double, Int32);
 401     scilab_fill_dotmul(Int32, Int8, M_M, Int32, Int8, Int32);
 402     scilab_fill_dotmul(Int32, UInt8, M_M, Int32, UInt8, UInt32);
 403     scilab_fill_dotmul(Int32, Int16, M_M, Int32, Int16, Int32);
 404     scilab_fill_dotmul(Int32, UInt16, M_M, Int32, UInt16, UInt32);
 405     scilab_fill_dotmul(Int32, Int32, M_M, Int32, Int32, Int32);
 406     scilab_fill_dotmul(Int32, UInt32, M_M, Int32, UInt32, UInt32);
 407     scilab_fill_dotmul(Int32, Int64, M_M, Int32, Int64, Int64);
 408     scilab_fill_dotmul(Int32, UInt64, M_M, Int32, UInt64, UInt64);
 409     scilab_fill_dotmul(Int32, Bool, M_M, Int32, Bool, Int32);
 410     scilab_fill_dotmul(Int32, Empty, M_E, Int32, Double, Double);
 411
 412     //Matrix .* Scalar
 413     scilab_fill_dotmul(Int32, ScalarDouble, M_S, Int32, Double, Int32);
 414     scilab_fill_dotmul(Int32, ScalarInt8, M_S, Int32, Int8, Int32);
 415     scilab_fill_dotmul(Int32, ScalarUInt8, M_S, Int32, UInt8, UInt32);
 416     scilab_fill_dotmul(Int32, ScalarInt16, M_S, Int32, Int16, Int32);
 417     scilab_fill_dotmul(Int32, ScalarUInt16, M_S, Int32, UInt16, UInt32);
 418     scilab_fill_dotmul(Int32, ScalarInt32, M_S, Int32, Int32, Int32);
 419     scilab_fill_dotmul(Int32, ScalarUInt32, M_S, Int32, UInt32, UInt32);
 420     scilab_fill_dotmul(Int32, ScalarInt64, M_S, Int32, Int64, Int64);
 421     scilab_fill_dotmul(Int32, ScalarUInt64, M_S, Int32, UInt64, UInt64);
 422     scilab_fill_dotmul(Int32, ScalarBool, M_S, Int32, Bool, Int32);
 423
 424     //Scalar .* Matrix
 425     scilab_fill_dotmul(ScalarInt32, Double, S_M, Int32, Double, Int32);
 426     scilab_fill_dotmul(ScalarInt32, Int8, S_M, Int32, Int8, Int32);
 427     scilab_fill_dotmul(ScalarInt32, UInt8, S_M, Int32, UInt8, UInt32);
 428     scilab_fill_dotmul(ScalarInt32, Int16, S_M, Int32, Int16, Int32);
 429     scilab_fill_dotmul(ScalarInt32, UInt16, S_M, Int32, UInt16, UInt32);
 430     scilab_fill_dotmul(ScalarInt32, Int32, S_M, Int32, Int32, Int32);
 431     scilab_fill_dotmul(ScalarInt32, UInt32, S_M, Int32, UInt32, UInt32);
 432     scilab_fill_dotmul(ScalarInt32, Int64, S_M, Int32, Int64, Int64);
 433     scilab_fill_dotmul(ScalarInt32, UInt64, S_M, Int32, UInt64, UInt64);
 434     scilab_fill_dotmul(ScalarInt32, Bool, S_M, Int32, Bool, Int32);
 435     scilab_fill_dotmul(ScalarInt32, Empty, M_E, Int32, Double, Double);
 436
 437     //Scalar .* Scalar
 438     scilab_fill_dotmul(ScalarInt32, ScalarDouble, S_S, Int32, Double, Int32);
 439     scilab_fill_dotmul(ScalarInt32, ScalarInt8, S_S, Int32, Int8, Int32);
 440     scilab_fill_dotmul(ScalarInt32, ScalarUInt8, S_S, Int32, UInt8, UInt32);
 441     scilab_fill_dotmul(ScalarInt32, ScalarInt16, S_S, Int32, Int16, Int32);
 442     scilab_fill_dotmul(ScalarInt32, ScalarUInt16, S_S, Int32, UInt16, UInt32);
 443     scilab_fill_dotmul(ScalarInt32, ScalarInt32, S_S, Int32, Int32, Int32);
 444     scilab_fill_dotmul(ScalarInt32, ScalarUInt32, S_S, Int32, UInt32, UInt32);
 445     scilab_fill_dotmul(ScalarInt32, ScalarInt64, S_S, Int32, Int64, Int64);
 446     scilab_fill_dotmul(ScalarInt32, ScalarUInt64, S_S, Int32, UInt64, UInt64);
 447     scilab_fill_dotmul(ScalarInt32, ScalarBool, S_S, Int32, Bool, Int32);
 448
 449     //UInt32
 450     //Matrix .* Matrix
 451     scilab_fill_dotmul(UInt32, Double, M_M, UInt32, Double, UInt32);
 452     scilab_fill_dotmul(UInt32, Int8, M_M, UInt32, Int8, UInt32);
 453     scilab_fill_dotmul(UInt32, UInt8, M_M, UInt32, UInt8, UInt32);
 454     scilab_fill_dotmul(UInt32, Int16, M_M, UInt32, Int16, UInt32);
 455     scilab_fill_dotmul(UInt32, UInt16, M_M, UInt32, UInt16, UInt32);
 456     scilab_fill_dotmul(UInt32, Int32, M_M, UInt32, Int32, UInt32);
 457     scilab_fill_dotmul(UInt32, UInt32, M_M, UInt32, UInt32, UInt32);
 458     scilab_fill_dotmul(UInt32, Int64, M_M, UInt32, Int64, UInt64);
 459     scilab_fill_dotmul(UInt32, UInt64, M_M, UInt32, UInt64, UInt64);
 460     scilab_fill_dotmul(UInt32, Bool, M_M, UInt32, Bool, UInt32);
 461     scilab_fill_dotmul(UInt32, Empty, M_E, UInt32, Double, Double);
 462
 463     //Matrix .* Scalar
 464     scilab_fill_dotmul(UInt32, ScalarDouble, M_S, UInt32, Double, UInt32);
 465     scilab_fill_dotmul(UInt32, ScalarInt8, M_S, UInt32, Int8, UInt32);
 466     scilab_fill_dotmul(UInt32, ScalarUInt8, M_S, UInt32, UInt8, UInt32);
 467     scilab_fill_dotmul(UInt32, ScalarInt16, M_S, UInt32, Int16, UInt32);
 468     scilab_fill_dotmul(UInt32, ScalarUInt16, M_S, UInt32, UInt16, UInt32);
 469     scilab_fill_dotmul(UInt32, ScalarInt32, M_S, UInt32, Int32, UInt32);
 470     scilab_fill_dotmul(UInt32, ScalarUInt32, M_S, UInt32, UInt32, UInt32);
 471     scilab_fill_dotmul(UInt32, ScalarInt64, M_S, UInt32, Int64, UInt64);
 472     scilab_fill_dotmul(UInt32, ScalarUInt64, M_S, UInt32, UInt64, UInt64);
 473     scilab_fill_dotmul(UInt32, ScalarBool, M_S, UInt32, Bool, UInt32);
 474
 475     //Scalar .* Matrix
 476     scilab_fill_dotmul(ScalarUInt32, Double, S_M, UInt32, Double, UInt32);
 477     scilab_fill_dotmul(ScalarUInt32, Int8, S_M, UInt32, Int8, UInt32);
 478     scilab_fill_dotmul(ScalarUInt32, UInt8, S_M, UInt32, UInt8, UInt32);
 479     scilab_fill_dotmul(ScalarUInt32, Int16, S_M, UInt32, Int16, UInt32);
 480     scilab_fill_dotmul(ScalarUInt32, UInt16, S_M, UInt32, UInt16, UInt32);
 481     scilab_fill_dotmul(ScalarUInt32, Int32, S_M, UInt32, Int32, UInt32);
 482     scilab_fill_dotmul(ScalarUInt32, UInt32, S_M, UInt32, UInt32, UInt32);
 483     scilab_fill_dotmul(ScalarUInt32, Int64, S_M, UInt32, Int64, UInt64);
 484     scilab_fill_dotmul(ScalarUInt32, UInt64, S_M, UInt32, UInt64, UInt64);
 485     scilab_fill_dotmul(ScalarUInt32, Bool, S_M, UInt32, Bool, UInt32);
 486     scilab_fill_dotmul(ScalarUInt32, Empty, S_M, UInt32, Double, UInt32);
 487
 488     //Scalar .* Scalar
 489     scilab_fill_dotmul(ScalarUInt32, ScalarDouble, S_S, UInt32, Double, UInt32);
 490     scilab_fill_dotmul(ScalarUInt32, ScalarInt8, S_S, UInt32, Int8, UInt32);
 491     scilab_fill_dotmul(ScalarUInt32, ScalarUInt8, S_S, UInt32, UInt8, UInt32);
 492     scilab_fill_dotmul(ScalarUInt32, ScalarInt16, S_S, UInt32, Int16, UInt32);
 493     scilab_fill_dotmul(ScalarUInt32, ScalarUInt16, S_S, UInt32, UInt16, UInt32);
 494     scilab_fill_dotmul(ScalarUInt32, ScalarInt32, S_S, UInt32, Int32, UInt32);
 495     scilab_fill_dotmul(ScalarUInt32, ScalarUInt32, S_S, UInt32, UInt32, UInt32);
 496     scilab_fill_dotmul(ScalarUInt32, ScalarInt64, S_S, UInt32, Int64, UInt64);
 497     scilab_fill_dotmul(ScalarUInt32, ScalarUInt64, S_S, UInt32, UInt64, UInt64);
 498     scilab_fill_dotmul(ScalarUInt32, ScalarBool, S_S, UInt32, Bool, UInt32);
 499
 500     //Int64
 501     //Matrix .* Matrix
 502     scilab_fill_dotmul(Int64, Double, M_M, Int64, Double, Int64);
 503     scilab_fill_dotmul(Int64, Int8, M_M, Int64, Int8, Int64);
 504     scilab_fill_dotmul(Int64, UInt8, M_M, Int64, UInt8, UInt64);
 505     scilab_fill_dotmul(Int64, Int16, M_M, Int64, Int16, Int64);
 506     scilab_fill_dotmul(Int64, UInt16, M_M, Int64, UInt16, UInt64);
 507     scilab_fill_dotmul(Int64, Int32, M_M, Int64, Int32, Int64);
 508     scilab_fill_dotmul(Int64, UInt32, M_M, Int64, UInt32, UInt64);
 509     scilab_fill_dotmul(Int64, Int64, M_M, Int64, Int64, Int64);
 510     scilab_fill_dotmul(Int64, UInt64, M_M, Int64, UInt64, UInt64);
 511     scilab_fill_dotmul(Int64, Bool, M_M, Int64, Bool, Int64);
 512     scilab_fill_dotmul(Int64, Empty, M_E, Int64, Double, Double);
 513
 514     //Matrix .* Scalar
 515     scilab_fill_dotmul(Int64, ScalarDouble, M_S, Int64, Double, Int64);
 516     scilab_fill_dotmul(Int64, ScalarInt8, M_S, Int64, Int8, Int64);
 517     scilab_fill_dotmul(Int64, ScalarUInt8, M_S, Int64, UInt8, UInt64);
 518     scilab_fill_dotmul(Int64, ScalarInt16, M_S, Int64, Int16, Int64);
 519     scilab_fill_dotmul(Int64, ScalarUInt16, M_S, Int64, UInt16, UInt64);
 520     scilab_fill_dotmul(Int64, ScalarInt32, M_S, Int64, Int32, Int64);
 521     scilab_fill_dotmul(Int64, ScalarUInt32, M_S, Int64, UInt32, UInt64);
 522     scilab_fill_dotmul(Int64, ScalarInt64, M_S, Int64, Int64, Int64);
 523     scilab_fill_dotmul(Int64, ScalarUInt64, M_S, Int64, UInt64, UInt64);
 524     scilab_fill_dotmul(Int64, ScalarBool, M_S, Int64, Bool, Int64);
 525
 526     //Scalar .* Matrix
 527     scilab_fill_dotmul(ScalarInt64, Double, S_M, Int64, Double, Int64);
 528     scilab_fill_dotmul(ScalarInt64, Int8, S_M, Int64, Int8, Int64);
 529     scilab_fill_dotmul(ScalarInt64, UInt8, S_M, Int64, UInt8, UInt64);
 530     scilab_fill_dotmul(ScalarInt64, Int16, S_M, Int64, Int16, Int64);
 531     scilab_fill_dotmul(ScalarInt64, UInt16, S_M, Int64, UInt16, UInt64);
 532     scilab_fill_dotmul(ScalarInt64, Int32, S_M, Int64, Int32, Int64);
 533     scilab_fill_dotmul(ScalarInt64, UInt32, S_M, Int64, UInt32, UInt64);
 534     scilab_fill_dotmul(ScalarInt64, Int64, S_M, Int64, Int64, Int64);
 535     scilab_fill_dotmul(ScalarInt64, UInt64, S_M, Int64, UInt64, UInt64);
 536     scilab_fill_dotmul(ScalarInt64, Bool, S_M, Int64, Bool, Int64);
 537     scilab_fill_dotmul(ScalarInt64, Empty, M_E, Int64, Double, Double);
 538
 539     //Scalar .* Scalar
 540     scilab_fill_dotmul(ScalarInt64, ScalarDouble, S_S, Int64, Double, Int64);
 541     scilab_fill_dotmul(ScalarInt64, ScalarInt8, S_S, Int64, Int8, Int64);
 542     scilab_fill_dotmul(ScalarInt64, ScalarUInt8, S_S, Int64, UInt8, UInt64);
 543     scilab_fill_dotmul(ScalarInt64, ScalarInt16, S_S, Int64, Int16, Int64);
 544     scilab_fill_dotmul(ScalarInt64, ScalarUInt16, S_S, Int64, UInt16, UInt64);
 545     scilab_fill_dotmul(ScalarInt64, ScalarInt32, S_S, Int64, Int32, Int64);
 546     scilab_fill_dotmul(ScalarInt64, ScalarUInt32, S_S, Int64, UInt32, UInt64);
 547     scilab_fill_dotmul(ScalarInt64, ScalarInt64, S_S, Int64, Int64, Int64);
 548     scilab_fill_dotmul(ScalarInt64, ScalarUInt64, S_S, Int64, UInt64, UInt64);
 549     scilab_fill_dotmul(ScalarInt64, ScalarBool, S_S, Int64, Bool, Int64);
 550
 551     //UInt64
 552     //Matrix .* Matrix
 553     scilab_fill_dotmul(UInt64, Double, M_M, UInt64, Double, UInt64);
 554     scilab_fill_dotmul(UInt64, Int8, M_M, UInt64, Int8, UInt64);
 555     scilab_fill_dotmul(UInt64, UInt8, M_M, UInt64, UInt8, UInt64);
 556     scilab_fill_dotmul(UInt64, Int16, M_M, UInt64, Int16, UInt64);
 557     scilab_fill_dotmul(UInt64, UInt16, M_M, UInt64, UInt16, UInt64);
 558     scilab_fill_dotmul(UInt64, Int32, M_M, UInt64, Int32, UInt64);
 559     scilab_fill_dotmul(UInt64, UInt32, M_M, UInt64, UInt32, UInt64);
 560     scilab_fill_dotmul(UInt64, Int64, M_M, UInt64, Int64, UInt64);
 561     scilab_fill_dotmul(UInt64, UInt64, M_M, UInt64, UInt64, UInt64);
 562     scilab_fill_dotmul(UInt64, Bool, M_M, UInt64, Bool, UInt64);
 563     scilab_fill_dotmul(UInt64, Empty, M_E, UInt64, Double, Double);
 564
 565     //Matrix .* Scalar
 566     scilab_fill_dotmul(UInt64, ScalarDouble, M_S, UInt64, Double, UInt64);
 567     scilab_fill_dotmul(UInt64, ScalarInt8, M_S, UInt64, Int8, UInt64);
 568     scilab_fill_dotmul(UInt64, ScalarUInt8, M_S, UInt64, UInt8, UInt64);
 569     scilab_fill_dotmul(UInt64, ScalarInt16, M_S, UInt64, Int16, UInt64);
 570     scilab_fill_dotmul(UInt64, ScalarUInt16, M_S, UInt64, UInt16, UInt64);
 571     scilab_fill_dotmul(UInt64, ScalarInt32, M_S, UInt64, Int32, UInt64);
 572     scilab_fill_dotmul(UInt64, ScalarUInt32, M_S, UInt64, UInt32, UInt64);
 573     scilab_fill_dotmul(UInt64, ScalarInt64, M_S, UInt64, Int64, UInt64);
 574     scilab_fill_dotmul(UInt64, ScalarUInt64, M_S, UInt64, UInt64, UInt64);
 575     scilab_fill_dotmul(UInt64, ScalarBool, M_S, UInt64, Bool, UInt64);
 576
 577     //Scalar .* Matrix
 578     scilab_fill_dotmul(ScalarUInt64, Double, S_M, UInt64, Double, UInt64);
 579     scilab_fill_dotmul(ScalarUInt64, Int8, S_M, UInt64, Int8, UInt64);
 580     scilab_fill_dotmul(ScalarUInt64, UInt8, S_M, UInt64, UInt8, UInt64);
 581     scilab_fill_dotmul(ScalarUInt64, Int16, S_M, UInt64, Int16, UInt64);
 582     scilab_fill_dotmul(ScalarUInt64, UInt16, S_M, UInt64, UInt16, UInt64);
 583     scilab_fill_dotmul(ScalarUInt64, Int32, S_M, UInt64, Int32, UInt64);
 584     scilab_fill_dotmul(ScalarUInt64, UInt32, S_M, UInt64, UInt32, UInt64);
 585     scilab_fill_dotmul(ScalarUInt64, Int64, S_M, UInt64, Int64, UInt64);
 586     scilab_fill_dotmul(ScalarUInt64, UInt64, S_M, UInt64, UInt64, UInt64);
 587     scilab_fill_dotmul(ScalarUInt64, Bool, S_M, UInt64, Bool, UInt64);
 588     scilab_fill_dotmul(ScalarUInt64, Empty, S_M, UInt64, Double, UInt64);
 589
 590     //Scalar .* Scalar
 591     scilab_fill_dotmul(ScalarUInt64, ScalarDouble, S_S, UInt64, Double, UInt64);
 592     scilab_fill_dotmul(ScalarUInt64, ScalarInt8, S_S, UInt64, Int8, UInt64);
 593     scilab_fill_dotmul(ScalarUInt64, ScalarUInt8, S_S, UInt64, UInt8, UInt64);
 594     scilab_fill_dotmul(ScalarUInt64, ScalarInt16, S_S, UInt64, Int16, UInt64);
 595     scilab_fill_dotmul(ScalarUInt64, ScalarUInt16, S_S, UInt64, UInt16, UInt64);
 596     scilab_fill_dotmul(ScalarUInt64, ScalarInt32, S_S, UInt64, Int32, UInt64);
 597     scilab_fill_dotmul(ScalarUInt64, ScalarUInt32, S_S, UInt64, UInt32, UInt64);
 598     scilab_fill_dotmul(ScalarUInt64, ScalarInt64, S_S, UInt64, Int64, UInt64);
 599     scilab_fill_dotmul(ScalarUInt64, ScalarUInt64, S_S, UInt64, UInt64, UInt64);
 600     scilab_fill_dotmul(ScalarUInt64, ScalarBool, S_S, UInt64, Bool, UInt64);
 601
 602     //Bool
 603     //Matrix + Matrix
 604     scilab_fill_dotmul(Bool, Double, M_M, Bool, Double, Double);
 605     scilab_fill_dotmul(Bool, Int8, M_M, Bool, Int8, Int8);
 606     scilab_fill_dotmul(Bool, UInt8, M_M, Bool, UInt8, UInt8);
 607     scilab_fill_dotmul(Bool, Int16, M_M, Bool, Int16, Int16);
 608     scilab_fill_dotmul(Bool, UInt16, M_M, Bool, UInt16, UInt16);
 609     scilab_fill_dotmul(Bool, Int32, M_M, Bool, Int32, Int32);
 610     scilab_fill_dotmul(Bool, UInt32, M_M, Bool, UInt32, UInt32);
 611     scilab_fill_dotmul(Bool, Int64, M_M, Bool, Int64, Int64);
 612     scilab_fill_dotmul(Bool, UInt64, M_M, Bool, UInt64, UInt64);
 613     scilab_fill_dotmul(Bool, Bool, M_M, Bool, Bool, Double);
 614     scilab_fill_dotmul(Bool, Empty, M_E, Bool, Double, Double);
 615
 616     //Matrix + Scalar
 617     scilab_fill_dotmul(Bool, ScalarDouble, M_S, Bool, Double, Double);
 618     scilab_fill_dotmul(Bool, ScalarInt8, M_S, Bool, Int8, Int8);
 619     scilab_fill_dotmul(Bool, ScalarUInt8, M_S, Bool, UInt8, UInt8);
 620     scilab_fill_dotmul(Bool, ScalarInt16, M_S, Bool, Int16, Int16);
 621     scilab_fill_dotmul(Bool, ScalarUInt16, M_S, Bool, UInt16, UInt16);
 622     scilab_fill_dotmul(Bool, ScalarInt32, M_S, Bool, Int32, Int32);
 623     scilab_fill_dotmul(Bool, ScalarUInt32, M_S, Bool, UInt32, UInt32);
 624     scilab_fill_dotmul(Bool, ScalarInt64, M_S, Bool, Int64, Int64);
 625     scilab_fill_dotmul(Bool, ScalarUInt64, M_S, Bool, UInt64, UInt64);
 626     scilab_fill_dotmul(Bool, ScalarBool, M_S, Bool, Bool, Double);
 627
 628     //Scalar + Matrix
 629     scilab_fill_dotmul(ScalarBool, Double, S_M, Bool, Double, Double);
 630     scilab_fill_dotmul(ScalarBool, Int8, S_M, Bool, Int8, Int8);
 631     scilab_fill_dotmul(ScalarBool, UInt8, S_M, Bool, UInt8, UInt8);
 632     scilab_fill_dotmul(ScalarBool, Int16, S_M, Bool, Int16, Int16);
 633     scilab_fill_dotmul(ScalarBool, UInt16, S_M, Bool, UInt16, UInt16);
 634     scilab_fill_dotmul(ScalarBool, Int32, S_M, Bool, Int32, Int32);
 635     scilab_fill_dotmul(ScalarBool, UInt32, S_M, Bool, UInt32, UInt32);
 636     scilab_fill_dotmul(ScalarBool, Int64, S_M, Bool, Int64, Int64);
 637     scilab_fill_dotmul(ScalarBool, UInt64, S_M, Bool, UInt64, UInt64);
 638     scilab_fill_dotmul(ScalarBool, Bool, S_M, Bool, Bool, Double);
 639     scilab_fill_dotmul(ScalarBool, Empty, M_E, Bool, Double, Double);
 640
 641     //Scalar + Scalar
 642     scilab_fill_dotmul(ScalarBool, ScalarDouble, S_S, Bool, Double, Double);
 643     scilab_fill_dotmul(ScalarBool, ScalarInt8, S_S, Bool, Int8, Int8);
 644     scilab_fill_dotmul(ScalarBool, ScalarUInt8, S_S, Bool, UInt8, UInt8);
 645     scilab_fill_dotmul(ScalarBool, ScalarInt16, S_S, Bool, Int16, Int16);
 646     scilab_fill_dotmul(ScalarBool, ScalarUInt16, S_S, Bool, UInt16, UInt16);
 647     scilab_fill_dotmul(ScalarBool, ScalarInt32, S_S, Bool, Int32, Int32);
 648     scilab_fill_dotmul(ScalarBool, ScalarUInt32, S_S, Bool, UInt32, UInt32);
 649     scilab_fill_dotmul(ScalarBool, ScalarInt64, S_S, Bool, Int64, Int64);
 650     scilab_fill_dotmul(ScalarBool, ScalarUInt64, S_S, Bool, UInt64, UInt64);
 651     scilab_fill_dotmul(ScalarBool, ScalarBool, S_S, Bool, Bool, Double);
 652
 653     //Identity
 654     scilab_fill_dotmul(Identity, Double, I_M, Double, Double, Double);
 655     scilab_fill_dotmul(Identity, DoubleComplex, I_MC, Double, Double, Double);
 656     scilab_fill_dotmul(Identity, ScalarDouble, I_S, Double, Double, Double);
 657     scilab_fill_dotmul(Identity, ScalarDoubleComplex, I_SC, Double, Double, Double);
 658     scilab_fill_dotmul(Identity, Identity, I_I, Double, Double, Double);
 659     scilab_fill_dotmul(Identity, IdentityComplex, I_IC, Double, Double, Double);
 660     scilab_fill_dotmul(Identity, Empty, M_E, Double, Double, Double);
 661
 662     scilab_fill_dotmul(Identity, Polynom, M_M, Double, Polynom, Polynom);
 663     scilab_fill_dotmul(Identity, PolynomComplex, M_M, Double, Polynom, Polynom);
 664     scilab_fill_dotmul(Identity, ScalarPolynom, M_M, Double, Polynom, Polynom);
 665     scilab_fill_dotmul(Identity, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 666     //scilab_fill_dotmul(Identity, Sparse, M_M, Double, Sparse, Sparse);
 667     //scilab_fill_dotmul(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
 668
 669     scilab_fill_dotmul(IdentityComplex, Double, IC_M, Double, Double, Double);
 670     scilab_fill_dotmul(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
 671     scilab_fill_dotmul(IdentityComplex, ScalarDouble, IC_S, Double, Double, Double);
 672     scilab_fill_dotmul(IdentityComplex, ScalarDoubleComplex, IC_SC, Double, Double, Double);
 673     scilab_fill_dotmul(IdentityComplex, Identity, IC_I, Double, Double, Double);
 674     scilab_fill_dotmul(IdentityComplex, IdentityComplex, IC_IC, Double, Double, Double);
 675     scilab_fill_dotmul(IdentityComplex, Empty, M_E, Double, Double, Double);
 676
 677     scilab_fill_dotmul(IdentityComplex, Polynom, M_M, Double, Polynom, Polynom);
 678     scilab_fill_dotmul(IdentityComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
 679     scilab_fill_dotmul(IdentityComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
 680     scilab_fill_dotmul(IdentityComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
 681     //scilab_fill_dotmul(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
 682     //scilab_fill_dotmul(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
 683
 684     //Polynom
 685
 686     //poly + poly
 687     scilab_fill_dotmul(Polynom, Polynom, M_M, Polynom, Polynom, Polynom);
 688     scilab_fill_dotmul(Polynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 689     scilab_fill_dotmul(PolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
 690     scilab_fill_dotmul(PolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 691
 692     //poly + scalar poly
 693     scilab_fill_dotmul(Polynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 694     scilab_fill_dotmul(Polynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 695     scilab_fill_dotmul(PolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 696     scilab_fill_dotmul(PolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 697
 698     //poly + double
 699     scilab_fill_dotmul(Polynom, Double, M_M, Polynom, Double, Polynom);
 700     scilab_fill_dotmul(Polynom, DoubleComplex, M_M, Polynom, Double, Polynom);
 701     scilab_fill_dotmul(PolynomComplex, Double, M_M, Polynom, Double, Polynom);
 702     scilab_fill_dotmul(PolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
 703
 704     //poly + scalar double
 705     scilab_fill_dotmul(Polynom, ScalarDouble, M_M, Polynom, Double, Polynom);
 706     scilab_fill_dotmul(Polynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 707     scilab_fill_dotmul(PolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
 708     scilab_fill_dotmul(PolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 709
 710     //poly + []
 711     scilab_fill_dotmul(Polynom, Empty, M_E, Polynom, Double, Double);
 712     scilab_fill_dotmul(PolynomComplex, Empty, M_E, Polynom, Double, Double);
 713
 714     //poly + eye
 715     scilab_fill_dotmul(Polynom, Identity, M_M, Polynom, Double, Polynom);
 716     scilab_fill_dotmul(Polynom, IdentityComplex, M_M, Polynom, Double, Polynom);
 717     scilab_fill_dotmul(PolynomComplex, Identity, M_M, Polynom, Double, Polynom);
 718     scilab_fill_dotmul(PolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
 719
 720     //scalar poly + poly
 721     scilab_fill_dotmul(ScalarPolynom, Polynom, M_M, Polynom, Polynom, Polynom);
 722     scilab_fill_dotmul(ScalarPolynom, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 723     scilab_fill_dotmul(ScalarPolynomComplex, Polynom, M_M, Polynom, Polynom, Polynom);
 724     scilab_fill_dotmul(ScalarPolynomComplex, PolynomComplex, M_M, Polynom, Polynom, Polynom);
 725
 726     //scalar poly + scalar poly
 727     scilab_fill_dotmul(ScalarPolynom, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 728     scilab_fill_dotmul(ScalarPolynom, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 729     scilab_fill_dotmul(ScalarPolynomComplex, ScalarPolynom, M_M, Polynom, Polynom, Polynom);
 730     scilab_fill_dotmul(ScalarPolynomComplex, ScalarPolynomComplex, M_M, Polynom, Polynom, Polynom);
 731
 732     //scalar poly + double
 733     scilab_fill_dotmul(ScalarPolynom, Double, M_M, Polynom, Double, Polynom);
 734     scilab_fill_dotmul(ScalarPolynom, DoubleComplex, M_M, Polynom, Double, Polynom);
 735     scilab_fill_dotmul(ScalarPolynomComplex, Double, M_M, Polynom, Double, Polynom);
 736     scilab_fill_dotmul(ScalarPolynomComplex, DoubleComplex, M_M, Polynom, Double, Polynom);
 737
 738     //scalar poly + scalar double
 739     scilab_fill_dotmul(ScalarPolynom, ScalarDouble, M_M, Polynom, Double, Polynom);
 740     scilab_fill_dotmul(ScalarPolynom, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 741     scilab_fill_dotmul(ScalarPolynomComplex, ScalarDouble, M_M, Polynom, Double, Polynom);
 742     scilab_fill_dotmul(ScalarPolynomComplex, ScalarDoubleComplex, M_M, Polynom, Double, Polynom);
 743
 744     //scalar poly + []
 745     scilab_fill_dotmul(ScalarPolynom, Empty, M_E, Polynom, Double, Double);
 746     scilab_fill_dotmul(ScalarPolynomComplex, Empty, M_E, Polynom, Double, Double);
 747
 748     //scalar poly + eye
 749     scilab_fill_dotmul(ScalarPolynom, Identity, M_M, Polynom, Double, Polynom);
 750     scilab_fill_dotmul(ScalarPolynom, IdentityComplex, M_M, Polynom, Double, Polynom);
 751     scilab_fill_dotmul(ScalarPolynomComplex, Identity, M_M, Polynom, Double, Polynom);
 752     scilab_fill_dotmul(ScalarPolynomComplex, IdentityComplex, M_M, Polynom, Double, Polynom);
 753
 754     //Sparse
 755     scilab_fill_dotmul(Sparse, Sparse, M_M, Sparse, Sparse, Sparse);
 756     scilab_fill_dotmul(Sparse, SparseComplex, M_M, Sparse, Sparse, Sparse);
 757     scilab_fill_dotmul(Sparse, Double, M_M, Sparse, Double, Sparse);
 758     scilab_fill_dotmul(Sparse, DoubleComplex, M_M, Sparse, Double, Sparse);
 759     scilab_fill_dotmul(Sparse, ScalarDouble, M_M, Sparse, Double, Sparse);
 760     scilab_fill_dotmul(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
 761
 762     scilab_fill_dotmul(Sparse, Empty, M_E, Sparse, Double, Double);
 763     //scilab_fill_dotmul(Sparse, Identity, M_M, Sparse, Double, Sparse);
 764     //scilab_fill_dotmul(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
 765
 766     scilab_fill_dotmul(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
 767     scilab_fill_dotmul(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
 768     scilab_fill_dotmul(SparseComplex, Double, M_M, Sparse, Double, Sparse);
 769     scilab_fill_dotmul(SparseComplex, DoubleComplex, M_M, Sparse, Double, Sparse);
 770     scilab_fill_dotmul(SparseComplex, ScalarDouble, M_M, Sparse, Double, Sparse);
 771     scilab_fill_dotmul(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
 772
 773     scilab_fill_dotmul(SparseComplex, Empty, M_E, Sparse, Double, Double);
 774     //scilab_fill_dotmul(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
 775     //scilab_fill_dotmul(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
 776
 777 #undef scilab_fill_dotmul
 778 }
 779
 780 InternalType *GenericDotTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
 781 {
 782     InternalType *pResult = NULL;
 783
 784     dotmul_function dotmul = pDotMulfunction[_pLeftOperand->getId()][_pRightOperand->getId()];
 785     if (dotmul)
 786     {
 787         pResult = dotmul(_pLeftOperand, _pRightOperand);
 788         if (pResult)
 789         {
 790             return pResult;
 791         }
 792     }
 793
 794     /*
 795     ** Default case : Return NULL will Call Overloading.
 796     */
 797     return NULL;
 798 }
 799
 800 //Matrix .* x
 801 template<class T, class U, class O>
 802 InternalType* dotmul_M_M(T *_pL, U *_pR)
 803 {
 804     //check dims
 805     int iDimsL = _pL->getDims();
 806     int iDimsR = _pR->getDims();
 807
 808     if (iDimsL != iDimsR)
 809     {
 810         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 811     }
 812
 813     int* piDimsL = _pL->getDimsArray();
 814     int* piDimsR = _pR->getDimsArray();
 815
 816     for (int i = 0 ; i < iDimsL ; ++i)
 817     {
 818         if (piDimsL[i] != piDimsR[i])
 819         {
 820             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 821         }
 822     }
 823
 824     O* pOut = new O(iDimsL, piDimsL);
 825     int iSize = pOut->getSize();
 826
 827     dotmul(_pL->get(), iSize, _pR->get(), pOut->get());
 828     return pOut;
 829 }
 830
 831 template<class T, class U, class O>
 832 InternalType* dotmul_M_MC(T *_pL, U *_pR)
 833 {
 834     //check dims
 835     int iDimsL = _pL->getDims();
 836     int iDimsR = _pR->getDims();
 837
 838     if (iDimsL != iDimsR)
 839     {
 840         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 841     }
 842
 843     int* piDimsL = _pL->getDimsArray();
 844     int* piDimsR = _pR->getDimsArray();
 845
 846     for (int i = 0 ; i < iDimsL ; ++i)
 847     {
 848         if (piDimsL[i] != piDimsR[i])
 849         {
 850             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 851         }
 852     }
 853
 854     O* pOut = new O(iDimsL, piDimsL, true);
 855     int iSize = pOut->getSize();
 856
 857     dotmul(_pL->get(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
 858     return pOut;
 859 }
 860
 861 template<class T, class U, class O>
 862 InternalType* dotmul_M_S(T *_pL, U *_pR)
 863 {
 864     O* pOut = new O(_pL->getDims(), _pL->getDimsArray());
 865     dotmul(_pL->get(), (size_t)pOut->getSize(), _pR->get(0), pOut->get());
 866     return pOut;
 867 }
 868
 869 template<class T, class U, class O>
 870 InternalType* dotmul_M_SC(T *_pL, U *_pR)
 871 {
 872     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 873     dotmul(_pL->get(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
 874     return pOut;
 875 }
 876
 877 template<class T, class U, class O>
 878 InternalType* dotmul_M_I(T * /*_pL*/, U * /*_pR*/)
 879 {
 880     return NULL;
 881 }
 882
 883 template<class T, class U, class O>
 884 InternalType* dotmul_M_IC(T * /*_pL*/, U * /*_pR*/)
 885 {
 886     return NULL;
 887 }
 888
 889 template<class T, class U, class O>
 890 InternalType* dotmul_M_E(T * /*_pL*/, U *_pR)
 891 {
 892     return _pR;
 893 }
 894
 895 //Matrix complex .* x
 896 template<class T, class U, class O>
 897 InternalType* dotmul_MC_M(T *_pL, U *_pR)
 898 {
 899     //check dims
 900     int iDimsL = _pL->getDims();
 901     int iDimsR = _pR->getDims();
 902
 903     if (iDimsL != iDimsR)
 904     {
 905         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 906     }
 907
 908     int* piDimsL = _pL->getDimsArray();
 909     int* piDimsR = _pR->getDimsArray();
 910
 911     for (int i = 0 ; i < iDimsL ; ++i)
 912     {
 913         if (piDimsL[i] != piDimsR[i])
 914         {
 915             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 916         }
 917     }
 918
 919     O* pOut = new O(iDimsL, piDimsL, true);
 920     int iSize = pOut->getSize();
 921
 922     dotmul(_pL->get(), _pL->getImg(), iSize, _pR->get(), pOut->get(), pOut->getImg());
 923     return pOut;
 924 }
 925
 926 template<class T, class U, class O>
 927 InternalType* dotmul_MC_MC(T *_pL, U *_pR)
 928 {
 929     //check dims
 930     int iDimsL = _pL->getDims();
 931     int iDimsR = _pR->getDims();
 932
 933     if (iDimsL != iDimsR)
 934     {
 935         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 936     }
 937
 938     int* piDimsL = _pL->getDimsArray();
 939     int* piDimsR = _pR->getDimsArray();
 940
 941     for (int i = 0 ; i < iDimsL ; ++i)
 942     {
 943         if (piDimsL[i] != piDimsR[i])
 944         {
 945             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
 946         }
 947     }
 948
 949     O* pOut = new O(iDimsL, piDimsL, true);
 950     int iSize = pOut->getSize();
 951
 952     dotmul(_pL->get(), _pL->getImg(), iSize, _pR->get(), _pR->getImg(), pOut->get(), pOut->getImg());
 953     return pOut;
 954 }
 955
 956 template<class T, class U, class O>
 957 InternalType* dotmul_MC_S(T *_pL, U *_pR)
 958 {
 959     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 960     dotmul(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), pOut->get(), pOut->getImg());
 961     return pOut;
 962 }
 963
 964 template<class T, class U, class O>
 965 InternalType* dotmul_MC_SC(T *_pL, U *_pR)
 966 {
 967     O* pOut = new O(_pL->getDims(), _pL->getDimsArray(), true);
 968     dotmul(_pL->get(), _pL->getImg(), pOut->getSize(), _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
 969     return pOut;
 970 }
 971
 972 template<class T, class U, class O>
 973 InternalType* dotmul_MC_I(T * /*_pL*/, U * /*_pR*/)
 974 {
 975     return NULL;
 976 }
 977
 978 template<class T, class U, class O>
 979 InternalType* dotmul_MC_IC(T * /*_pL*/, U * /*_pR*/)
 980 {
 981     return NULL;
 982 }
 983
 984 //Scalar .* x
 985 template<class T, class U, class O>
 986 InternalType* dotmul_S_M(T *_pL, U *_pR)
 987 {
 988     return dotmul_M_S<U, T, O>(_pR, _pL);
 989 }
 990
 991 template<class T, class U, class O>
 992 InternalType* dotmul_S_MC(T *_pL, U *_pR)
 993 {
 994     return dotmul_MC_S<U, T, O>(_pR, _pL);
 995 }
 996
 997 template<class T, class U, class O>
 998 InternalType* dotmul_S_S(T *_pL, U *_pR)
 999 {
1000     O* pOut = new O(0);
1001     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1002     return pOut;
1003 }
1004
1005 template<class T, class U, class O>
1006 InternalType* dotmul_S_SC(T *_pL, U *_pR)
1007 {
1008     O* pOut = new O(0.0, 0.0);
1009     dotmul(_pL->get(), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1010     return pOut;
1011 }
1012
1013 template<class T, class U, class O>
1014 InternalType* dotmul_S_I(T *_pL, U *_pR)
1015 {
1016     O* pOut = (O*)_pR->clone();
1017     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1018     return pOut;
1019 }
1020
1021 template<class T, class U, class O>
1022 InternalType* dotmul_S_IC(T *_pL, U *_pR)
1023 {
1024     O* pOut = (O*)_pR->clone();
1025     dotmul(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1026     return pOut;
1027 }
1028
1029 //Scalar complex .* x
1030 template<class T, class U, class O>
1031 InternalType* dotmul_SC_M(T *_pL, U *_pR)
1032 {
1033     return dotmul_M_SC<U, T, O>(_pR, _pL);
1034 }
1035
1036 template<class T, class U, class O>
1037 InternalType* dotmul_SC_MC(T *_pL, U *_pR)
1038 {
1039     return dotmul_MC_SC<U, T, O>(_pR, _pL);
1040 }
1041
1042 template<class T, class U, class O>
1043 InternalType* dotmul_SC_S(T *_pL, U *_pR)
1044 {
1045     return dotmul_S_SC<U, T, O>(_pR, _pL);
1046 }
1047
1048 template<class T, class U, class O>
1049 InternalType* dotmul_SC_SC(T *_pL, U *_pR)
1050 {
1051     O* pOut = new O(0.0, 0.0);
1052     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1053     return pOut;
1054 }
1055
1056 template<class T, class U, class O>
1057 InternalType* dotmul_SC_I(T *_pL, U *_pR)
1058 {
1059     O* pOut = (O*)_pR->clone();
1060     pOut->setComplex(true);
1061     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1062     return pOut;
1063 }
1064
1065 template<class T, class U, class O>
1066 InternalType* dotmul_SC_IC(T *_pL, U *_pR)
1067 {
1068     O* pOut = (O*)_pR->clone();
1069     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1070     return pOut;
1071 }
1072
1073 //Identity .* x
1074 template<class T, class U, class O>
1075 InternalType* dotmul_I_M(T * /*_pL*/, U * /*_pR*/)
1076 {
1077     return NULL;
1078 }
1079
1080 template<class T, class U, class O>
1081 InternalType* dotmul_I_MC(T * /*_pL*/, U * /*_pR*/)
1082 {
1083     return NULL;
1084 }
1085
1086 template<class T, class U, class O>
1087 InternalType* dotmul_I_S(T *_pL, U *_pR)
1088 {
1089     return dotmul_S_I<U, T, O>(_pR, _pL);
1090 }
1091
1092 template<class T, class U, class O>
1093 InternalType* dotmul_I_SC(T *_pL, U *_pR)
1094 {
1095     return dotmul_SC_I<U, T, O>(_pR, _pL);
1096 }
1097
1098 template<class T, class U, class O>
1099 InternalType* dotmul_I_I(T *_pL, U *_pR)
1100 {
1101     O* pOut = (O*)_pL->clone();
1102     dotmul(_pL->get(0), _pR->get(0), pOut->get());
1103     return pOut;
1104 }
1105
1106 template<class T, class U, class O>
1107 InternalType* dotmul_I_IC(T *_pL, U *_pR)
1108 {
1109     O* pOut = (O*)_pR->clone();
1110     dotmul(_pL->get(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1111     return pOut;
1112 }
1113
1114 //Identity complex .* x
1115 template<class T, class U, class O>
1116 InternalType* dotmul_IC_M(T * /*_pL*/, U * /*_pR*/)
1117 {
1118     return NULL;
1119 }
1120
1121 template<class T, class U, class O>
1122 InternalType* dotmul_IC_MC(T * /*_pL*/, U * /*_pR*/)
1123 {
1124     return NULL;
1125 }
1126
1127 template<class T, class U, class O>
1128 InternalType* dotmul_IC_S(T *_pL, U *_pR)
1129 {
1130     return dotmul_S_IC<U, T, O>(_pR, _pL);
1131 }
1132
1133 template<class T, class U, class O>
1134 InternalType* dotmul_IC_SC(T *_pL, U *_pR)
1135 {
1136     return dotmul_SC_IC<U, T, O>(_pR, _pL);
1137 }
1138
1139 template<class T, class U, class O>
1140 InternalType* dotmul_IC_I(T *_pL, U *_pR)
1141 {
1142     O* pOut = (O*)_pL->clone();
1143     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), pOut->get(), pOut->getImg());
1144     return pOut;
1145 }
1146
1147 template<class T, class U, class O>
1148 InternalType* dotmul_IC_IC(T *_pL, U *_pR)
1149 {
1150     O* pOut = (O*)_pL->clone();
1151     dotmul(_pL->get(0), _pL->getImg(0), 1, _pR->get(0), _pR->getImg(0), pOut->get(), pOut->getImg());
1152     return pOut;
1153 }
1154
1155 //Empty .* x
1156 template<class T, class U, class O>
1157 InternalType* dotmul_E_M(T *_pL, U * /*_pR*/)
1158 {
1159     return _pL;
1160 }
1161
1162 template<>
1163 InternalType* dotmul_M_M<Sparse, Sparse, Sparse>(Sparse* _pL, Sparse* _pR)
1164 {
1165     //check dims
1166     if (_pL->isScalar())
1167     {
1168         Sparse* pOut = NULL;
1169         std::complex<double> c(_pL->getImg(0, 0));
1170         Double* pL = NULL;
1171         if (c.imag())
1172         {
1173             pL = new Double(c.real(), c.imag());
1174         }
1175         else
1176         {
1177             pL = new Double(c.real());
1178         }
1179         pOut = (Sparse*)dotmul_M_M<Double, Sparse, Sparse>(pL, _pR);
1180         delete pL;
1181         return pOut;
1182     }
1183
1184     if (_pR->isScalar())
1185     {
1186         Sparse* pOut = NULL;
1187         std::complex<double> c(_pR->getImg(0, 0));
1188         Double* pR = NULL;
1189         if (c.imag())
1190         {
1191             pR = new Double(c.real(), c.imag());
1192         }
1193         else
1194         {
1195             pR = new Double(c.real());
1196         }
1197         pOut = (Sparse*)dotmul_M_M<Sparse, Double, Sparse>(_pL, pR);
1198         delete pR;
1199         return pOut;
1200     }
1201
1202     //check dimensions
1203     if (_pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1204     {
1205         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1206     }
1207
1208     return _pL->dotMultiply(*_pR);
1209 }
1210
1211 //[] .* SP
1212 template<>
1213 InternalType* dotmul_M_M<Double, Sparse, Double>(Double* _pL, Sparse* /*_pR*/)
1214 {
1215     return _pL;
1216 }
1217
1218 //SP .* []
1219 template<>
1220 InternalType* dotmul_M_M<Sparse, Double, Double>(Sparse* /*_pL*/, Double* _pR)
1221 {
1222     return _pR;
1223 }
1224
1225 template<>
1226 InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
1227 {
1228     //D * SP
1229     if (_pL->isScalar())
1230     {
1231         //d * SP -> SP
1232         if (_pL->isComplex())
1233         {
1234             std::complex<double> dbl(_pL->get(0), _pL->getImg(0));
1235             return _pR->multiply(dbl);
1236         }
1237         else
1238         {
1239             return _pR->multiply(_pL->get(0));
1240         }
1241     }
1242
1243     if (_pR->isScalar())
1244     {
1245         //D * sp -> D .* d
1246         Double* pD = NULL;
1247
1248         if (_pR->isComplex())
1249         {
1250             std::complex<double> dbl(_pR->getImg(0, 0));
1251             pD = new Double(dbl.real(), dbl.imag());
1252         }
1253         else
1254         {
1255             pD = new Double(_pR->get(0, 0));
1256         }
1257
1258         InternalType* pIT = GenericDotTimes(_pL, pD);
1259         delete pD;
1260         return pIT;
1261     }
1262
1263
1264     //check dimensions
1265     if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
1266     {
1267         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1268     }
1269
1270     //get some information
1271     int iNonZeros = static_cast<int>(_pR->nonZeros());
1272     int* pRows = new int[iNonZeros * 2];
1273     _pR->outputRowCol(pRows);
1274     int* pCols = pRows + iNonZeros;
1275     double* pValR = new double[iNonZeros];
1276     double* pValI = new double[iNonZeros];
1277     _pR->outputValues(pValR, pValI);
1278     double* pdblR = _pL->get();
1279     int iRows = _pL->getRows();
1280
1281     Sparse* pOut = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex() || _pR->isComplex());
1282
1283     if (_pL->isComplex() == false)
1284     {
1285         if (_pR->isComplex() == false)
1286         {
1287             for (int i = 0 ; i < iNonZeros ; i++)
1288             {
1289                 int iRow = static_cast<int>(pRows[i]) - 1;
1290                 int iCol = static_cast<int>(pCols[i]) - 1;
1291                 int index = iCol * iRows + iRow;
1292
1293                 pOut->set(iRow, iCol,  pdblR[index] * pValR[i]);
1294             }
1295         }
1296         else
1297         {
1298             for (int i = 0 ; i < iNonZeros ; i++)
1299             {
1300                 int iRow = static_cast<int>(pRows[i]) - 1;
1301                 int iCol = static_cast<int>(pCols[i]) - 1;
1302                 int index = iCol * iRows + iRow;
1303
1304                 std::complex<double> c;
1305                 c.real(pdblR[index] * pValR[i]);
1306                 c.imag(pdblR[index] * pValI[i]);
1307                 pOut->set(iRow, iCol,  c);
1308             }
1309         }
1310     }
1311     else
1312     {
1313         double* pdblI = _pL->getImg();
1314         if (_pR->isComplex() == false)
1315         {
1316             for (int i = 0 ; i < iNonZeros ; i++)
1317             {
1318                 int iRow = static_cast<int>(pRows[i]) - 1;
1319                 int iCol = static_cast<int>(pCols[i]) - 1;
1320                 int index = iCol * iRows + iRow;
1321
1322                 std::complex<double> c;
1323                 c.real(pdblR[index] * pValR[i]);
1324                 c.imag(pdblI[index] * pValR[i]);
1325                 pOut->set(iRow, iCol,  c);
1326             }
1327         }
1328         else
1329         {
1330             for (int i = 0 ; i < iNonZeros ; i++)
1331             {
1332                 int iRow = static_cast<int>(pRows[i]) - 1;
1333                 int iCol = static_cast<int>(pCols[i]) - 1;
1334                 int index = iCol * iRows + iRow;
1335
1336                 std::complex<double> c;
1337                 c.real(pdblR[index] * pValR[i] - pdblI[index] * pValI[i]);
1338                 c.imag(pdblR[index] * pValI[i] + pdblI[index] * pValR[i]);
1339                 pOut->set(iRow, iCol,  c);
1340             }
1341         }
1342     }
1343
1344     delete[] pRows;
1345     delete[] pValR;
1346     delete[] pValI;
1347
1348     return pOut;
1349 }
1350
1351 template<>
1352 InternalType* dotmul_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
1353 {
1354     return dotmul_M_M<Double, Sparse, Sparse>(_pR, _pL);
1355 }
1356
1357 //Polynom
1358 template<>
1359 InternalType* dotmul_M_M<Polynom, Polynom, Polynom>(Polynom* _pL, Polynom* _pR)
1360 {
1361     //check varname
1362     if (_pL->getVariableName() != _pR->getVariableName())
1363     {
1364         //call overload
1365         return NULL;
1366     }
1367
1368     int iDimsL = _pL->getDims();
1369     int iDimsR = _pR->getDims();
1370     int* piDimsL = _pL->getDimsArray();
1371     int* piDimsR = _pR->getDimsArray();
1372
1373     if (_pL->isScalar())
1374     {
1375         Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsR, piDimsR);
1376         int iSize = pOut->getSize();
1377         SinglePoly** pSPOut = pOut->get();
1378         SinglePoly* pSPL = _pL->get(0);
1379         SinglePoly** pSPR = _pR->get();
1380
1381         for (int i = 0 ; i < iSize ; ++i)
1382         {
1383             pSPOut[i] = *pSPL **pSPR[i];
1384         }
1385
1386         return pOut;
1387     }
1388
1389     if (_pR->isScalar())
1390     {
1391         Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsL, piDimsL);
1392         int iSize = pOut->getSize();
1393         SinglePoly** pSPOut = pOut->get();
1394         SinglePoly** pSPL = _pL->get();
1395         SinglePoly* pSPR = _pR->get(0);
1396
1397         for (int i = 0 ; i < iSize ; ++i)
1398         {
1399             pSPOut[i] = *pSPL[i] **pSPR;
1400         }
1401
1402         return pOut;
1403     }
1404
1405     //check dims
1406     if (iDimsL != iDimsR)
1407     {
1408         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1409     }
1410
1411     for (int i = 0 ; i < iDimsL ; ++i)
1412     {
1413         if (piDimsL[i] != piDimsR[i])
1414         {
1415             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1416         }
1417     }
1418
1419     Polynom* pOut = new Polynom(_pL->getVariableName(), iDimsL, piDimsR);
1420     int iSize = pOut->getSize();
1421     SinglePoly** pSPOut = pOut->get();
1422     SinglePoly** pSPL = _pL->get();
1423     SinglePoly** pSPR = _pR->get();
1424
1425     for (int i = 0 ; i < iSize ; ++i)
1426     {
1427         pSPOut[i] = *pSPL[i] **pSPR[i];
1428     }
1429
1430     return pOut;
1431 }
1432
1433 template<>
1434 InternalType* dotmul_M_M<Polynom, Double, Polynom>(Polynom* _pL, Double* _pR)
1435 {
1436     return dotmul_M_M<Double, Polynom, Polynom>(_pR, _pL);
1437 }
1438
1439 template<>
1440 InternalType* dotmul_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom* _pR)
1441 {
1442     Polynom* pOut = NULL;
1443
1444     bool isComplexL = _pL->isComplex();
1445     bool isComplexR = _pR->isComplex();
1446     bool isComplexOut = isComplexL || isComplexR;
1447
1448     if (_pL->isScalar())
1449     {
1450         pOut = (Polynom*)_pR->clone();
1451         SinglePoly** pSPR = _pR->get();
1452         SinglePoly** pSP = pOut->get();
1453         int iSize = pOut->getSize();
1454
1455         double dblR = _pL->get(0);
1456         if (isComplexL)
1457         {
1458             double dblI = _pL->getImg(0);
1459             pOut->setComplex(true);
1460             if (isComplexR)
1461             {
1462                 for (int i = 0 ; i < iSize ; i++)
1463                 {
1464                     dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1465                 }
1466             }
1467             else
1468             {
1469                 for (int i = 0 ; i < iSize ; i++)
1470                 {
1471                     dotmul(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, dblI, pSP[i]->get(), pSP[i]->getImg());
1472                 }
1473             }
1474         }
1475         else
1476         {
1477             if (isComplexR)
1478             {
1479                 for (int i = 0 ; i < iSize ; i++)
1480                 {
1481                     dotmul(pSP[i]->get(), pSP[i]->getImg(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get(), pSP[i]->getImg());
1482                 }
1483             }
1484             else
1485             {
1486                 //r .* P
1487                 for (int i = 0 ; i < iSize ; i++)
1488                 {
1489                     dotmul(pSP[i]->get(), (size_t)pSP[i]->getSize(), dblR, pSP[i]->get());
1490                 }
1491             }
1492         }
1493
1494         return pOut;
1495     }
1496
1497     if (_pR->isScalar())
1498     {
1499         pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray());
1500         SinglePoly* pSPL = _pR->get(0);
1501         SinglePoly** pSP = pOut->get();
1502         int iSize = pOut->getSize();
1503         double* pdblLR = _pL->get();
1504         double* pdblLI = NULL;
1505         if (isComplexL)
1506         {
1507             pdblLI  = _pL->getImg();
1508         }
1509
1510         double* pdblRR = pSPL->get();
1511         double* pdblRI = NULL;
1512         if (isComplexR)
1513         {
1514             pdblRI = pSPL->getImg();
1515         }
1516
1517         if (isComplexL)
1518         {
1519             if (isComplexR)
1520             {
1521                 for (int i = 0 ; i < iSize ; ++i)
1522                 {
1523                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1524                     int iSPSize = pSPOut->getSize();
1525                     pSPOut->setComplex(isComplexOut);
1526
1527                     double* pdblOutR = pSPOut->get();
1528                     double* pdblOutI = pSPOut->getImg();
1529
1530                     dotmul(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1531                     pSP[i] = pSPOut;
1532                 }
1533             }
1534             else
1535             {
1536                 for (int i = 0 ; i < iSize ; ++i)
1537                 {
1538                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1539                     int iSPSize = pSPOut->getSize();
1540                     pSPOut->setComplex(isComplexOut);
1541
1542                     double* pdblOutR = pSPOut->get();
1543                     double* pdblOutI = pSPOut->getImg();
1544                     dotmul(pdblRR, (size_t)iSPSize, pdblLR[i], pdblLI[i], pdblOutR, pdblOutI);
1545                     pSP[i] = pSPOut;
1546                 }
1547             }
1548         }
1549         else
1550         {
1551             if (isComplexR)
1552             {
1553                 for (int i = 0 ; i < iSize ; ++i)
1554                 {
1555                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1556                     int iSPSize = pSPOut->getSize();
1557                     pSPOut->setComplex(isComplexOut);
1558
1559                     double* pdblOutR = pSPOut->get();
1560                     double* pdblOutI = pSPOut->getImg();
1561                     dotmul(pdblRR, pdblRI, (size_t)iSPSize, pdblLR[i], pdblOutR, pdblOutI);
1562                     pSP[i] = pSPOut;
1563                 }
1564             }
1565             else
1566             {
1567                 for (int i = 0 ; i < iSize ; ++i)
1568                 {
1569                     SinglePoly* pSPOut = (SinglePoly*)pSPL->clone();
1570                     int iSPSize = pSPOut->getSize();
1571                     pSPOut->setComplex(isComplexOut);
1572
1573                     double* pdblOutR = pSPOut->get();
1574                     dotmul(pdblRR, (size_t)iSPSize, pdblLR[i], pdblOutR);
1575                     pSP[i] = pSPOut;
1576                 }
1577             }
1578         }
1579
1580         return pOut;
1581
1582     }
1583
1584     //check dims
1585     int iDimsL = _pL->getDims();
1586     int iDimsR = _pR->getDims();
1587
1588     if (iDimsL != iDimsR)
1589     {
1590         throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1591     }
1592
1593     int* piDimsL = _pL->getDimsArray();
1594     int* piDimsR = _pR->getDimsArray();
1595
1596     for (int i = 0 ; i < iDimsL ; ++i)
1597     {
1598         if (piDimsL[i] != piDimsR[i])
1599         {
1600             throw ast::InternalError(_W("Inconsistent row/column dimensions.\n"));
1601         }
1602     }
1603
1604
1605     pOut = (Polynom*)_pR->clone();
1606     pOut->setComplex(isComplexOut);
1607     SinglePoly** pSPR = _pR->get();
1608     SinglePoly** pSP = pOut->get();
1609     int iSize = pOut->getSize();
1610
1611     double* pdblR = _pL->get();
1612     double* pdblI = NULL;
1613     if (isComplexL)
1614     {
1615         pdblI = _pL->getImg();
1616     }
1617
1618     if (isComplexL)
1619     {
1620         if (isComplexR)
1621         {
1622             for (int i = 0 ; i < iSize ; i++)
1623             {
1624                 dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1625             }
1626         }
1627         else
1628         {
1629             for (int i = 0 ; i < iSize ; i++)
1630             {
1631                 dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pdblI[i], pSP[i]->get(), pSP[i]->getImg());
1632             }
1633         }
1634     }
1635     else
1636     {
1637         if (isComplexR)
1638         {
1639             for (int i = 0 ; i < iSize ; i++)
1640             {
1641                 dotmul(pSPR[i]->get(), pSPR[i]->getImg(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get(), pSP[i]->getImg());
1642             }
1643         }
1644         else
1645         {
1646             //r .* P
1647             for (int i = 0 ; i < iSize ; i++)
1648             {
1649                 dotmul(pSPR[i]->get(), (size_t)pSPR[i]->getSize(), pdblR[i], pSP[i]->get());
1650             }
1651         }
1652     }
1653
1654     return pOut;
1655 }