6a979ce3875c24bbbdd5620ad009ba8bacfb64a5
[scilab.git] / scilab / modules / operations / src / cpp / 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 }
28
29 using namespace types;
30
31 InternalType *GenericDotTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
32 {
33     InternalType *pResult = NULL;
34     GenericType::RealType TypeL = _pLeftOperand->getType();
35     GenericType::RealType TypeR = _pRightOperand->getType();
36
37     /*
38     ** DOUBLE .* DOUBLE
39     */
40     if(TypeL == GenericType::RealDouble && TypeR == GenericType::RealDouble)
41     {
42         Double *pL                      = _pLeftOperand->getAs<Double>();
43         Double *pR                      = _pRightOperand->getAs<Double>();
44
45
46         int iResult = DotMultiplyDoubleByDouble(pL, pR, (Double**)&pResult);
47         if(iResult)
48         {
49             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
50         }
51
52         return pResult;
53     }
54
55     /*
56     ** Default case : Return NULL will Call Overloading.
57     */
58     return NULL;
59
60 }
61
62 InternalType *GenericTimes(InternalType *_pLeftOperand, InternalType *_pRightOperand)
63 {
64     InternalType *pResult = NULL;
65     GenericType::RealType TypeL = _pLeftOperand->getType();
66     GenericType::RealType TypeR = _pRightOperand->getType();
67
68     /*
69     ** DOUBLE * DOUBLE
70     */
71     if(TypeL == GenericType::RealDouble && TypeR == GenericType::RealDouble)
72     {
73         Double *pL                      = _pLeftOperand->getAs<Double>();
74         Double *pR                      = _pRightOperand->getAs<Double>();
75
76         int iResult = MultiplyDoubleByDouble(pL, pR, (Double**)&pResult);
77         if(iResult)
78         {
79             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
80         }
81
82         return pResult;
83     }
84
85     /*
86     ** DOUBLE * POLY
87     */
88     else if(TypeL == InternalType::RealDouble && TypeR == InternalType::RealPoly)
89     {
90         Double *pL                      = _pLeftOperand->getAs<Double>();
91         Polynom *pR         = _pRightOperand->getAs<types::Polynom>();
92
93         int iResult = MultiplyDoubleByPoly(pL, pR, (Polynom**)&pResult);
94
95         if(iResult)
96         {
97             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
98         }
99
100         return pResult;
101     }
102
103     /*
104     ** POLY * DOUBLE
105     */
106     else if(TypeL == InternalType::RealPoly && TypeR == InternalType::RealDouble)
107     {
108         Polynom *pL          = _pLeftOperand->getAs<types::Polynom>();
109         Double *pR              = _pRightOperand->getAs<Double>();
110
111         int iResult = MultiplyPolyByDouble(pL, pR, (Polynom**)&pResult);
112
113         if(iResult)
114         {
115             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
116         }
117
118         return pResult;
119     }
120
121     /*
122     ** POLY * POLY
123     */
124     else if(TypeL == InternalType::RealPoly && TypeR == InternalType::RealPoly)
125     {
126         Polynom *pL          = _pLeftOperand->getAs<types::Polynom>();
127         Polynom *pR          = _pRightOperand->getAs<types::Polynom>();
128
129         int iResult = MultiplyPolyByPoly(pL, pR, (Polynom**)&pResult);
130
131         if(iResult)
132         {
133             throw ast::ScilabError(_W("Inconsistent row/column dimensions.\n"));
134         }
135
136         return pResult;
137     }
138
139     /*
140     ** Default case : Return NULL will Call Overloading.
141     */
142     return NULL;
143
144 }
145
146 int MultiplyDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double** _pDoubleOut)
147 {
148     bool bComplex1              = _pDouble1->isComplex();
149     bool bComplex2              = _pDouble2->isComplex();
150     bool bScalar1                       = _pDouble1->getRows() == 1 && _pDouble1->getCols() == 1;
151     bool bScalar2                       = _pDouble2->getRows() == 1 && _pDouble2->getCols() == 1;
152
153     int iRowResult      = 0;
154     int iColResult      = 0;
155
156     if(bScalar1)
157     {
158         iRowResult = _pDouble2->getRows();
159         iColResult = _pDouble2->getCols();
160     }
161     else if(bScalar2)
162     {
163         iRowResult = _pDouble1->getRows();
164         iColResult = _pDouble1->getCols();
165     }
166     else if(_pDouble1->getCols() == _pDouble2->getRows())
167     {
168         iRowResult = _pDouble1->getRows();
169         iColResult = _pDouble2->getCols();
170     }
171     else
172     {
173         return 1;
174     }
175
176     //Output variables
177     bool bComplexOut    = bComplex1 || bComplex2;
178     (*_pDoubleOut) = new Double(iRowResult, iColResult, bComplexOut);
179
180     double *pReal                       = (*_pDoubleOut)->getReal();
181     double *pImg                        = (*_pDoubleOut)->getImg();
182
183     if(bScalar1)
184     {//cst*b
185         if(bComplex1 == false && bComplex2 == false)
186         {
187             iMultiRealScalarByRealMatrix(_pDouble1->getReal(0,0), _pDouble2->getReal(), iRowResult, iColResult, pReal);
188         }
189         else if(bComplex1 == false && bComplex2 == true)
190         {
191             iMultiRealScalarByComplexMatrix(_pDouble1->getReal(0,0), _pDouble2->getReal(), _pDouble2->getImg(), iRowResult, iColResult, pReal, pImg);
192         }
193         else if(bComplex1 == true && bComplex2 == false)
194         {
195             iMultiComplexScalarByRealMatrix(_pDouble1->getReal(0,0), _pDouble1->getImg(0,0), _pDouble2->getReal(), iRowResult, iColResult, pReal, pImg);
196         }
197         else //if(bComplex1 == true && bComplex2 == true)
198         {
199             iMultiComplexScalarByComplexMatrix(_pDouble1->getReal(0,0), _pDouble1->getImg(0,0), _pDouble2->getReal(), _pDouble2->getImg(), iRowResult, iColResult, pReal, pImg);
200         }
201     }
202     else if(bScalar2)
203     {//a * cst
204         if(bComplex1 == false && bComplex2 == false)
205         {//Real Matrix by Real Scalar
206             iMultiRealScalarByRealMatrix(_pDouble2->getReal(0,0), _pDouble1->getReal(), iRowResult, iColResult, pReal);
207         }
208         else if(bComplex1 == false && bComplex2 == true)
209         {//Real Matrix by Scalar Complex
210             iMultiComplexScalarByRealMatrix(_pDouble2->getReal(0,0), _pDouble2->getImg(0,0), _pDouble1->getReal(), iRowResult, iColResult, pReal, pImg);
211         }
212         else if(bComplex1 == true && bComplex2 == false)
213         {
214             iMultiRealScalarByComplexMatrix(_pDouble2->getReal(0,0), _pDouble1->getReal(), _pDouble1->getImg(), iRowResult, iColResult, pReal, pImg);
215         }
216         else //if(bComplex1 == true && bComplex2 == true)
217         {
218             iMultiComplexScalarByComplexMatrix(_pDouble2->getReal(0,0), _pDouble2->getImg(0,0), _pDouble1->getReal(), _pDouble1->getImg(), iRowResult, iColResult, pReal, pImg);
219         }
220     }
221     else if(_pDouble1->getCols() == _pDouble2->getRows())
222     {//a * b
223         if(bComplex1 == false && bComplex2 == false)
224         {//Real Matrix by Real Matrix
225             iMultiRealMatrixByRealMatrix(
226                 _pDouble1->getReal(), _pDouble1->getRows(), _pDouble1->getCols(),
227                 _pDouble2->getReal(), _pDouble2->getRows(), _pDouble2->getCols(),
228                 pReal);
229         }
230         else if(bComplex1 == false && bComplex2 == true)
231         {//Real Matrix by Matrix Complex
232             iMultiRealMatrixByComplexMatrix(
233                 _pDouble1->getReal(), _pDouble1->getRows(), _pDouble1->getCols(),
234                 _pDouble2->getReal(), _pDouble2->getImg(), _pDouble2->getRows(), _pDouble2->getCols(),
235                 pReal, pImg);
236         }
237         else if(bComplex1 == true && bComplex2 == false)
238         {//Complex Matrix by Real Matrix
239             iMultiComplexMatrixByRealMatrix(
240                 _pDouble1->getReal(), _pDouble1->getImg(), _pDouble1->getRows(), _pDouble1->getCols(),
241                 _pDouble2->getReal(), _pDouble2->getRows(), _pDouble2->getCols(),
242                 pReal, pImg);
243         }
244         else //if(bComplex1 == true && bComplex2 == true)
245         {//Complex Matrix by Complex Matrix
246             iMultiComplexMatrixByComplexMatrix(
247                 _pDouble1->getReal(), _pDouble1->getImg(), _pDouble1->getRows(), _pDouble1->getCols(),
248                 _pDouble2->getReal(), _pDouble2->getImg(), _pDouble2->getRows(), _pDouble2->getCols(),
249                 pReal, pImg);
250         }
251     }
252     else
253     {
254         return 1;
255     }
256     return 0;
257 }
258
259 int DotMultiplyDoubleByDouble(Double* _pDouble1, Double* _pDouble2, Double**     _pDoubleOut)
260 {
261     bool bComplex1              = _pDouble1->isComplex();
262     bool bComplex2              = _pDouble2->isComplex();
263     bool bScalar1                       = _pDouble1->getRows() == 1 && _pDouble1->getCols() == 1;
264     bool bScalar2                       = _pDouble2->getRows() == 1 && _pDouble2->getCols() == 1;
265
266     int iRowResult      = 0;
267     int iColResult      = 0;
268
269     if(bScalar1)
270     {
271         iRowResult = _pDouble2->getRows();
272         iColResult = _pDouble2->getCols();
273     }
274     else if(bScalar2)
275     {
276         iRowResult = _pDouble1->getRows();
277         iColResult = _pDouble1->getCols();
278     }
279     else if(_pDouble1->getRows() == _pDouble2->getRows() && _pDouble1->getCols() == _pDouble2->getCols())
280     {
281         iRowResult = _pDouble2->getRows();
282         iColResult = _pDouble2->getCols();
283     }
284     else
285     {//Error
286         return 1;
287     }
288
289     bool bComplexOut    = bComplex1 || bComplex2;
290     (*_pDoubleOut) = new Double(iRowResult, iColResult, bComplexOut);
291
292     double *pReal                       = (*_pDoubleOut)->getReal();
293     double *pImg                        = (*_pDoubleOut)->getImg();
294
295     if(bScalar1)
296     {
297         if(bComplex1 == false && bComplex2 == false)
298         {
299             iMultiRealScalarByRealMatrix(_pDouble1->getReal(0,0), _pDouble2->getReal(), iRowResult, iColResult, pReal);
300         }
301         else if(bComplex1 == false && bComplex2 == true)
302         {
303             iMultiRealScalarByComplexMatrix(_pDouble1->getReal(0,0), _pDouble2->getReal(), _pDouble2->getImg(), iRowResult, iColResult, pReal, pImg);
304         }
305         else if(bComplex1 == true && bComplex2 == false)
306         {
307             iMultiComplexScalarByRealMatrix(_pDouble1->getReal(0,0), _pDouble1->getImg(0,0), _pDouble2->getReal(), iRowResult, iColResult, pReal, pImg);
308         }
309         else //if(bComplex1 == true && bComplex2 == true)
310         {
311             iMultiComplexScalarByComplexMatrix(_pDouble1->getReal(0,0), _pDouble1->getImg(0,0), _pDouble2->getReal(), _pDouble2->getImg(), iRowResult, iColResult, pReal, pImg);
312         }
313     }
314     else if(bScalar2)
315     {
316         if(bComplex1 == false && bComplex2 == false)
317         {//Real Matrix by Real Scalar
318             iMultiRealScalarByRealMatrix(_pDouble2->getReal(0,0), _pDouble1->getReal(), iRowResult, iColResult, pReal);
319         }
320         else if(bComplex1 == false && bComplex2 == true)
321         {//Real Matrix by Scalar Complex
322             iMultiComplexScalarByRealMatrix(_pDouble2->getReal(0,0), _pDouble2->getImg(0,0), _pDouble1->getReal(), iRowResult, iColResult, pReal, pImg);
323         }
324         else if(bComplex1 == true && bComplex2 == false)
325         {
326             iMultiRealScalarByComplexMatrix(_pDouble2->getReal(0,0), _pDouble1->getReal(), _pDouble1->getImg(), iRowResult, iColResult, pReal, pImg);
327         }
328         else //if(bComplex1 == true && bComplex2 == true)
329         {
330             iMultiComplexScalarByComplexMatrix(_pDouble2->getReal(0,0), _pDouble2->getImg(0,0), _pDouble1->getReal(), _pDouble1->getImg(), iRowResult, iColResult, pReal, pImg);
331         }
332     }
333     else
334     {//multiply element wise element
335         if(bComplex1 == false && bComplex2 == false)
336         {
337             iDotMultiplyRealMatrixByRealMatrix(_pDouble1->getReal(), _pDouble2->getReal(), pReal, iRowResult, iColResult);
338         }
339         else if(bComplex1 == false && bComplex2 == true)
340         {
341             iDotMultiplyRealMatrixByComplexMatrix(_pDouble1->getReal(), _pDouble2->getReal(), _pDouble2->getImg(), pReal, pImg, iRowResult, iColResult);
342         }
343         else if(bComplex1 == true && bComplex2 == false)
344         {
345             iDotMultiplyComplexMatrixByRealMatrix(_pDouble1->getReal(), _pDouble1->getImg(), _pDouble2->getReal(), pReal, pImg, iRowResult, iColResult);
346         }
347         else //if(bComplex1 == true && bComplex2 == true)
348         {
349             iDotMultiplyComplexMatrixByComplexMatrix(_pDouble1->getReal(), _pDouble1->getImg(), _pDouble2->getReal(), _pDouble2->getImg(), pReal, pImg, iRowResult, iColResult);
350         }
351     }
352
353     return 0;
354 }
355 int MultiplyDoubleByPoly(Double* _pDouble, Polynom* _pPoly, Polynom** _pPolyOut)
356 {
357     bool bComplex1      = _pDouble->isComplex();
358     bool bComplex2      = _pPoly->isComplex();
359     bool bScalar1               = _pDouble->getRows() == 1 && _pDouble->getCols() == 1;
360     bool bScalar2               = _pPoly->getRows() == 1 && _pPoly->getCols() == 1;
361
362     int iRowResult      = 0;
363     int iColResult      = 0;
364     int *piRank                 = NULL;
365
366     if(bScalar1)
367     {
368         iRowResult = _pPoly->getRows();
369         iColResult = _pPoly->getCols();
370
371         piRank = new int[iRowResult * iColResult];
372         for(int i = 0 ; i < iRowResult * iColResult ; i++)
373         {
374             piRank[i] = _pPoly->get(i)->getRank();
375         }
376     }
377     else if (bScalar2)
378     {
379         iRowResult = _pDouble->getRows();
380         iColResult = _pDouble->getCols();
381
382         piRank = new int[iRowResult * iColResult];
383         for(int i = 0 ; i < iRowResult * iColResult ; i++)
384         {
385             piRank[i] = _pPoly->get(0)->getRank();
386         }
387     }
388     else if(_pDouble->getCols() == _pPoly->getRows())
389     {
390         iRowResult = _pDouble->getRows();
391         iColResult = _pPoly->getCols();
392         piRank = new int[iRowResult * iColResult];
393         for(int i = 0 ; i < iRowResult * iColResult ; i++)
394         {
395             piRank[i] = _pPoly->getMaxRank();
396         }
397     }
398     else
399     {
400         return 1;
401     }
402
403     (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), iRowResult, iColResult, piRank);
404     delete[] piRank;
405     if(bComplex1 || bComplex2)
406     {
407         (*_pPolyOut)->setComplex(true);
408     }
409
410     if(bScalar1)
411     {//cst * p
412         for(int i = 0 ; i < _pPoly->getSize() ; i++)
413         {
414             SinglePoly *pPolyIn                 = _pPoly->get(i);
415             double* pRealIn             = pPolyIn->getCoef()->getReal();
416             double* pImgIn              = pPolyIn->getCoef()->getImg();
417
418             SinglePoly *pPolyOut                = (*_pPolyOut)->get(i);
419             double* pRealOut    = pPolyOut->getCoef()->getReal();
420             double* pImgOut             = pPolyOut->getCoef()->getImg();
421
422             if(bComplex1 == false && bComplex2 == false)
423             {
424                 iMultiRealScalarByRealMatrix(
425                     _pDouble->getReal(0,0),
426                     pRealIn, 1, pPolyIn->getRank(),
427                     pRealOut);
428             }
429             else if(bComplex1 == false && bComplex2 == true)
430             {
431                 iMultiRealScalarByComplexMatrix(
432                     _pDouble->getReal(0,0),
433                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
434                     pRealOut, pImgOut);
435             }
436             else if(bComplex1 == true && bComplex2 == false)
437             {
438                 iMultiComplexScalarByRealMatrix(
439                     _pDouble->getReal(0,0), _pDouble->getImg(0,0),
440                     pRealIn, 1, pPolyIn->getRank(),
441                     pRealOut, pImgOut);
442             }
443             else if(bComplex1 == true && bComplex2 == true)
444             {
445                 iMultiComplexScalarByComplexMatrix(
446                     _pDouble->getReal(0,0), _pDouble->getImg(0,0),
447                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
448                     pRealOut, pImgOut);
449             }
450         }
451     }
452     else if(bScalar2)
453     {
454         double *pDoubleR        = _pDouble->getReal();
455         double *pDoubleI        = _pDouble->getImg();
456
457         SinglePoly *pPolyIn                     = _pPoly->get(0);
458         double* pRealIn         = pPolyIn->getCoef()->getReal();
459         double* pImgIn          = pPolyIn->getCoef()->getImg();
460
461         for(int i = 0 ; i < _pDouble->getSize() ; i++)
462         {
463             SinglePoly *pPolyOut                = (*_pPolyOut)->get(i);
464             double* pRealOut    = pPolyOut->getCoef()->getReal();
465             double* pImgOut             = pPolyOut->getCoef()->getImg();
466
467             if(bComplex1 == false && bComplex2 == false)
468             {
469                 iMultiRealScalarByRealMatrix(
470                     pDoubleR[i],
471                     pRealIn, 1, pPolyIn->getRank(),
472                     pRealOut);
473             }
474             else if(bComplex1 == false && bComplex2 == true)
475             {
476                 iMultiRealScalarByComplexMatrix(
477                     pDoubleR[i],
478                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
479                     pRealOut, pImgOut);
480             }
481             else if(bComplex1 == true && bComplex2 == false)
482             {
483                 iMultiComplexScalarByRealMatrix(
484                     pDoubleR[i], pDoubleI[i],
485                     pRealIn, 1, pPolyIn->getRank(),
486                     pRealOut, pImgOut);
487             }
488             else if(bComplex1 == true && bComplex2 == true)
489             {
490                 iMultiComplexScalarByComplexMatrix(
491                     pDoubleR[i], pDoubleI[i],
492                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
493                     pRealOut, pImgOut);
494             }
495         }
496     }
497     else if(_pDouble->getCols() == _pPoly->getRows())
498     {
499         Double *pCoef   = _pPoly->getCoef();
500         Double *pTemp   = new Double(_pDouble->getRows(), pCoef->getCols(), bComplex1 || bComplex2);
501
502         if(bComplex1 == false && bComplex2 == false)
503         {
504             iMultiRealMatrixByRealMatrix(
505                 _pDouble->getReal(), _pDouble->getRows(), _pDouble->getCols(),
506                 pCoef->getReal(), pCoef->getRows(), pCoef->getCols(),
507                 pTemp->getReal());
508
509         }
510         else if(bComplex1 == false && bComplex2 == true)
511         {
512             iMultiRealMatrixByComplexMatrix(
513                 _pDouble->getReal(), _pDouble->getRows(), _pDouble->getCols(),
514                 pCoef->getReal(), pCoef->getImg(), pCoef->getRows(), pCoef->getCols(),
515                 pTemp->getReal(), pTemp->getImg());
516
517         }
518         else if(bComplex1 == true && bComplex2 == false)
519         {
520             iMultiComplexMatrixByRealMatrix(
521                 _pDouble->getReal(), _pDouble->getImg(), _pDouble->getRows(), _pDouble->getCols(),
522                 pCoef->getReal(), pCoef->getRows(), pCoef->getCols(),
523                 pTemp->getReal(), pTemp->getImg());
524         }
525         else //if(bComplex1 == true && bComplex2 == true)
526         {
527             iMultiComplexMatrixByComplexMatrix(
528                 _pDouble->getReal(), _pDouble->getImg(), _pDouble->getRows(), _pDouble->getCols(),
529                 pCoef->getReal(), pCoef->getImg(), pCoef->getRows(), pCoef->getCols(),
530                 pTemp->getReal(), pTemp->getImg());
531         }
532         (*_pPolyOut)->setCoef(pTemp);
533         delete pTemp;
534     }
535     else
536     {
537         return 1;
538     }
539
540     return 0;
541 }
542
543 int MultiplyPolyByDouble(Polynom* _pPoly, Double* _pDouble, Polynom **_pPolyOut)
544 {
545     bool bComplex1      = _pPoly->isComplex();
546     bool bComplex2      = _pDouble->isComplex();
547     bool bScalar1               = _pPoly->getRows() == 1 && _pPoly->getCols() == 1;
548     bool bScalar2               = _pDouble->getRows() == 1 && _pDouble->getCols() == 1;
549
550     int iRowResult      = 0;
551     int iColResult      = 0;
552     int *piRank                 = NULL;
553
554     if(bScalar1)
555     {
556         iRowResult = _pDouble->getRows();
557         iColResult = _pDouble->getCols();
558
559         piRank = new int[iRowResult * iColResult];
560         for(int i = 0 ; i < iRowResult * iColResult ; i++)
561         {
562             piRank[i] = _pPoly->get(0)->getRank();
563         }
564     }
565     else if (bScalar2)
566     {
567         iRowResult = _pPoly->getRows();
568         iColResult = _pPoly->getCols();
569
570         piRank = new int[iRowResult * iColResult];
571         for(int i = 0 ; i < iRowResult * iColResult ; i++)
572         {
573             piRank[i] = _pPoly->get(i)->getRank();
574         }
575     }
576     else if(_pPoly->getCols() == _pDouble->getRows())
577     {
578         iRowResult = _pPoly->getRows();
579         iColResult = _pDouble->getCols();
580         piRank = new int[iRowResult * iColResult];
581         for(int i = 0 ; i < iRowResult * iColResult ; i++)
582         {
583             piRank[i] = _pPoly->getMaxRank();
584         }
585     }
586     else
587     {
588         return 1;
589     }
590
591     (*_pPolyOut) = new Polynom(_pPoly->getVariableName(), iRowResult, iColResult, piRank);
592     delete[] piRank;
593     if(bComplex1 || bComplex2)
594     {
595         (*_pPolyOut)->setComplex(true);
596     }
597     //Output variables
598     //Polynom *pResult  = NULL;
599     bool bComplexOut            = bComplex1 || bComplex2;
600
601     if(bScalar1)
602     {//p[1] * A
603         double *pDoubleR        = _pDouble->getReal();
604         double *pDoubleI        = _pDouble->getImg();
605
606         SinglePoly *pPolyIn                     = _pPoly->get(0);
607         double* pRealIn         = pPolyIn->getCoef()->getReal();
608         double* pImgIn          = pPolyIn->getCoef()->getImg();
609
610         for(int i = 0 ; i < _pDouble->getSize() ; i++)
611         {
612             SinglePoly *pPolyOut                = (*_pPolyOut)->get(i);
613             double* pRealOut    = pPolyOut->getCoef()->getReal();
614             double* pImgOut             = pPolyOut->getCoef()->getImg();
615
616             if(bComplex1 == false && bComplex2 == false)
617             {
618                 iMultiRealScalarByRealMatrix(
619                     pDoubleR[i],
620                     pRealIn, 1, pPolyIn->getRank(),
621                     pRealOut);
622             }
623             else if(bComplex1 == false && bComplex2 == true)
624             {
625                 iMultiComplexScalarByRealMatrix(
626                     pDoubleR[i], pDoubleI[i],
627                     pRealIn, 1, pPolyIn->getRank(),
628                     pRealOut, pImgOut);
629             }
630             else if(bComplex1 == true && bComplex2 == false)
631             {
632                 iMultiRealScalarByComplexMatrix(
633                     pDoubleR[i],
634                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
635                     pRealOut, pImgOut);
636             }
637             else if(bComplex1 == true && bComplex2 == true)
638             {
639                 iMultiComplexScalarByComplexMatrix(
640                     pDoubleR[i], pDoubleI[i],
641                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
642                     pRealOut, pImgOut);
643             }
644         }
645     }
646     else if(bScalar2)
647     {//p * cst
648         for(int i = 0 ; i < _pPoly->getSize() ; i++)
649         {
650             SinglePoly *pPolyIn                 = _pPoly->get(i);
651             double* pRealIn             = pPolyIn->getCoef()->getReal();
652             double* pImgIn              = pPolyIn->getCoef()->getImg();
653
654             SinglePoly *pPolyOut                = (*_pPolyOut)->get(i);
655             double* pRealOut    = pPolyOut->getCoef()->getReal();
656             double* pImgOut             = pPolyOut->getCoef()->getImg();
657
658             if(bComplex1 == false && bComplex2 == false)
659             {
660                 iMultiRealScalarByRealMatrix(
661                     _pDouble->getReal(0,0),
662                     pRealIn, 1, pPolyIn->getRank(),
663                     pRealOut);
664             }
665             else if(bComplex1 == false && bComplex2 == true)
666             {
667                 iMultiComplexScalarByRealMatrix(
668                     _pDouble->getReal(0,0), _pDouble->getImg(0,0),
669                     pRealIn, 1, pPolyIn->getRank(),
670                     pRealOut, pImgOut);
671             }
672             else if(bComplex1 == true && bComplex2 == false)
673             {
674                 iMultiRealScalarByComplexMatrix(
675                     _pDouble->getReal(0,0),
676                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
677                     pRealOut, pImgOut);
678             }
679             else if(bComplex1 == true && bComplex2 == true)
680             {
681                 iMultiComplexScalarByComplexMatrix(
682                     _pDouble->getReal(0,0), _pDouble->getImg(0,0),
683                     pRealIn, pImgIn, 1, pPolyIn->getRank(),
684                     pRealOut, pImgOut);
685             }
686         }
687     }
688     else if(_pPoly->getCols() == _pDouble->getRows())
689     {
690         //Distribution a la mano par appels a des sous-fonctions ( iMulti...ScalarBy...Scalar ) plus iAdd...To... )
691
692         //for each line of _pPoly
693         for(int iRow1 = 0 ; iRow1 < _pPoly->getRows() ; iRow1++)
694         {//for each col of _pDouble
695             for(int iCol2 = 0 ; iCol2 < _pDouble->getCols() ; iCol2++)
696             {//for each rows of _pDouble / cols of _pPoly
697                 for(int iRow2 = 0 ; iRow2 < _pDouble->getRows() ; iRow2++)
698                 {
699                     Double *pPolyCoef = _pPoly->get(iRow1, iRow2)->getCoef();
700
701                     Double *pDouble = NULL;
702                     if(bComplex2 == false)
703                     {
704                         pDouble = new Double(_pDouble->getReal(iRow2, iCol2));
705                     }
706                     else
707                     {
708                         pDouble = new Double(_pDouble->getReal(iRow2, iCol2), _pDouble->getImg(iRow2, iCol2));
709                     }
710
711                     Double *TimeDouble = NULL; //(pPolyCoef->getRows(), pPolyCoef->getCols(), bComplexOut);
712                     MultiplyDoubleByDouble(pPolyCoef, pDouble, &TimeDouble);
713                     Double *pAddDouble = NULL;
714
715                     //Adjust size to allow vector multiplication
716                     Double* pCoef = (*_pPolyOut)->get(iRow1, iCol2)->getCoef();
717
718                     if(TimeDouble->getRows() > pCoef->getRows())
719                     {
720                         pCoef->resize(TimeDouble->getRows(), pCoef->getCols());
721                     }
722                     else if(TimeDouble->getRows() < pCoef->getRows())
723                     {
724                         TimeDouble->resize(pCoef->getRows(), TimeDouble->getCols());
725                     }
726
727                     if(TimeDouble->getCols() > pCoef->getCols())
728                     {
729                         pCoef->resize(pCoef->getRows(), TimeDouble->getCols());
730                     }
731                     else if(TimeDouble->getCols() < pCoef->getCols())
732                     {
733                         TimeDouble->resize(TimeDouble->getRows(), pCoef->getCols());
734                     }
735
736                     AddDoubleToDouble(TimeDouble, pCoef, &pAddDouble);
737                     (*_pPolyOut)->setCoef(iRow1, iCol2, pAddDouble);
738
739                     delete pAddDouble;
740                     delete pDouble;
741                 }//for(int iRow2 = 0 ; iRow2 < _pDouble->getRows() ; iRow2++)
742             }//for(int iCol2 = 0 ; iCol2 < _pDouble->getCols() ; iCol2++)
743         }//for(int iRow1 = 0 ; iRow1 < _pPoly->getRows() ; iRow1++)
744     }
745     else //Wrong dimensions.
746     {
747         return 1;
748     }
749     return 0;
750 }
751
752 int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
753 {
754     bool bComplex1      = _pPoly1->isComplex();
755     bool bComplex2      = _pPoly2->isComplex();
756     bool bScalar1               = _pPoly1->getRows() == 1 && _pPoly1->getCols() == 1;
757     bool bScalar2               = _pPoly2->getRows() == 1 && _pPoly2->getCols() == 1;
758
759     int iRowResult      = 0;
760     int iColResult      = 0;
761     int *piRank                 = NULL;
762
763     if(_pPoly1->getSize() == 1 && _pPoly2->getSize() == 1)
764     {
765         iRowResult = 1;
766         iColResult = 1;
767
768         piRank = new int[1];
769         piRank[0] = _pPoly1->get(0)->getRank() + _pPoly2->get(0)->getRank() - 1;
770     }
771     else if(_pPoly1->getSize() == 1)
772     {
773         iRowResult = _pPoly2->getRows();
774         iColResult = _pPoly2->getCols();
775
776         piRank = new int[iRowResult * iColResult];
777         for(int i = 0 ; i < iRowResult * iColResult ; i++)
778         {
779             piRank[i] = _pPoly1->get(0)->getRank() + _pPoly2->get(i)->getRank() - 1;
780         }
781     }
782     else if (_pPoly2->getSize() == 1)
783     {
784         iRowResult = _pPoly1->getRows();
785         iColResult = _pPoly1->getCols();
786
787         piRank = new int[iRowResult * iColResult];
788         for(int i = 0 ; i < iRowResult * iColResult ; i++)
789         {
790             piRank[i] = _pPoly2->get(0)->getRank() * _pPoly1->get(i)->getRank();
791         }
792     }
793     else if(_pPoly1->getCols() == _pPoly2->getRows())
794     {
795         iRowResult = _pPoly1->getRows();
796         iColResult = _pPoly2->getCols();
797         piRank = new int[iRowResult * iColResult];
798         for(int i = 0 ; i < iRowResult * iColResult ; i++)
799         {
800             piRank[i] = _pPoly1->getMaxRank() * _pPoly2->getMaxRank();
801         }
802     }
803     else
804     {
805         return 1;
806     }
807
808     (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), iRowResult, iColResult, piRank);
809
810     delete[] piRank;
811
812     if(bComplex1 || bComplex2)
813     {
814         (*_pPolyOut)->setComplex(true);
815     }
816
817     if(bScalar1 && bScalar2)
818     {//poly1(0) * poly2(0)
819         if(bComplex1 == false && bComplex2 == false)
820         {
821             SinglePoly *pPoly1          = _pPoly1->get(0);
822             SinglePoly *pPoly2          = _pPoly2->get(0);
823             SinglePoly *pPolyOut        = (*_pPolyOut)->get(0);
824
825             pPolyOut->getCoef()->setZeros();
826
827             iMultiRealPolyByRealPoly(
828                 pPoly1->getCoef()->getReal(), pPoly1->getRank(),
829                 pPoly2->getCoef()->getReal(), pPoly2->getRank(),
830                 pPolyOut->getCoef()->getReal(), pPolyOut->getRank());
831         }
832         else if(bComplex1 == false && bComplex2 == true)
833         {
834             SinglePoly *pPoly1          = _pPoly1->get(0);
835             SinglePoly *pPoly2          = _pPoly2->get(0);
836             SinglePoly *pPolyOut        = (*_pPolyOut)->get(0);
837
838             pPolyOut->getCoef()->setZeros();
839
840             iMultiRealPolyByComplexPoly(
841                 pPoly1->getCoef()->getReal(), pPoly1->getRank(),
842                 pPoly2->getCoef()->getReal(), pPoly2->getCoef()->getImg(), pPoly2->getRank(),
843                 pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
844         }
845         else if(bComplex1 == true && bComplex2 == false)
846         {
847             SinglePoly *pPoly1          = _pPoly1->get(0);
848             SinglePoly *pPoly2          = _pPoly2->get(0);
849             SinglePoly *pPolyOut        = (*_pPolyOut)->get(0);
850
851             pPolyOut->getCoef()->setZeros();
852
853             iMultiComplexPolyByRealPoly(
854                 pPoly1->getCoef()->getReal(), pPoly1->getCoef()->getImg(), pPoly1->getRank(),
855                 pPoly2->getCoef()->getReal(), pPoly2->getRank(),
856                 pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
857         }
858         else if(bComplex1 == true && bComplex2 == true)
859         {
860             SinglePoly *pPoly1                  = _pPoly1->get(0);
861             SinglePoly *pPoly2                  = _pPoly2->get(0);
862             SinglePoly *pPolyOut                = (*_pPolyOut)->get(0);
863             Double *pCoef1              = pPoly1->getCoef();
864             Double *pCoef2              = pPoly2->getCoef();
865             Double *pCoefOut    = pPolyOut->getCoef();
866
867             pCoefOut->setZeros();
868             iMultiComplexPolyByComplexPoly(
869                 pCoef1->getReal(), pCoef1->getImg(), pPoly1->getRank(),
870                 pCoef2->getReal(), pCoef2->getImg(), pPoly2->getRank(),
871                 pCoefOut->getReal(), pCoefOut->getImg(), pPolyOut->getRank());
872         }
873     }
874     else if(bScalar1)
875     {//poly1(0) * poly2(n)
876         SinglePoly *pPoly1              = _pPoly1->get(0);
877         if(bComplex1 == false && bComplex2 == false)
878         {
879             for(int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
880             {
881                 SinglePoly *pPoly2              = _pPoly2->get(iPoly);
882                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
883
884                 pPolyOut->getCoef()->setZeros();
885
886                 iMultiRealPolyByRealPoly(
887                     pPoly1->getCoef()->getReal(), pPoly1->getRank(),
888                     pPoly2->getCoef()->getReal(), pPoly2->getRank(),
889                     pPolyOut->getCoef()->getReal(), pPolyOut->getRank());
890             }
891         }
892         else if(bComplex1 == false && bComplex2 == true)
893         {
894             for(int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
895             {
896                 SinglePoly *pPoly2              = _pPoly2->get(iPoly);
897                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
898
899                 pPolyOut->getCoef()->setZeros();
900
901                 iMultiRealPolyByComplexPoly(
902                     pPoly1->getCoef()->getReal(), pPoly1->getRank(),
903                     pPoly2->getCoef()->getReal(), pPoly2->getCoef()->getImg(), pPoly2->getRank(),
904                     pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
905             }
906         }
907         else if(bComplex1 == true && bComplex2 == false)
908         {
909             for(int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
910             {
911                 SinglePoly *pPoly2              = _pPoly2->get(iPoly);
912                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
913
914                 pPolyOut->getCoef()->setZeros();
915
916                 iMultiComplexPolyByRealPoly(
917                     pPoly1->getCoef()->getReal(), pPoly1->getCoef()->getImg(), pPoly1->getRank(),
918                     pPoly2->getCoef()->getReal(), pPoly2->getRank(),
919                     pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
920             }
921         }
922         else if(bComplex1 == true && bComplex2 == true)
923         {
924             Double *pCoef1              = pPoly1->getCoef();
925             for(int iPoly = 0 ; iPoly < _pPoly2->getSize() ; iPoly++)
926             {
927                 SinglePoly *pPoly2                      = _pPoly2->get(iPoly);
928                 SinglePoly *pPolyOut            = (*_pPolyOut)->get(iPoly);
929                 Double *pCoef2          = pPoly2->getCoef();
930                 Double *pCoefOut        = pPolyOut->getCoef();
931
932
933                 pCoefOut->setZeros();
934
935                 iMultiComplexPolyByComplexPoly(
936                     pCoef1->getReal(), pCoef1->getImg(), pPoly1->getRank(),
937                     pCoef2->getReal(), pCoef2->getImg(), pPoly2->getRank(),
938                     pCoefOut->getReal(), pCoefOut->getImg(), pPolyOut->getRank());
939             }
940         }
941     }
942     else if(bScalar2)
943     {//poly1(n) * poly2(0)
944         SinglePoly *pPoly2              = _pPoly2->get(0);
945         if(bComplex1 == false && bComplex2 == false)
946         {
947             for(int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
948             {
949                 SinglePoly *pPoly1              = _pPoly1->get(iPoly);
950                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
951
952                 pPolyOut->getCoef()->setZeros();
953
954                 iMultiRealPolyByRealPoly(
955                     pPoly1->getCoef()->getReal(), pPoly1->getRank(),
956                     pPoly2->getCoef()->getReal(), pPoly2->getRank(),
957                     pPolyOut->getCoef()->getReal(), pPolyOut->getRank());
958             }
959         }
960         else if(bComplex1 == false && bComplex2 == true)
961         {
962             for(int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
963             {
964                 SinglePoly *pPoly1              = _pPoly1->get(iPoly);
965                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
966
967                 pPolyOut->getCoef()->setZeros();
968
969                 iMultiRealPolyByComplexPoly(
970                     pPoly1->getCoef()->getReal(), pPoly1->getRank(),
971                     pPoly2->getCoef()->getReal(), pPoly2->getCoef()->getImg(), pPoly2->getRank(),
972                     pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
973             }
974         }
975         else if(bComplex1 == true && bComplex2 == false)
976         {
977             for(int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
978             {
979                 SinglePoly *pPoly1              = _pPoly1->get(iPoly);
980                 SinglePoly *pPolyOut    = (*_pPolyOut)->get(iPoly);
981
982                 pPolyOut->getCoef()->setZeros();
983
984                 iMultiComplexPolyByRealPoly(
985                     pPoly1->getCoef()->getReal(), pPoly1->getCoef()->getImg(), pPoly1->getRank(),
986                     pPoly2->getCoef()->getReal(), pPoly2->getRank(),
987                     pPolyOut->getCoef()->getReal(), pPolyOut->getCoef()->getImg(), pPolyOut->getRank());
988             }
989         }
990         else if(bComplex1 == true && bComplex2 == true)
991         {
992             Double *pCoef2              = pPoly2->getCoef();
993             for(int iPoly = 0 ; iPoly < _pPoly1->getSize() ; iPoly++)
994             {
995                 SinglePoly *pPoly1                      = _pPoly1->get(iPoly);
996                 SinglePoly *pPolyOut            = (*_pPolyOut)->get(iPoly);
997                 Double *pCoef1          = pPoly1->getCoef();
998                 Double *pCoefOut        = pPolyOut->getCoef();
999
1000
1001                 pCoefOut->setZeros();
1002
1003                 iMultiComplexPolyByComplexPoly(
1004                     pCoef1->getReal(), pCoef1->getImg(), pPoly1->getRank(),
1005                     pCoef2->getReal(), pCoef2->getImg(), pPoly2->getRank(),
1006                     pCoefOut->getReal(), pCoefOut->getImg(), pPolyOut->getRank());
1007             }
1008         }
1009     }
1010     else
1011     {// matrix by matrix
1012         if(bComplex1 == false && bComplex2 == false)
1013         {
1014             double *pReal       = NULL;
1015             SinglePoly *pTemp           = new SinglePoly(&pReal, (*_pPolyOut)->getMaxRank());
1016
1017             for(int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1018             {
1019                 for(int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1020                 {
1021                     SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1022                     pResult->getCoef()->setZeros();
1023
1024                     for(int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1025                     {
1026                         SinglePoly *pL                  = _pPoly1->get(iRow, iCommon);
1027                         SinglePoly *pR                  = _pPoly2->get(iCommon, iCol);
1028
1029                         pTemp->getCoef()->setZeros();
1030
1031                         iMultiRealPolyByRealPoly(
1032                             pL->getCoef()->getReal(), pL->getRank(),
1033                             pR->getCoef()->getReal(), pR->getRank(),
1034                             pTemp->getCoef()->getReal(), pL->getRank() + pR->getRank() - 1);
1035
1036                         iAddRealPolyToRealPoly(
1037                             pResult->getCoef()->getReal(), pResult->getRank(),
1038                             pTemp->getCoef()->getReal(), pResult->getRank(),
1039                             pResult->getCoef()->getReal(), pResult->getRank());
1040                     }
1041                 }
1042             }
1043         }
1044         else if(bComplex1 == false && bComplex2 == true)
1045         {
1046             double *pReal       = NULL;
1047             double *pImg        = NULL;
1048             SinglePoly *pTemp           = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1049
1050             for(int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1051             {
1052                 for(int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1053                 {
1054                     SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1055                     pResult->getCoef()->setZeros();
1056
1057                     for(int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1058                     {
1059                         SinglePoly *pL                  = _pPoly1->get(iRow, iCommon);
1060                         SinglePoly *pR                  = _pPoly2->get(iCommon, iCol);
1061
1062                         pTemp->getCoef()->setZeros();
1063
1064                         iMultiRealPolyByComplexPoly(
1065                             pL->getCoef()->getReal(), pL->getRank(),
1066                             pR->getCoef()->getReal(), pR->getCoef()->getImg(), pR->getRank(),
1067                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pL->getRank() + pR->getRank() - 1);
1068
1069                         iAddComplexPolyToComplexPoly(
1070                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank(),
1071                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pResult->getRank(),
1072                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank());
1073                     }
1074                 }
1075             }
1076         }
1077         else if(bComplex1 == true && bComplex2 == false)
1078         {
1079             double *pReal       = NULL;
1080             double *pImg        = NULL;
1081             SinglePoly *pTemp           = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1082
1083             for(int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1084             {
1085                 for(int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1086                 {
1087                     SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1088                     pResult->getCoef()->setZeros();
1089
1090                     for(int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1091                     {
1092                         SinglePoly *pL                  = _pPoly1->get(iRow, iCommon);
1093                         SinglePoly *pR                  = _pPoly2->get(iCommon, iCol);
1094
1095                         pTemp->getCoef()->setZeros();
1096
1097                         iMultiRealPolyByComplexPoly(
1098                             pR->getCoef()->getReal(), pR->getRank(),
1099                             pL->getCoef()->getReal(), pL->getCoef()->getImg(), pL->getRank(),
1100                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pL->getRank() + pR->getRank() - 1);
1101
1102                         iAddComplexPolyToComplexPoly(
1103                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank(),
1104                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pResult->getRank(),
1105                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank());
1106                     }
1107                 }
1108             }
1109         }
1110         else if(bComplex1 == true && bComplex2 == true)
1111         {
1112             double *pReal       = NULL;
1113             double *pImg        = NULL;
1114             SinglePoly *pTemp           = new SinglePoly(&pReal, &pImg, (*_pPolyOut)->getMaxRank());
1115
1116             for(int iRow = 0 ; iRow < _pPoly1->getRows() ; iRow++)
1117             {
1118                 for(int iCol = 0 ; iCol < _pPoly2->getCols() ; iCol++)
1119                 {
1120                     SinglePoly *pResult = (*_pPolyOut)->get(iRow, iCol);
1121                     pResult->getCoef()->setZeros();
1122
1123                     for(int iCommon = 0 ; iCommon < _pPoly1->getCols() ; iCommon++)
1124                     {
1125                         SinglePoly *pL                  = _pPoly1->get(iRow, iCommon);
1126                         SinglePoly *pR                  = _pPoly2->get(iCommon, iCol);
1127
1128                         pTemp->getCoef()->setZeros();
1129
1130                         iMultiComplexPolyByComplexPoly(
1131                             pL->getCoef()->getReal(), pL->getCoef()->getImg(), pL->getRank(),
1132                             pR->getCoef()->getReal(), pR->getCoef()->getImg(), pR->getRank(),
1133                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pL->getRank() + pR->getRank() - 1);
1134
1135                         iAddComplexPolyToComplexPoly(
1136                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank(),
1137                             pTemp->getCoef()->getReal(), pTemp->getCoef()->getImg(), pResult->getRank(),
1138                             pResult->getCoef()->getReal(), pResult->getCoef()->getImg(), pResult->getRank());
1139                     }
1140                 }
1141             }
1142         }
1143     }
1144     return 0; //No Error;
1145 }