refactoring polynom.
[scilab.git] / scilab / modules / ast / src / cpp / operations / types_multiplication.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_multiplication.hxx"
15 #include "types_addition.hxx"
16 #include "arrayof.hxx"
17
18 #include "scilabexception.hxx"
19
20 extern "C"
21 {
22 #include "matrix_multiplication.h"
23 #include "matrix_addition.h"
24 #include "operation_f.h"
25 #include "localization.h"
26 #include "charEncoding.h"
27 #include "elem_common.h"
28 }
29
30 using namespace types;
31
32 InternalType *GenericDotTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
33 {
34     InternalType *pResult = NULL;
35
36     if (_pLeftOperand->isDouble() && _pLeftOperand->getAs<Double>()->isEmpty())
37     {
38         return Double::Empty();
39     }
40
41     if (_pRightOperand->isDouble() && _pRightOperand->getAs<Double>()->isEmpty())
42     {
43         return Double::Empty();
44     }
45
46     /*
47     ** DOUBLE .* DOUBLE
48     */
49     if (_pLeftOperand->isDouble() && _pRightOperand->isDouble())
50     {
51         Double *pL   = _pLeftOperand->getAs<Double>();
52         Double *pR   = _pRightOperand->getAs<Double>();
53
54         int iResult = DotMultiplyDoubleByDouble(pL, pR, (Double**)&pResult);
55         if (iResult)
56         {
57             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
58         }
59
60         return pResult;
61     }
62
63     /*
64     ** SPARSE .* SPARSE
65     */
66     if (_pLeftOperand->isSparse() && _pRightOperand->isSparse())
67     {
68         Sparse *pL   = _pLeftOperand->getAs<Sparse>();
69         Sparse *pR   = _pRightOperand->getAs<Sparse>();
70
71         int iResult = DotMultiplySparseBySparse(pL, pR, (Sparse**)&pResult);
72         if (iResult)
73         {
74             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
75         }
76
77         return pResult;
78     }
79
80     /*
81     ** SPARSE .* DOUBLE
82     */
83     if (_pLeftOperand->isSparse() && _pRightOperand->isDouble())
84     {
85         Sparse *pL   = _pLeftOperand->getAs<Sparse>();
86         Double *pR   = _pRightOperand->getAs<Double>();
87
88         int iResult = DotMultiplySparseByDouble(pL, pR, (GenericType**)&pResult);
89         if (iResult)
90         {
91             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
92         }
93
94         return pResult;
95     }
96
97     /*
98     ** DOUBLE .* SPARSE
99     */
100     if (_pLeftOperand->isDouble() && _pRightOperand->isSparse())
101     {
102         Double *pL   = _pLeftOperand->getAs<Double>();
103         Sparse *pR   = _pRightOperand->getAs<Sparse>();
104
105         int iResult = DotMultiplyDoubleBySparse(pL, pR, (GenericType**)&pResult);
106         if (iResult)
107         {
108             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
109         }
110
111         return pResult;
112     }
113
114     /*
115     ** DOUBLE .* POLY
116     */
117     if (_pLeftOperand->isDouble() && _pRightOperand->isPoly())
118     {
119         Double *pL   = _pLeftOperand->getAs<Double>();
120         Polynom *pR  = _pRightOperand->getAs<Polynom>();
121
122         int iResult = DotMultiplyDoubleByPoly(pL, pR, (Polynom**)&pResult);
123         if (iResult)
124         {
125             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
126         }
127
128         return pResult;
129     }
130
131     /*
132     ** POLY .* DOUBLE
133     */
134     if (_pLeftOperand->isPoly() && _pRightOperand->isDouble())
135     {
136         Polynom *pL   = _pLeftOperand->getAs<Polynom>();
137         Double *pR    = _pRightOperand->getAs<Double>();
138
139         int iResult = DotMultiplyPolyByDouble(pL, pR, (Polynom**)&pResult);
140         if (iResult)
141         {
142             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
143         }
144
145         return pResult;
146     }
147
148     /*
149     ** POLY .* POLY
150     */
151     if (_pLeftOperand->isPoly() && _pRightOperand->isPoly())
152     {
153         Polynom *pL   = _pLeftOperand->getAs<Polynom>();
154         Polynom *pR   = _pRightOperand->getAs<Polynom>();
155
156         int iResult = DotMultiplyPolyByPoly(pL, pR, (Polynom**)&pResult);
157         if (iResult)
158         {
159             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
160         }
161
162         return pResult;
163     }
164
165     /*
166     ** Default case : Return NULL will Call Overloading.
167     */
168     return NULL;
169 }
170
171 InternalType *GenericTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
172 {
173     InternalType *pResult = NULL;
174     GenericType::ScilabType TypeL = _pLeftOperand->getType();
175     GenericType::ScilabType TypeR = _pRightOperand->getType();
176
177     if (TypeL == GenericType::ScilabDouble && _pLeftOperand->getAs<Double>()->isEmpty())
178     {
179         return Double::Empty();
180     }
181
182     if (TypeR == GenericType::ScilabDouble && _pRightOperand->getAs<Double>()->isEmpty())
183     {
184         return Double::Empty();
185     }
186
187     /*
188     ** DOUBLE * DOUBLE
189     */
190     if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabDouble)
191     {
192         Double *pL   = _pLeftOperand->getAs<Double>();
193         Double *pR   = _pRightOperand->getAs<Double>();
194
195         int iResult = MultiplyDoubleByDouble(pL, pR, (Double**)&pResult);
196         if (iResult)
197         {
198             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
199         }
200
201         return pResult;
202     }
203
204     /*
205     ** DOUBLE * POLY
206     */
207     else if (TypeL == InternalType::ScilabDouble && TypeR == InternalType::ScilabPolynom)
208     {
209         Double *pL   = _pLeftOperand->getAs<Double>();
210         Polynom *pR     = _pRightOperand->getAs<types::Polynom>();
211
212         int iResult = MultiplyDoubleByPoly(pL, pR, (Polynom**)&pResult);
213         if (iResult)
214         {
215             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
216         }
217
218         return pResult;
219     }
220
221     /*
222     ** POLY * DOUBLE
223     */
224     else if (TypeL == InternalType::ScilabPolynom && TypeR == InternalType::ScilabDouble)
225     {
226         Polynom *pL          = _pLeftOperand->getAs<types::Polynom>();
227         Double *pR              = _pRightOperand->getAs<Double>();
228
229         int iResult = MultiplyPolyByDouble(pL, pR, (Polynom**)&pResult);
230         if (iResult)
231         {
232             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
233         }
234
235         return pResult;
236     }
237
238     /*
239     ** POLY * POLY
240     */
241     else if (TypeL == InternalType::ScilabPolynom && TypeR == InternalType::ScilabPolynom)
242     {
243         Polynom *pL          = _pLeftOperand->getAs<types::Polynom>();
244         Polynom *pR          = _pRightOperand->getAs<types::Polynom>();
245
246         int iResult = MultiplyPolyByPoly(pL, pR, (Polynom**)&pResult);
247         if (iResult)
248         {
249             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
250         }
251
252         return pResult;
253     }
254
255     /*
256     ** SPARSE * SPARSE
257     */
258     if (TypeL == GenericType::ScilabSparse && TypeR == GenericType::ScilabSparse)
259     {
260         Sparse *pL   = _pLeftOperand->getAs<Sparse>();
261         Sparse *pR   = _pRightOperand->getAs<Sparse>();
262
263         int iResult = MultiplySparseBySparse(pL, pR, (Sparse**)&pResult);
264         if (iResult)
265         {
266             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
267         }
268
269         return pResult;
270     }
271
272     /*
273     ** DOUBLE * SPARSE
274     */
275     if (TypeL == GenericType::ScilabDouble && TypeR == GenericType::ScilabSparse)
276     {
277         Double *pL   = _pLeftOperand->getAs<Double>();
278         Sparse *pR   = _pRightOperand->getAs<Sparse>();
279
280         int iResult = MultiplyDoubleBySparse(pL, pR, (GenericType**)&pResult);
281         if (iResult)
282         {
283             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
284         }
285
286         return pResult;
287     }
288
289     /*
290     ** SPARSE * DOUBLE
291     */
292     if (TypeL == GenericType::ScilabSparse && TypeR == GenericType::ScilabDouble)
293     {
294         Sparse *pL   = _pLeftOperand->getAs<Sparse>();
295         Double *pR   = _pRightOperand->getAs<Double>();
296
297         int iResult = MultiplySparseByDouble(pL, pR, (GenericType**)&pResult);
298         if (iResult)
299         {
300             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
301         }
302
303         return pResult;
304     }
305
306     /*
307     ** Default case : Return NULL will Call Overloading.
308     */
309     return NULL;
310
311 }
312
313 int MultiplyDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoubleOut)
314 {
315     if (_pDouble1->isScalar())
316     {
317         bool bComplex1  = _pDouble1->isComplex();
318         bool bComplex2  = _pDouble2->isComplex();
319
320         (*_pDoubleOut) = new Double(_pDouble2->getDims(), _pDouble2->getDimsArray(), bComplex1 | bComplex2);
321
322         if (bComplex1 == false && bComplex2 == false)
323         {
324             iMultiRealScalarByRealMatrix(_pDouble1->get(0), _pDouble2->get(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get());
325         }
326         else if (bComplex1 == false && bComplex2 == true)
327         {
328             iMultiRealScalarByComplexMatrix(_pDouble1->get(0), _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
329         }
330         else if (bComplex1 == true && bComplex2 == false)
331         {
332             iMultiComplexScalarByRealMatrix(_pDouble1->get(0), _pDouble1->getImg(0), _pDouble2->get(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
333         }
334         else //if(bComplex1 == true && bComplex2 == true)
335         {
336             iMultiComplexScalarByComplexMatrix(_pDouble1->get(0), _pDouble1->getImg(0), _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
337         }
338
339         return 0;
340     }
341
342     if (_pDouble2->isScalar())
343     {
344         bool bComplex1  = _pDouble1->isComplex();
345         bool bComplex2  = _pDouble2->isComplex();
346
347         (*_pDoubleOut) = new Double(_pDouble1->getDims(), _pDouble1->getDimsArray(), bComplex1 | bComplex2);
348
349         if (bComplex1 == false && bComplex2 == false)
350         {
351             //Real Matrix by Real Scalar
352             iMultiRealScalarByRealMatrix(_pDouble2->get(0), _pDouble1->get(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get());
353         }
354         else if (bComplex1 == false && bComplex2 == true)
355         {
356             //Real Matrix by Scalar Complex
357             iMultiComplexScalarByRealMatrix(_pDouble2->get(0), _pDouble2->getImg(0), _pDouble1->get(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
358         }
359         else if (bComplex1 == true && bComplex2 == false)
360         {
361             iMultiRealScalarByComplexMatrix(_pDouble2->get(0, 0), _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
362         }
363         else //if(bComplex1 == true && bComplex2 == true)
364         {
365             iMultiComplexScalarByComplexMatrix(_pDouble2->get(0, 0), _pDouble2->getImg(0, 0), _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
366         }
367
368         return 0;
369     }
370
371     if (_pDouble1->getDims() > 2 || _pDouble2->getDims() > 2 || _pDouble1->getCols() != _pDouble2->getRows())
372     {
373         return 1;
374     }
375
376     bool bComplex1  = _pDouble1->isComplex();
377     bool bComplex2  = _pDouble2->isComplex();
378     (*_pDoubleOut) = new Double(_pDouble1->getRows(), _pDouble2->getCols(), bComplex1 | bComplex2);
379
380     if (bComplex1 == false && bComplex2 == false)
381     {
382         //Real Matrix by Real Matrix
383         iMultiRealMatrixByRealMatrix(
384             _pDouble1->get(), _pDouble1->getRows(), _pDouble1->getCols(),
385             _pDouble2->get(), _pDouble2->getRows(), _pDouble2->getCols(),
386             (*_pDoubleOut)->get());
387     }
388     else if (bComplex1 == false && bComplex2 == true)
389     {
390         //Real Matrix by Matrix Complex
391         iMultiRealMatrixByComplexMatrix(
392             _pDouble1->get(), _pDouble1->getRows(), _pDouble1->getCols(),
393             _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getRows(), _pDouble2->getCols(),
394             (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
395     }
396     else if (bComplex1 == true && bComplex2 == false)
397     {
398         //Complex Matrix by Real Matrix
399         iMultiComplexMatrixByRealMatrix(
400             _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getRows(), _pDouble1->getCols(),
401             _pDouble2->get(), _pDouble2->getRows(), _pDouble2->getCols(),
402             (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
403     }
404     else //if(bComplex1 == true && bComplex2 == true)
405     {
406         //Complex Matrix by Complex Matrix
407         iMultiComplexMatrixByComplexMatrix(
408             _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getRows(), _pDouble1->getCols(),
409             _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getRows(), _pDouble2->getCols(),
410             (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
411     }
412     return 0;
413 }
414
415 int DotMultiplyDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double**  _pDoubleOut)
416 {
417     bool bComplex1  = _pDouble1->isComplex();
418     bool bComplex2  = _pDouble2->isComplex();
419     bool bScalar1   = _pDouble1->isScalar();
420     bool bScalar2   = _pDouble2->isScalar();
421
422     if (bScalar1)
423     {
424         (*_pDoubleOut) = new Double(_pDouble2->getDims(), _pDouble2->getDimsArray(), _pDouble1->isComplex() | _pDouble2->isComplex());
425         if (bComplex1 == false && bComplex2 == false)
426         {
427             iMultiRealScalarByRealMatrix(_pDouble1->get(0), _pDouble2->get(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get());
428         }
429         else if (bComplex1 == false && bComplex2 == true)
430         {
431             iMultiRealScalarByComplexMatrix(_pDouble1->get(0), _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
432         }
433         else if (bComplex1 == true && bComplex2 == false)
434         {
435             iMultiComplexScalarByRealMatrix(_pDouble1->get(0), _pDouble1->getImg(0), _pDouble2->get(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
436         }
437         else //if(bComplex1 == true && bComplex2 == true)
438         {
439             iMultiComplexScalarByComplexMatrix(_pDouble1->get(0), _pDouble1->getImg(0), _pDouble2->get(), _pDouble2->getImg(), _pDouble2->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
440         }
441
442         return 0;
443     }
444
445     if (bScalar2)
446     {
447         (*_pDoubleOut) = new Double(_pDouble1->getDims(), _pDouble1->getDimsArray(), _pDouble1->isComplex() | _pDouble2->isComplex());
448         if (bComplex1 == false && bComplex2 == false)
449         {
450             //Real Matrix by Real Scalar
451             iMultiRealScalarByRealMatrix(_pDouble2->get(0), _pDouble1->get(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get());
452         }
453         else if (bComplex1 == false && bComplex2 == true)
454         {
455             //Real Matrix by Scalar Complex
456             iMultiComplexScalarByRealMatrix(_pDouble2->get(0), _pDouble2->getImg(0), _pDouble1->get(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
457         }
458         else if (bComplex1 == true && bComplex2 == false)
459         {
460             iMultiRealScalarByComplexMatrix(_pDouble2->get(0), _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
461         }
462         else //if(bComplex1 == true && bComplex2 == true)
463         {
464             iMultiComplexScalarByComplexMatrix(_pDouble2->get(0), _pDouble2->getImg(0), _pDouble1->get(), _pDouble1->getImg(), _pDouble1->getSize(), 1, (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg());
465         }
466
467         return 0;
468     }
469
470     if (_pDouble1->getDims() != _pDouble2->getDims())
471     {
472         return 1;
473     }
474
475     int* piDims1 = _pDouble1->getDimsArray();
476     int* piDims2 = _pDouble2->getDimsArray();
477
478     for (int i = 0 ; i < _pDouble1->getDims() ; i++)
479     {
480         if (piDims1[i] != piDims2[i])
481         {
482             return 0;
483         }
484     }
485
486     (*_pDoubleOut) = new Double(_pDouble1->getDims(), _pDouble1->getDimsArray(), _pDouble1->isComplex() | _pDouble2->isComplex());
487     if (bComplex1 == false && bComplex2 == false)
488     {
489         iDotMultiplyRealMatrixByRealMatrix(_pDouble1->get(), _pDouble2->get(), (*_pDoubleOut)->get(), _pDouble1->getSize(), 1);
490     }
491     else if (bComplex1 == false && bComplex2 == true)
492     {
493         iDotMultiplyRealMatrixByComplexMatrix(_pDouble1->get(), _pDouble2->get(), _pDouble2->getImg(), (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg(), _pDouble1->getSize(), 1);
494     }
495     else if (bComplex1 == true && bComplex2 == false)
496     {
497         iDotMultiplyComplexMatrixByRealMatrix(_pDouble1->get(), _pDouble1->getImg(), _pDouble2->get(), (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg(), _pDouble1->getSize(), 1);
498     }
499     else //if(bComplex1 == true && bComplex2 == true)
500     {
501         iDotMultiplyComplexMatrixByComplexMatrix(_pDouble1->get(), _pDouble1->getImg(), _pDouble2->get(), _pDouble2->getImg(), (*_pDoubleOut)->get(), (*_pDoubleOut)->getImg(), _pDouble1->getSize(), 1);
502     }
503
504     return 0;
505 }
506 int MultiplyDoubleByPoly(Double* _pDouble, Polynom* _pPoly, Polynom** _pPolyOut)
507 {
508     bool bComplex1  = _pDouble->isComplex();
509     bool bComplex2  = _pPoly->isComplex();
510     bool bScalar1   = _pDouble->isScalar();
511     bool bScalar2   = _pPoly->isScalar();
512
513     if (_pDouble->isScalar())
514     {
515         int* piRank = new int[_pPoly->getSize()];
516         for (int i = 0 ; i < _pPoly->getSize() ; i++)
517         {
518             piRank[i] = _pPoly->get(i)->getRank();
519         }
520
521         (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pPoly->getDims(), _pPoly->getDimsArray(), piRank);
522         delete[] piRank;
523         if (bComplex1 || bComplex2)
524         {
525             (*_pPolyOut)->setComplex(true);
526         }
527
528         for (int i = 0 ; i < _pPoly->getSize() ; i++)
529         {
530             SinglePoly *pPolyIn     = _pPoly->get(i);
531             double* pRealIn         = pPolyIn->get();
532             double* pImgIn          = pPolyIn->getImg();
533
534             SinglePoly *pPolyOut    = (*_pPolyOut)->get(i);
535             double* pRealOut        = pPolyOut->get();
536             double* pImgOut         = pPolyOut->getImg();
537
538             if (bComplex1 == false && bComplex2 == false)
539             {
540                 iMultiRealScalarByRealMatrix(_pDouble->get(0), pRealIn, 1, pPolyIn->getSize(), pRealOut);
541             }
542             else if (bComplex1 == false && bComplex2 == true)
543             {
544                 iMultiRealScalarByComplexMatrix(_pDouble->get(0), pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
545             }
546             else if (bComplex1 == true && bComplex2 == false)
547             {
548                 iMultiComplexScalarByRealMatrix(_pDouble->get(0), _pDouble->getImg(0), pRealIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
549             }
550             else if (bComplex1 == true && bComplex2 == true)
551             {
552                 iMultiComplexScalarByComplexMatrix(_pDouble->get(0), _pDouble->getImg(0), pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
553             }
554         }
555         (*_pPolyOut)->updateRank();
556         return 0;
557     }
558
559     if (_pPoly->isScalar())
560     {
561         int* piRank = new int[_pDouble->getSize()];
562         for (int i = 0 ; i < _pDouble->getSize() ; i++)
563         {
564             piRank[i] = _pPoly->get(0)->getRank();
565         }
566
567         (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pDouble->getDims(), _pDouble->getDimsArray(), piRank);
568         delete[] piRank;
569         if (bComplex1 || bComplex2)
570         {
571             (*_pPolyOut)->setComplex(true);
572         }
573
574         double *pDoubleR    = _pDouble->get();
575         double *pDoubleI    = _pDouble->getImg();
576
577         SinglePoly *pPolyIn = _pPoly->get(0);
578         double* pRealIn     = pPolyIn->get();
579         double* pImgIn      = pPolyIn->getImg();
580
581         for (int i = 0 ; i < _pDouble->getSize() ; i++)
582         {
583             SinglePoly *pPolyOut    = (*_pPolyOut)->get(i);
584             double* pRealOut        = pPolyOut->get();
585             double* pImgOut         = pPolyOut->getImg();
586
587             if (bComplex1 == false && bComplex2 == false)
588             {
589                 iMultiRealScalarByRealMatrix(pDoubleR[i], pRealIn, 1, pPolyIn->getSize(), pRealOut);
590             }
591             else if (bComplex1 == false && bComplex2 == true)
592             {
593                 iMultiRealScalarByComplexMatrix(pDoubleR[i], pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
594             }
595             else if (bComplex1 == true && bComplex2 == false)
596             {
597                 iMultiComplexScalarByRealMatrix(pDoubleR[i], pDoubleI[i], pRealIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
598             }
599             else if (bComplex1 == true && bComplex2 == true)
600             {
601                 iMultiComplexScalarByComplexMatrix(pDoubleR[i], pDoubleI[i], pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
602             }
603         }
604
605         (*_pPolyOut)->updateRank();
606         return 0;
607     }
608
609     if (_pPoly->getDims() > 2 || _pDouble->getDims() > 2 || _pDouble->getCols() != _pPoly->getRows())
610     {
611         return 1;
612     }
613
614     int* piRank = new int[_pDouble->getRows() * _pPoly->getCols()];
615     int iMaxRank = _pPoly->getMaxRank();
616     for (int i = 0 ; i < _pDouble->getRows() * _pPoly->getCols() ; i++)
617     {
618         piRank[i] = iMaxRank;
619     }
620
621     (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pDouble->getRows(), _pPoly->getCols(), piRank);
622     delete[] piRank;
623     if (bComplex1 || bComplex2)
624     {
625         (*_pPolyOut)->setComplex(true);
626     }
627
628     Double *pCoef = _pPoly->getCoef();
629     Double *pTemp = new Double(_pDouble->getRows(), pCoef->getCols(), bComplex1 || bComplex2);
630
631     if (bComplex1 == false && bComplex2 == false)
632     {
633         iMultiRealMatrixByRealMatrix(_pDouble->get(), _pDouble->getRows(), _pDouble->getCols(),
634                                      pCoef->get(), pCoef->getRows(), pCoef->getCols(),
635                                      pTemp->get());
636     }
637     else if (bComplex1 == false && bComplex2 == true)
638     {
639         iMultiRealMatrixByComplexMatrix(_pDouble->get(), _pDouble->getRows(), _pDouble->getCols(),
640                                         pCoef->get(), pCoef->getImg(), pCoef->getRows(), pCoef->getCols(),
641                                         pTemp->get(), pTemp->getImg());
642
643     }
644     else if (bComplex1 == true && bComplex2 == false)
645     {
646         iMultiComplexMatrixByRealMatrix(_pDouble->get(), _pDouble->getImg(), _pDouble->getRows(), _pDouble->getCols(),
647                                         pCoef->get(), pCoef->getRows(), pCoef->getCols(),
648                                         pTemp->get(), pTemp->getImg());
649     }
650     else //if(bComplex1 == true && bComplex2 == true)
651     {
652         iMultiComplexMatrixByComplexMatrix(_pDouble->get(), _pDouble->getImg(), _pDouble->getRows(), _pDouble->getCols(),
653                                            pCoef->get(), pCoef->getImg(), pCoef->getRows(), pCoef->getCols(),
654                                            pTemp->get(), pTemp->getImg());
655     }
656
657     (*_pPolyOut)->setCoef(pTemp);
658     (*_pPolyOut)->updateRank();
659     delete pTemp;
660     return 0;
661 }
662
663 int MultiplyPolyByDouble(Polynom* _pPoly, Double* _pDouble, Polynom **_pPolyOut)
664 {
665     bool bComplex1  = _pPoly->isComplex();
666     bool bComplex2  = _pDouble->isComplex();
667     bool bScalar1   = _pPoly->isScalar();
668     bool bScalar2   = _pDouble->isScalar();
669
670     if (bScalar1)
671     {
672         int* piRank = new int[_pDouble->getSize()];
673         for (int i = 0 ; i < _pDouble->getSize() ; i++)
674         {
675             piRank[i] = _pPoly->get(0)->getRank();
676         }
677
678         (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pDouble->getDims(), _pDouble->getDimsArray(), piRank);
679         delete[] piRank;
680         if (bComplex1 || bComplex2)
681         {
682             (*_pPolyOut)->setComplex(true);
683         }
684
685         double *pDoubleR    = _pDouble->get();
686         double *pDoubleI    = _pDouble->getImg();
687
688         SinglePoly *pPolyIn = _pPoly->get(0);
689         double* pRealIn     = pPolyIn->get();
690         double* pImgIn      = pPolyIn->getImg();
691
692         for (int i = 0 ; i < _pDouble->getSize() ; i++)
693         {
694             SinglePoly *pPolyOut    = (*_pPolyOut)->get(i);
695             double* pRealOut        = pPolyOut->get();
696             double* pImgOut         = pPolyOut->getImg();
697
698             if (bComplex1 == false && bComplex2 == false)
699             {
700                 iMultiRealScalarByRealMatrix(pDoubleR[i], pRealIn, 1, pPolyIn->getSize(), pRealOut);
701             }
702             else if (bComplex1 == false && bComplex2 == true)
703             {
704                 iMultiComplexScalarByRealMatrix(pDoubleR[i], pDoubleI[i], pRealIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
705             }
706             else if (bComplex1 == true && bComplex2 == false)
707             {
708                 iMultiRealScalarByComplexMatrix(pDoubleR[i], pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
709             }
710             else if (bComplex1 == true && bComplex2 == true)
711             {
712                 iMultiComplexScalarByComplexMatrix(pDoubleR[i], pDoubleI[i], pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
713             }
714         }
715
716         (*_pPolyOut)->updateRank();
717         return 0;
718     }
719     else if (bScalar2)
720     {
721         int* piRank = new int[_pPoly->getSize()];
722         for (int i = 0 ; i < _pPoly->getSize() ; i++)
723         {
724             piRank[i] = _pPoly->get(i)->getRank();
725         }
726
727         (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pPoly->getDims(), _pPoly->getDimsArray(), piRank);
728         delete[] piRank;
729         if (bComplex1 || bComplex2)
730         {
731             (*_pPolyOut)->setComplex(true);
732         }
733
734         for (int i = 0 ; i < _pPoly->getSize() ; i++)
735         {
736             SinglePoly *pPolyIn = _pPoly->get(i);
737             double* pRealIn     = pPolyIn->get();
738             double* pImgIn      = pPolyIn->getImg();
739
740             SinglePoly *pPolyOut    = (*_pPolyOut)->get(i);
741             double* pRealOut        = pPolyOut->get();
742             double* pImgOut         = pPolyOut->getImg();
743
744             if (bComplex1 == false && bComplex2 == false)
745             {
746                 iMultiRealScalarByRealMatrix(_pDouble->get(0), pRealIn, 1, pPolyIn->getSize(), pRealOut);
747             }
748             else if (bComplex1 == false && bComplex2 == true)
749             {
750                 iMultiComplexScalarByRealMatrix(_pDouble->get(0), _pDouble->getImg(0), pRealIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
751             }
752             else if (bComplex1 == true && bComplex2 == false)
753             {
754                 iMultiRealScalarByComplexMatrix(_pDouble->get(0), pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
755             }
756             else if (bComplex1 == true && bComplex2 == true)
757             {
758                 iMultiComplexScalarByComplexMatrix(_pDouble->get(0), _pDouble->getImg(0), pRealIn, pImgIn, 1, pPolyIn->getSize(), pRealOut, pImgOut);
759             }
760         }
761
762         (*_pPolyOut)->updateRank();
763         return 0;
764     }
765
766     if (_pDouble->getDims() > 2 || _pPoly->getDims() > 2 || _pPoly->getCols() != _pDouble->getRows())
767     {
768         return 1;
769     }
770
771     int* piRank = new int[_pPoly->getRows() * _pDouble->getCols()];
772     int iMaxRank = _pPoly->getMaxRank();
773     for (int i = 0 ; i < _pPoly->getRows() * _pDouble->getCols() ; i++)
774     {
775         piRank[i] = iMaxRank;
776     }
777
778     (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), _pPoly->getRows(), _pDouble->getCols(), piRank);
779     delete[] piRank;
780     if (bComplex1 || bComplex2)
781     {
782         (*_pPolyOut)->setComplex(true);
783     }
784
785     //Distribution a la mano par appels a des sous-fonctions ( iMulti...ScalarBy...Scalar ) plus iAdd...To... )
786
787     //for each line of _pPoly
788     for (int iRow1 = 0 ; iRow1 < _pPoly->getRows() ; iRow1++)
789     {
790         //for each col of _pDouble
791         for (int iCol2 = 0 ; iCol2 < _pDouble->getCols() ; iCol2++)
792         {
793             SinglePoly* pSPOut = (*_pPolyOut)->get(iRow1, iCol2);
794             pSPOut->setZeros();
795
796             //for each rows of _pDouble / cols of _pPoly
797             for (int iRow2 = 0 ; iRow2 < _pDouble->getRows() ; iRow2++)
798             {
799                 // SinglePoly(iRow1, iRow2) * Double(iRow2, iCol2)
800                 SinglePoly* pSPIn = _pPoly->get(iRow1, iRow2);
801                 int iSize = pSPIn->getSize();
802                 double* pdblMult = new double[iSize];
803
804                 if (bComplex1 == false && bComplex2 == false)
805                 {
806                     //Real Matrix by Real Scalar
807                     iMultiRealScalarByRealMatrix(_pDouble->get(iRow2, iCol2), pSPIn->get(), iSize, 1, pdblMult);
808                     add(pSPOut->get(), (long long)iSize, pdblMult, pSPOut->get());
809                 }
810                 else if (bComplex1 == false && bComplex2 == true)
811                 {
812                     //Real Matrix by Scalar Complex
813                     double* pdblMultImg = new double[iSize];
814                     iMultiComplexScalarByRealMatrix(_pDouble->get(iRow2, iCol2), _pDouble->getImg(iRow2, iCol2), pSPIn->get(), pSPIn->getSize(), 1, pdblMult, pdblMultImg);
815                     add(pSPOut->get(), pSPOut->getImg(), (long long)iSize, pdblMult, pdblMultImg, pSPOut->get(), pSPOut->getImg());
816                     delete[] pdblMultImg;
817                 }
818                 else if (bComplex1 == true && bComplex2 == false)
819                 {
820                     double* pdblMultImg = new double[iSize];
821                     iMultiRealScalarByComplexMatrix(_pDouble->get(iRow2, iCol2), pSPIn->get(), pSPIn->getImg(), pSPIn->getSize(), 1, pdblMult, pdblMultImg);
822                     add(pSPOut->get(), pSPOut->getImg(), (long long)iSize, pdblMult, pdblMultImg, pSPOut->get(), pSPOut->getImg());
823                     delete[] pdblMultImg;
824                 }
825                 else //if(bComplex1 == true && bComplex2 == true)
826                 {
827                     double* pdblMultImg = new double[iSize];
828                     iMultiComplexScalarByComplexMatrix(_pDouble->get(iRow2, iCol2), _pDouble->getImg(iRow2, iCol2), pSPIn->get(), pSPIn->getImg(), pSPIn->getSize(), 1, pdblMult, pdblMultImg);
829                     add(pSPOut->get(), pSPOut->getImg(), (long long)iSize, pdblMult, pdblMultImg, pSPOut->get(), pSPOut->getImg());
830                     delete[] pdblMultImg;
831                 }
832
833                 delete[] pdblMult;
834             }//for(int iRow2 = 0 ; iRow2 < _pDouble->getRows() ; iRow2++)
835         }//for(int iCol2 = 0 ; iCol2 < _pDouble->getCols() ; iCol2++)
836     }//for(int iRow1 = 0 ; iRow1 < _pPoly->getRows() ; iRow1++)
837
838     (*_pPolyOut)->updateRank();
839     return 0;
840 }
841
842 int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
843 {
844     bool bComplex1  = _pPoly1->isComplex();
845     bool bComplex2  = _pPoly2->isComplex();
846
847     if (_pPoly1->isScalar() && _pPoly2->isScalar())
848     {
849         //poly1(0) * poly2(0)
850         int iRank = _pPoly1->get(0)->getRank() + _pPoly2->get(0)->getRank();
851         (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), 1, 1, &iRank);
852         if (bComplex1 || bComplex2)
853         {
854             (*_pPolyOut)->setComplex(true);
855         }
856
857         if (bComplex1 == false && bComplex2 == false)
858         {
859             SinglePoly *pPoly1  = _pPoly1->get(0);
860             SinglePoly *pPoly2  = _pPoly2->get(0);
861             SinglePoly *pPolyOut = (*_pPolyOut)->get(0);
862
863             pPolyOut->setZeros();
864
865             iMultiScilabPolynomByScilabPolynom(
866                 pPoly1->get(), pPoly1->getSize(),
867                 pPoly2->get(), pPoly2->getSize(),
868                 pPolyOut->get(), pPolyOut->getSize());
869         }
870         else if (bComplex1 == false && bComplex2 == true)
871         {
872             SinglePoly *pPoly1  = _pPoly1->get(0);
873             SinglePoly *pPoly2  = _pPoly2->get(0);
874             SinglePoly *pPolyOut = (*_pPolyOut)->get(0);
875
876             pPolyOut->setZeros();
877
878             iMultiScilabPolynomByComplexPoly(
879                 pPoly1->get(), pPoly1->getSize(),
880                 pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
881                 pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
882         }
883         else if (bComplex1 == true && bComplex2 == false)
884         {
885             SinglePoly *pPoly1  = _pPoly1->get(0);
886             SinglePoly *pPoly2  = _pPoly2->get(0);
887             SinglePoly *pPolyOut = (*_pPolyOut)->get(0);
888
889             pPolyOut->setZeros();
890
891             iMultiComplexPolyByScilabPolynom(
892                 pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
893                 pPoly2->get(), pPoly2->getSize(),
894                 pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
895         }
896         else if (bComplex1 == true && bComplex2 == true)
897         {
898             SinglePoly *pPoly1   = _pPoly1->get(0);
899             SinglePoly *pPoly2   = _pPoly2->get(0);
900             SinglePoly *pPolyOut  = (*_pPolyOut)->get(0);
901
902             pPolyOut->setZeros();
903
904             iMultiComplexPolyByComplexPoly(
905                 pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
906                 pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
907                 pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
908         }
909
910         (*_pPolyOut)->updateRank();
911         return 0;
912     }
913
914     if (_pPoly1->isScalar())
915     {
916         //poly1(0) * poly2(n)
917         int* piRank = new int[_pPoly2->getSize()];
918         for (int i = 0 ; i < _pPoly2->getSize() ; i++)
919         {
920             piRank[i] = _pPoly1->get(0)->getRank() + _pPoly2->get(i)->getRank();
921         }
922
923         (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly2->getDims(), _pPoly2->getDimsArray(), piRank);
924         if (bComplex1 || bComplex2)
925         {
926             (*_pPolyOut)->setComplex(true);
927         }
928         delete[] piRank;
929
930
931         SinglePoly *pPoly1  = _pPoly1->get(0);
932         if (bComplex1 == false && bComplex2 == false)
933         {
934             for (int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
935             {
936                 SinglePoly *pPoly2  = _pPoly2->get(iPoly);
937                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
938
939                 pPolyOut->setZeros();
940
941                 iMultiScilabPolynomByScilabPolynom(
942                     pPoly1->get(), pPoly1->getSize(),
943                     pPoly2->get(), pPoly2->getSize(),
944                     pPolyOut->get(), pPolyOut->getSize());
945             }
946         }
947         else if (bComplex1 == false && bComplex2 == true)
948         {
949             for (int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
950             {
951                 SinglePoly *pPoly2  = _pPoly2->get(iPoly);
952                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
953
954                 pPolyOut->setZeros();
955
956                 iMultiScilabPolynomByComplexPoly(
957                     pPoly1->get(), pPoly1->getSize(),
958                     pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
959                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
960             }
961         }
962         else if (bComplex1 == true && bComplex2 == false)
963         {
964             for (int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
965             {
966                 SinglePoly *pPoly2  = _pPoly2->get(iPoly);
967                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
968
969                 pPolyOut->setZeros();
970
971                 iMultiComplexPolyByScilabPolynom(
972                     pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
973                     pPoly2->get(), pPoly2->getSize(),
974                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
975             }
976         }
977         else if (bComplex1 == true && bComplex2 == true)
978         {
979             for (int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
980             {
981                 SinglePoly *pPoly2   = _pPoly2->get(iPoly);
982                 SinglePoly *pPolyOut  = (*_pPolyOut)->get(iPoly);
983
984                 pPolyOut->setZeros();
985
986                 iMultiComplexPolyByComplexPoly(
987                     pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
988                     pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
989                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
990             }
991         }
992
993         (*_pPolyOut)->updateRank();
994         return 0;
995     }
996
997     if (_pPoly2->isScalar())
998     {
999         //poly1(n) * poly2(0)
1000         int* piRank = new int[_pPoly1->getSize()];
1001         for (int i = 0 ; i < _pPoly1->getSize() ; i++)
1002         {
1003             piRank[i] = _pPoly2->get(0)->getRank() + _pPoly1->get(i)->getRank();
1004         }
1005
1006         (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly1->getDims(), _pPoly1->getDimsArray(), piRank);
1007         if (bComplex1 || bComplex2)
1008         {
1009             (*_pPolyOut)->setComplex(true);
1010         }
1011         delete[] piRank;
1012
1013         SinglePoly *pPoly2  = _pPoly2->get(0);
1014         if (bComplex1 == false && bComplex2 == false)
1015         {
1016             for (int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
1017             {
1018                 SinglePoly *pPoly1  = _pPoly1->get(iPoly);
1019                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
1020
1021                 pPolyOut->setZeros();
1022
1023                 iMultiScilabPolynomByScilabPolynom(
1024                     pPoly1->get(), pPoly1->getSize(),
1025                     pPoly2->get(), pPoly2->getSize(),
1026                     pPolyOut->get(), pPolyOut->getSize());
1027             }
1028         }
1029         else if (bComplex1 == false && bComplex2 == true)
1030         {
1031             for (int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
1032             {
1033                 SinglePoly *pPoly1  = _pPoly1->get(iPoly);
1034                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
1035
1036                 pPolyOut->setZeros();
1037
1038                 iMultiScilabPolynomByComplexPoly(
1039                     pPoly1->get(), pPoly1->getSize(),
1040                     pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
1041                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
1042             }
1043         }
1044         else if (bComplex1 == true && bComplex2 == false)
1045         {
1046             for (int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
1047             {
1048                 SinglePoly *pPoly1  = _pPoly1->get(iPoly);
1049                 SinglePoly *pPolyOut = (*_pPolyOut)->get(iPoly);
1050
1051                 pPolyOut->setZeros();
1052
1053                 iMultiComplexPolyByScilabPolynom(
1054                     pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
1055                     pPoly2->get(), pPoly2->getSize(),
1056                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
1057             }
1058         }
1059         else if (bComplex1 == true && bComplex2 == true)
1060         {
1061             for (int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
1062             {
1063                 SinglePoly *pPoly1   = _pPoly1->get(iPoly);
1064                 SinglePoly *pPolyOut  = (*_pPolyOut)->get(iPoly);
1065
1066                 pPolyOut->setZeros();
1067
1068                 iMultiComplexPolyByComplexPoly(
1069                     pPoly1->get(), pPoly1->getImg(), pPoly1->getSize(),
1070                     pPoly2->get(), pPoly2->getImg(), pPoly2->getSize(),
1071                     pPolyOut->get(), pPolyOut->getImg(), pPolyOut->getSize());
1072             }
1073         }
1074
1075         (*_pPolyOut)->updateRank();
1076         return 0;
1077     }
1078
1079     if (_pPoly1->getDims() > 2 || _pPoly2->getDims() > 2 || _pPoly1->getCols() != _pPoly2->getRows())
1080     {
1081         return 1;
1082     }
1083
1084     // matrix by matrix
1085     int* piRank = new int[_pPoly1->getRows() * _pPoly2->getCols()];
1086     int iMaxRank = _pPoly1->getMaxRank() + _pPoly2->getMaxRank();
1087     for (int i = 0 ; i < _pPoly1->getRows() * _pPoly2->getCols() ; i++)
1088     {
1089         piRank[i] = iMaxRank;
1090     }
1091
1092     (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly1->getRows(), _pPoly2->getCols(), piRank);
1093     if (bComplex1 || bComplex2)
1094     {
1095         (*_pPolyOut)->setComplex(true);
1096     }
1097
1098     delete[] piRank;
1099
1100
1101     if (bComplex1 == false && bComplex2 == false)
1102     {
1103         double *pReal = NULL;
1104         SinglePoly *pTemp  = new SinglePoly(&pReal, (*_pPolyOut)->getMaxRank());
1105
1106         for (int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1107         {
1108             for (int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1109             {
1110                 SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1111                 pResult->setZeros();
1112
1113                 for (int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1114                 {
1115                     SinglePoly *pL   = _pPoly1->get(iRow, iCommon);
1116                     SinglePoly *pR   = _pPoly2->get(iCommon, iCol);
1117
1118                     pTemp->setZeros();
1119
1120                     iMultiScilabPolynomByScilabPolynom(
1121                         pL->get(), pL->getSize(),
1122                         pR->get(), pR->getSize(),
1123                         pTemp->get(), pL->getRank() + pR->getRank() + 1);
1124
1125                     iAddScilabPolynomToScilabPolynom(
1126                         pResult->get(), pResult->getSize(),
1127                         pTemp->get(), pResult->getSize(),
1128                         pResult->get(), pResult->getSize());
1129                 }
1130             }
1131         }
1132     }
1133     else if (bComplex1 == false && bComplex2 == true)
1134     {
1135         double *pReal = NULL;
1136         double *pImg = NULL;
1137         SinglePoly *pTemp  = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1138
1139         for (int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1140         {
1141             for (int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1142             {
1143                 SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1144                 pResult->setZeros();
1145
1146                 for (int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1147                 {
1148                     SinglePoly *pL   = _pPoly1->get(iRow, iCommon);
1149                     SinglePoly *pR   = _pPoly2->get(iCommon, iCol);
1150
1151                     pTemp->setZeros();
1152
1153                     iMultiScilabPolynomByComplexPoly(
1154                         pL->get(), pL->getSize(),
1155                         pR->get(), pR->getImg(), pR->getSize(),
1156                         pTemp->get(), pTemp->getImg(), pL->getRank() + pR->getRank() + 1);
1157
1158                     iAddComplexPolyToComplexPoly(
1159                         pResult->get(), pResult->getImg(), pResult->getSize(),
1160                         pTemp->get(), pTemp->getImg(), pResult->getSize(),
1161                         pResult->get(), pResult->getImg(), pResult->getSize());
1162                 }
1163             }
1164         }
1165     }
1166     else if (bComplex1 == true && bComplex2 == false)
1167     {
1168         double *pReal = NULL;
1169         double *pImg = NULL;
1170         SinglePoly *pTemp  = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1171
1172         for (int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1173         {
1174             for (int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1175             {
1176                 SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1177                 pResult->setZeros();
1178
1179                 for (int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1180                 {
1181                     SinglePoly *pL   = _pPoly1->get(iRow, iCommon);
1182                     SinglePoly *pR   = _pPoly2->get(iCommon, iCol);
1183
1184                     pTemp->setZeros();
1185
1186                     iMultiScilabPolynomByComplexPoly(
1187                         pR->get(), pR->getSize(),
1188                         pL->get(), pL->getImg(), pL->getSize(),
1189                         pTemp->get(), pTemp->getImg(), pL->getRank() + pR->getRank() + 1);
1190
1191                     iAddComplexPolyToComplexPoly(
1192                         pResult->get(), pResult->getImg(), pResult->getSize(),
1193                         pTemp->get(), pTemp->getImg(), pResult->getSize(),
1194                         pResult->get(), pResult->getImg(), pResult->getSize());
1195                 }
1196             }
1197         }
1198     }
1199     else if (bComplex1 == true && bComplex2 == true)
1200     {
1201         double *pReal = NULL;
1202         double *pImg = NULL;
1203         SinglePoly *pTemp  = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1204
1205         for (int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1206         {
1207             for (int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1208             {
1209                 SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1210                 pResult->setZeros();
1211
1212                 for (int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1213                 {
1214                     SinglePoly *pL   = _pPoly1->get(iRow, iCommon);
1215                     SinglePoly *pR   = _pPoly2->get(iCommon, iCol);
1216
1217                     pTemp->setZeros();
1218
1219                     iMultiComplexPolyByComplexPoly(
1220                         pL->get(), pL->getImg(), pL->getSize(),
1221                         pR->get(), pR->getImg(), pR->getSize(),
1222                         pTemp->get(), pTemp->getImg(), pL->getRank() + pR->getRank() + 1);
1223
1224                     iAddComplexPolyToComplexPoly(
1225                         pResult->get(), pResult->getImg(), pResult->getSize(),
1226                         pTemp->get(), pTemp->getImg(), pResult->getSize(),
1227                         pResult->get(), pResult->getImg(), pResult->getSize());
1228                 }
1229             }
1230         }
1231     }
1232     (*_pPolyOut)->updateRank();
1233
1234     return 0;
1235 }
1236
1237 int MultiplySparseBySparse(Sparse* _pSparse1, Sparse* _pSparse2, Sparse** _pSparseOut)
1238 {
1239     if (_pSparse1->isScalar())
1240     {
1241         //scalar * sp
1242         Double* pDbl = NULL;
1243         if (_pSparse1->isComplex())
1244         {
1245             std::complex<double> dbl = _pSparse1->getImg(0, 0);
1246             pDbl = new Double(dbl.real(), dbl.imag());
1247         }
1248         else
1249         {
1250             pDbl = new Double(_pSparse1->get(0, 0));
1251         }
1252
1253         MultiplyDoubleBySparse(pDbl, _pSparse2, (GenericType**)_pSparseOut);
1254         delete pDbl;
1255         return 0;
1256     }
1257
1258     if (_pSparse2->isScalar())
1259     {
1260         //sp * scalar
1261         Double* pDbl = NULL;
1262         if (_pSparse2->isComplex())
1263         {
1264             std::complex<double> dbl = _pSparse2->getImg(0, 0);
1265             pDbl = new Double(dbl.real(), dbl.imag());
1266         }
1267         else
1268         {
1269             pDbl = new Double(_pSparse2->get(0, 0));
1270         }
1271
1272         MultiplySparseByDouble(_pSparse1, pDbl, (GenericType**)_pSparseOut);
1273         delete pDbl;
1274         return 0;
1275     }
1276
1277     if (_pSparse1->getCols() != _pSparse2->getRows())
1278     {
1279         return 1;
1280     }
1281
1282     *_pSparseOut = _pSparse1->multiply(*_pSparse2);
1283     return 0;
1284 }
1285
1286 int MultiplyDoubleBySparse(Double* _pDouble, Sparse *_pSparse, GenericType** _pOut)
1287 {
1288     //D * SP
1289     if (_pDouble->isScalar())
1290     {
1291         //d * SP -> SP
1292         Sparse* pOut = NULL;
1293         if (_pDouble->isComplex())
1294         {
1295             std::complex<double> dbl(_pDouble->get(0), _pDouble->getImg(0));
1296             pOut = _pSparse->multiply(dbl);
1297         }
1298         else
1299         {
1300             pOut = _pSparse->multiply(_pDouble->get(0));
1301         }
1302         *_pOut = pOut;
1303         return 0;
1304     }
1305
1306     if (_pSparse->isScalar())
1307     {
1308         //D * sp -> D .* d
1309         Double* pD = NULL;
1310
1311         if (_pSparse->isComplex())
1312         {
1313             std::complex<double> dbl(_pSparse->getImg(0, 0));
1314             pD = new Double(dbl.real(), dbl.imag());
1315         }
1316         else
1317         {
1318             pD = new Double(_pSparse->get(0, 0));
1319         }
1320
1321         InternalType* pIT = GenericDotTimes(_pDouble, pD);
1322         *_pOut = pIT->getAs<GenericType>();
1323         delete pD;
1324         return 0;
1325     }
1326
1327     if (_pDouble->getCols() != _pSparse->getRows())
1328     {
1329         return 1;
1330     }
1331
1332     //try to be smart and only compute for non zero values
1333
1334     //get some information
1335     int iNonZeros = static_cast<int>(_pSparse->nonZeros());
1336     int* pRows = new int[iNonZeros * 2];
1337     _pSparse->outputRowCol(pRows);
1338     int* pCols = pRows + iNonZeros;
1339     double* pValR = new double[iNonZeros];
1340     double* pValI = new double[iNonZeros];
1341     _pSparse->outputValues(pValR, pValI);
1342
1343     Double* pOut = new Double(_pDouble->getRows(), _pSparse->getCols(), _pDouble->isComplex() | _pSparse->isComplex());
1344     pOut->setZeros();
1345
1346     if (_pDouble->isComplex() == false && _pSparse->isComplex() == false)
1347     {
1348         for (int i = 0 ; i < iNonZeros ; i++)
1349         {
1350             int iRow = static_cast<int>(pRows[i]) - 1;
1351             int iCol = static_cast<int>(pCols[i]) - 1;
1352             double dbl = pValR[i];
1353
1354             for (int j = 0 ; j < _pDouble->getRows() ; j++)
1355             {
1356                 double dblVal = _pDouble->get(j, iRow) * dbl;
1357                 pOut->set(j, iCol, pOut->get(j, iCol) + dblVal);
1358             }
1359         }
1360     }
1361     else if (_pDouble->isComplex() == false && _pSparse->isComplex() == true)
1362     {
1363         //a * (b ci) -> ab ac
1364         for (int i = 0 ; i < iNonZeros ; i++)
1365         {
1366             int iRow = static_cast<int>(pRows[i]) - 1;
1367             int iCol = static_cast<int>(pCols[i]) - 1;
1368             double dblR = pValR[i];
1369             double dblI = pValI[i];
1370
1371             for (int j = 0 ; j < _pDouble->getRows() ; j++)
1372             {
1373                 double dblValR = _pDouble->get(j, iRow) * dblR;
1374                 double dblValI = _pDouble->get(j, iRow) * dblI;
1375                 pOut->set(j, iCol, pOut->get(j, iCol) + dblValR);
1376                 pOut->setImg(j, iCol, pOut->getImg(j, iCol) + dblValI);
1377             }
1378         }
1379     }
1380     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == false)
1381     {
1382         //(a bi) * c -> ac + bc
1383         for (int i = 0 ; i < iNonZeros ; i++)
1384         {
1385             int iRow = static_cast<int>(pRows[i]) - 1;
1386             int iCol = static_cast<int>(pCols[i]) - 1;
1387             double dblR = pValR[i];
1388
1389             for (int j = 0 ; j < _pDouble->getRows() ; j++)
1390             {
1391                 double dblValR = _pDouble->get(j, iRow) * dblR;
1392                 double dblValI = _pDouble->getImg(j, iRow) * dblR;
1393                 pOut->set(j, iCol, pOut->get(j, iCol) + dblValR);
1394                 pOut->setImg(j, iCol, pOut->getImg(j, iCol) + dblValI);
1395             }
1396         }
1397     }
1398     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == true)
1399     {
1400         for (int i = 0 ; i < iNonZeros ; i++)
1401         {
1402             int iRow = static_cast<int>(pRows[i]) - 1;
1403             int iCol = static_cast<int>(pCols[i]) - 1;
1404             double dblR = pValR[i];
1405             double dblI = pValI[i];
1406
1407             for (int j = 0 ; j < _pDouble->getRows() ; j++)
1408             {
1409                 double dblValR = _pDouble->get(j, iRow) * dblR - _pDouble->getImg(j, iRow) * dblI;
1410                 double dblValI = _pDouble->get(j, iRow) * dblI + _pDouble->getImg(j, iRow) * dblR;
1411                 pOut->set(j, iCol, pOut->get(j, iCol) + dblValR);
1412                 pOut->setImg(j, iCol, pOut->getImg(j, iCol) + dblValI);
1413             }
1414         }
1415     }
1416
1417     *_pOut = pOut;
1418     delete[] pRows;
1419     delete[] pValR;
1420     delete[] pValI;
1421
1422     return 0;
1423 }
1424
1425 int MultiplySparseByDouble(Sparse *_pSparse, Double*_pDouble, GenericType** _pOut)
1426 {
1427     if (_pDouble->isScalar())
1428     {
1429         //SP * d -> SP
1430         Sparse* pOut = NULL;
1431         if (_pDouble->isComplex())
1432         {
1433             std::complex<double> dbl(_pDouble->get(0), _pDouble->getImg(0));
1434             pOut = _pSparse->multiply(dbl);
1435         }
1436         else
1437         {
1438             pOut = _pSparse->multiply(_pDouble->get(0));
1439         }
1440         *_pOut = pOut;
1441         return 0;
1442     }
1443
1444     if (_pSparse->isScalar())
1445     {
1446         //D * sp -> D .* d
1447         Double* pD = NULL;
1448
1449         if (_pSparse->isComplex())
1450         {
1451             std::complex<double> dbl(_pSparse->getImg(0, 0));
1452             pD = new Double(dbl.real(), dbl.imag());
1453         }
1454         else
1455         {
1456             pD = new Double(_pSparse->get(0, 0));
1457         }
1458
1459         InternalType* pIT = GenericDotTimes(_pDouble, pD);
1460         *_pOut = pIT->getAs<GenericType>();
1461         delete pD;
1462         return 0;
1463     }
1464
1465     if (_pSparse->getCols() != _pDouble->getRows())
1466     {
1467         return 1;
1468     }
1469
1470     //try to be smart and only compute for non zero values
1471
1472     //get some information
1473     int iNonZeros = static_cast<int>(_pSparse->nonZeros());
1474     int* pRows = new int[iNonZeros * 2];
1475     _pSparse->outputRowCol(pRows);
1476     int* pCols = pRows + iNonZeros;
1477     double* pValR = new double[iNonZeros];
1478     double* pValI = new double[iNonZeros];
1479     _pSparse->outputValues(pValR, pValI);
1480
1481     Double* pOut = new Double(_pSparse->getRows(), _pDouble->getCols(), _pDouble->isComplex() | _pSparse->isComplex());
1482     pOut->setZeros();
1483
1484     if (_pDouble->isComplex() == false && _pSparse->isComplex() == false)
1485     {
1486         for (int i = 0 ; i < iNonZeros ; i++)
1487         {
1488             int iRow    = static_cast<int>(pRows[i]) - 1;
1489             int iCol    = static_cast<int>(pCols[i]) - 1;
1490             double dbl  = pValR[i];
1491
1492             for (int j = 0 ; j < _pDouble->getCols() ; j++)
1493             {
1494                 double dblVal = _pDouble->get(iCol, j) * dbl;
1495                 pOut->set(iRow, j, pOut->get(iRow, j) + dblVal);
1496             }
1497         }
1498     }
1499     else if (_pDouble->isComplex() == false && _pSparse->isComplex() == true)
1500     {
1501         //a * (b ci) -> ab ac
1502         for (int i = 0 ; i < iNonZeros ; i++)
1503         {
1504             int iRow = static_cast<int>(pRows[i]) - 1;
1505             int iCol = static_cast<int>(pCols[i]) - 1;
1506             double dblR = pValR[i];
1507             double dblI = pValI[i];
1508
1509             for (int j = 0 ; j < _pDouble->getCols() ; j++)
1510             {
1511                 double dblValR = _pDouble->get(iCol, j) * dblR;
1512                 double dblValI = _pDouble->get(iCol, j) * dblI;
1513                 pOut->set(iRow, j, pOut->get(iRow, j) + dblValR);
1514                 pOut->setImg(iRow, j, pOut->getImg(iRow, j) + dblValI);
1515             }
1516         }
1517     }
1518     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == false)
1519     {
1520         //(a bi) * c -> ac + bc
1521         for (int i = 0 ; i < iNonZeros ; i++)
1522         {
1523             int iRow = static_cast<int>(pRows[i]) - 1;
1524             int iCol = static_cast<int>(pCols[i]) - 1;
1525             double dblR = pValR[i];
1526
1527             for (int j = 0 ; j < _pDouble->getCols() ; j++)
1528             {
1529                 double dblValR = _pDouble->get(iCol, j) * dblR;
1530                 double dblValI = _pDouble->getImg(iCol, j) * dblR;
1531                 pOut->set(iRow, j, pOut->get(iRow, j) + dblValR);
1532                 pOut->setImg(iRow, j, pOut->getImg(iRow, j) + dblValI);
1533             }
1534         }
1535     }
1536     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == true)
1537     {
1538         for (int i = 0 ; i < iNonZeros ; i++)
1539         {
1540             int iRow = static_cast<int>(pRows[i]) - 1;
1541             int iCol = static_cast<int>(pCols[i]) - 1;
1542             double dblR = pValR[i];
1543             double dblI = pValI[i];
1544
1545             for (int j = 0 ; j < _pDouble->getCols() ; j++)
1546             {
1547                 double dblValR = _pDouble->get(iCol, j) * dblR - _pDouble->getImg(iCol, j) * dblI;
1548                 double dblValI = _pDouble->get(iCol, j) * dblI + _pDouble->getImg(iCol, j) * dblR;
1549                 pOut->set(iRow, j, pOut->get(iRow, j) + dblValR);
1550                 pOut->setImg(iRow, j, pOut->getImg(iRow, j) + dblValI);
1551             }
1552         }
1553     }
1554
1555     *_pOut = pOut;
1556     delete[] pRows;
1557     delete[] pValR;
1558     delete[] pValI;
1559
1560     return 0;
1561 }
1562
1563 int DotMultiplySparseBySparse(Sparse* _pSparse1, Sparse* _pSparse2, Sparse** _pOut)
1564 {
1565     if (_pSparse1->isScalar() || _pSparse2->isScalar())
1566     {
1567         //SP .* sp or sp .* SP
1568         return MultiplySparseBySparse(_pSparse1, _pSparse2, _pOut);
1569     }
1570
1571     if (_pSparse1->getRows() != _pSparse2->getRows() || _pSparse1->getCols() != _pSparse2->getCols())
1572     {
1573         return 1;
1574     }
1575
1576     *_pOut = _pSparse1->dotMultiply(*_pSparse2);
1577
1578     return 0;
1579 }
1580
1581 int DotMultiplyDoubleBySparse(Double* _pDouble, Sparse* _pSparse, GenericType**  _pOut)
1582 {
1583     if (_pDouble->isScalar())
1584     {
1585         return MultiplyDoubleBySparse(_pDouble, _pSparse, _pOut);
1586     }
1587
1588     if (_pSparse->isScalar())
1589     {
1590         return MultiplyDoubleBySparse(_pDouble, _pSparse, _pOut);
1591     }
1592
1593     if (_pSparse->getRows() != _pDouble->getRows() || _pSparse->getCols() != _pDouble->getCols())
1594     {
1595         return 1;
1596     }
1597
1598     Sparse* pOut = new Sparse(_pDouble->getRows(), _pDouble->getCols(), _pSparse->isComplex() || _pDouble->isComplex());
1599     //get some information
1600     int iNonZeros = static_cast<int>(_pSparse->nonZeros());
1601     int* pRows = new int[iNonZeros * 2];
1602     _pSparse->outputRowCol(pRows);
1603     int* pCols = pRows + iNonZeros;
1604
1605     if (_pDouble->isComplex() == false && _pSparse->isComplex() == false)
1606     {
1607         for (int i = 0 ; i < iNonZeros ; i++)
1608         {
1609             int iRow = static_cast<int>(pRows[i]) - 1;
1610             int iCol = static_cast<int>(pCols[i]) - 1;
1611             pOut->set(iRow, iCol, _pSparse->get(iRow, iCol) * _pDouble->get(iRow, iCol));
1612         }
1613     }
1614     else if (_pDouble->isComplex() == false && _pSparse->isComplex() == true)
1615     {
1616         for (int i = 0 ; i < iNonZeros ; i++)
1617         {
1618             int iRow = static_cast<int>(pRows[i]) - 1;
1619             int iCol = static_cast<int>(pCols[i]) - 1;
1620             std::complex<double> dbl = _pSparse->getImg(iRow, iCol);
1621             std::complex<double> newVal(dbl.real() * _pDouble->get(iRow, iCol), dbl.imag() * _pDouble->get(iRow, iCol));
1622             pOut->set(iRow, iCol, newVal);
1623         }
1624     }
1625     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == false)
1626     {
1627         for (int i = 0 ; i < iNonZeros ; i++)
1628         {
1629             int iRow = static_cast<int>(pRows[i]) - 1;
1630             int iCol = static_cast<int>(pCols[i]) - 1;
1631             std::complex<double> dbl = _pSparse->getImg(iRow, iCol);
1632             std::complex<double> newVal(dbl.real() * _pDouble->get(iRow, iCol), dbl.real() * _pDouble->getImg(iRow, iCol));
1633             pOut->set(iRow, iCol, newVal);
1634         }
1635     }
1636     else if (_pDouble->isComplex() == true && _pSparse->isComplex() == true)
1637     {
1638         for (int i = 0 ; i < iNonZeros ; i++)
1639         {
1640             int iRow = static_cast<int>(pRows[i]) - 1;
1641             int iCol = static_cast<int>(pCols[i]) - 1;
1642             std::complex<double> dbl = _pSparse->getImg(iRow, iCol);
1643             double dblR = _pDouble->get(iRow, iCol) * dbl.real() - _pDouble->getImg(iRow, iCol) * dbl.imag();
1644             double dblI = _pDouble->getImg(iRow, iCol) * dbl.real() + _pDouble->get(iRow, iCol) * dbl.imag();
1645
1646             std::complex<double> newVal(dblR, dblI);
1647             pOut->set(iRow, iCol, newVal);
1648         }
1649     }
1650
1651     *_pOut = pOut;
1652     delete[] pRows;
1653
1654     return 0;
1655 }
1656
1657 int DotMultiplySparseByDouble(Sparse* _pSparse, Double* _pDouble, GenericType** _pOut)
1658 {
1659     return DotMultiplyDoubleBySparse(_pDouble, _pSparse, _pOut);
1660 }
1661
1662 int DotMultiplyPolyByDouble(Polynom* _pPoly, Double* _pDouble, Polynom** _pPolyOut)
1663 {
1664     return DotMultiplyDoubleByPoly(_pDouble, _pPoly, _pPolyOut);
1665 }
1666
1667 int DotMultiplyDoubleByPoly(Double* _pDouble, Polynom* _pPoly, Polynom** _pPolyOut)
1668 {
1669     int iSize = _pDouble->getSize();
1670     if (_pDouble->isScalar() == false &&
1671             _pPoly->isScalar() == false &&
1672             iSize != _pPoly->getSize())
1673     {
1674         return 1;
1675     }
1676
1677     int* piRanks = new int[iSize];
1678     memset(piRanks, 0x00, iSize * sizeof(int));
1679     Polynom* pPolyTemp = new Polynom(_pPoly->getVariableName(), _pDouble->getDims(), _pDouble->getDimsArray(), piRanks);
1680     delete[] piRanks;
1681     pPolyTemp->setCoef(_pDouble);
1682     int iErr = DotMultiplyPolyByPoly(pPolyTemp, _pPoly, _pPolyOut);
1683     delete pPolyTemp;
1684     return iErr;
1685 }
1686
1687 int DotMultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
1688 {
1689     if (_pPoly1->isScalar() || _pPoly2->isScalar())
1690     {
1691         return MultiplyPolyByPoly(_pPoly1, _pPoly2, _pPolyOut);
1692     }
1693     else
1694     {
1695         if (_pPoly1->getSize() != _pPoly2->getSize())
1696         {
1697             return 1;
1698         }
1699
1700         int* piRank = new int[_pPoly1->getSize()];
1701         for (int i = 0 ; i < _pPoly1->getSize() ; i++)
1702         {
1703             piRank[i] = _pPoly1->get(i)->getRank() + _pPoly2->get(i)->getRank();
1704         }
1705
1706         (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly1->getDims(), _pPoly1->getDimsArray(), piRank);
1707
1708         if (_pPoly1->isComplex() && _pPoly2->isComplex())
1709         {
1710             (*_pPolyOut)->setComplex(true);
1711             for (int i = 0; i < _pPoly1->getSize(); i++)
1712             {
1713                 SinglePoly *pSP1    = _pPoly1->get(i);
1714                 SinglePoly *pSP2    = _pPoly2->get(i);
1715                 SinglePoly *pSPOut  = (*_pPolyOut)->get(i);
1716
1717                 pSPOut->setZeros();
1718
1719                 iMultiComplexPolyByComplexPoly(
1720                     pSP1->get(), pSP1->getImg(), pSP1->getSize(),
1721                     pSP2->get(), pSP2->getImg(), pSP2->getSize(),
1722                     pSPOut->get(), pSPOut->getImg(), pSPOut->getSize());
1723
1724             }
1725         }
1726         else if (_pPoly1->isComplex())
1727         {
1728             (*_pPolyOut)->setComplex(true);
1729             for (int i = 0; i < _pPoly1->getSize(); i++)
1730             {
1731                 SinglePoly *pSP1   = _pPoly1->get(i);
1732                 SinglePoly *pSP2   = _pPoly2->get(i);
1733                 SinglePoly *pSPOut = (*_pPolyOut)->get(i);
1734
1735                 pSPOut->setZeros();
1736
1737                 iMultiComplexPolyByScilabPolynom(
1738                     pSP1->get(), pSP1->getImg(), pSP1->getSize(),
1739                     pSP2->get(), pSP2->getSize(),
1740                     pSPOut->get(), pSPOut->getImg(), pSPOut->getSize());
1741             }
1742         }
1743         else if (_pPoly2->isComplex())
1744         {
1745             (*_pPolyOut)->setComplex(true);
1746             for (int i = 0; i < _pPoly1->getSize(); i++)
1747             {
1748                 SinglePoly *pSP1   = _pPoly1->get(i);
1749                 SinglePoly *pSP2   = _pPoly2->get(i);
1750                 SinglePoly *pSPOut = (*_pPolyOut)->get(i);
1751
1752                 pSPOut->setZeros();
1753
1754                 iMultiScilabPolynomByComplexPoly(
1755                     pSP1->get(), pSP1->getSize(),
1756                     pSP2->get(), pSP2->getImg(), pSP2->getSize(),
1757                     pSPOut->get(), pSPOut->getImg(), pSPOut->getSize());
1758             }
1759         }
1760         else
1761         {
1762             for (int i = 0; i < _pPoly1->getSize(); i++)
1763             {
1764                 SinglePoly *pSP1   = _pPoly1->get(i);
1765                 SinglePoly *pSP2   = _pPoly2->get(i);
1766                 SinglePoly *pSPOut = (*_pPolyOut)->get(i);
1767
1768                 pSPOut->setZeros();
1769
1770                 iMultiScilabPolynomByScilabPolynom(
1771                     pSP1->get(), pSP1->getSize(),
1772                     pSP2->get(), pSP2->getSize(),
1773                     pSPOut->get(), pSPOut->getSize());
1774             }
1775         }
1776     }
1777
1778     return 0;
1779 }