5ac4d43615b71cf99c0bc9209e54ed49abd00dca
[scilab.git] / scilab / modules / ast / src / cpp / types / polynom.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 #include <sstream>
17 #include <algorithm>
18 #include "core_math.h"
19 #include "tostring_common.hxx"
20 #include "singlepoly.hxx"
21 #include "polynom.hxx"
22 #include "configvariable.hxx"
23
24 namespace types
25 {
26 Polynom::Polynom()
27 {
28 #ifndef NDEBUG
29     Inspector::addItem(this);
30 #endif
31 }
32
33 Polynom::Polynom(const std::wstring& _szVarName, int _iRows, int _iCols)
34 {
35     int piDims[2]   = {_iRows, _iCols};
36     createPoly(_szVarName, 2, piDims, NULL);
37 }
38
39 Polynom::Polynom(const std::wstring& _szVarName, int _iRows, int _iCols, const int *_piRank)
40 {
41     int piDims[2]   = {_iRows, _iCols};
42     createPoly(_szVarName, 2, piDims, _piRank);
43 }
44
45 Polynom::Polynom(const std::wstring& _szVarName, int _iDims, const int* _piDims)
46 {
47     createPoly(_szVarName, _iDims, _piDims, NULL);
48 }
49
50 Polynom::Polynom(const std::wstring& _szVarName, int _iDims, const int* _piDims, const int *_piRank)
51 {
52     createPoly(_szVarName, _iDims, _piDims, _piRank);
53 }
54
55 Polynom::~Polynom()
56 {
57     if (isDeletable() == true)
58     {
59         deleteAll();
60     }
61 #ifndef NDEBUG
62     Inspector::removeItem(this);
63 #endif
64 }
65
66 bool Polynom::getMemory(long long* _piSize, long long* _piSizePlusType)
67 {
68     *_piSize = 0;
69     for (int i = 0; i<getSize(); i++)
70     {
71         *_piSize += (get(i)->getRank()+1)*sizeof(double);
72     }
73     
74     *_piSize = *_piSize * (isComplex() ? 2 : 1);
75     *_piSizePlusType = *_piSize + getSize()*sizeof(SinglePoly *) + sizeof(*this);
76     return true;
77 }
78
79
80 void Polynom::createPoly(const std::wstring& _szVarName, int _iDims, const int* _piDims, const int *_piRank)
81 {
82     m_szVarName = _szVarName;
83     SinglePoly** pPoly = NULL;
84     create(_piDims, _iDims, &pPoly, NULL);
85
86     if (_piRank)
87     {
88         for (int i = 0 ; i < getSize() ; i++)
89         {
90             double* pReal = NULL;
91             m_pRealData[i] = new SinglePoly(&pReal, _piRank[i]);
92         }
93     }
94 #ifndef NDEBUG
95     Inspector::addItem(this);
96 #endif
97 }
98
99 Polynom* Polynom::set(int _iPos, SinglePoly* _pS)
100 {
101     if (m_pRealData == NULL || _iPos >= m_iSize)
102     {
103         return NULL;
104     }
105
106     typedef Polynom* (Polynom::*set_t)(int, SinglePoly*);
107     Polynom* pIT = checkRef(this, (set_t)&Polynom::set, _iPos, _pS);
108     if (pIT != this)
109     {
110         return pIT;
111     }
112
113     if (m_pRealData[_iPos])
114     {
115         delete m_pRealData[_iPos];
116     }
117
118     m_pRealData[_iPos] = copyValue(_pS);
119
120     bool bComplex = isComplex();
121     if (_pS->isComplex() && bComplex == false)
122     {
123         setComplex(true);
124     }
125     else if (_pS->isComplex() == false && bComplex)
126     {
127         m_pRealData[_iPos]->setComplex(true);
128     }
129
130     return this;
131 }
132
133 Polynom* Polynom::set(int _iRows, int _iCols, SinglePoly* _pS)
134 {
135     return set(_iCols * getRows() + _iRows, _pS);
136 }
137
138 Polynom* Polynom::set(SinglePoly** _pS)
139 {
140     typedef Polynom* (Polynom::*set_t)(SinglePoly**);
141     Polynom* pIT = checkRef(this, (set_t)&Polynom::set, _pS);
142     if (pIT != this)
143     {
144         return pIT;
145     }
146
147     for (int i = 0 ; i < m_iSize ; i++)
148     {
149         set(i, _pS[i]);
150     }
151
152     return this;
153 }
154
155 Polynom* Polynom::setCoef(int _iRows, int _iCols, Double *_pdblCoef)
156 {
157     int piDims[] = {_iRows, _iCols};
158     int iPos = getIndex(piDims);
159     return setCoef(iPos, _pdblCoef);
160 }
161
162 Polynom* Polynom::setCoef(int _iIdx, Double *_pdblCoef)
163 {
164     if (_iIdx > m_iSize)
165     {
166         return NULL;
167     }
168
169     typedef Polynom* (Polynom::*setCoef_t)(int, Double*);
170     Polynom* pIT = checkRef(this, (setCoef_t)&Polynom::setCoef, _iIdx, _pdblCoef);
171     if (pIT != this)
172     {
173         return pIT;
174     }
175
176     /*Get old SinglePoly*/
177     m_pRealData[_iIdx]->setRank(_pdblCoef->getSize() - 1);
178     m_pRealData[_iIdx]->setCoef(_pdblCoef);
179
180     return this;
181 }
182
183 void Polynom::setZeros()
184 {
185     for (int i = 0; i < m_iSize; i++)
186     {
187         m_pRealData[i]->setZeros();
188     }
189 }
190
191 bool Polynom::getSizes(int *_piSizes)
192 {
193     if (_piSizes == NULL || m_pRealData == NULL)
194     {
195         return false;
196     }
197
198     for (int i = 0 ; i < getSize() ; i++)
199     {
200         _piSizes[i] = m_pRealData[i]->getSize();
201     }
202
203     return true;
204 }
205
206 bool Polynom::getRank(int *_piRank)
207 {
208     if (_piRank == NULL || m_pRealData == NULL)
209     {
210         return false;
211     }
212
213     for (int i = 0 ; i < getSize() ; i++)
214     {
215         _piRank[i] = m_pRealData[i]->getRank();
216     }
217
218     return true;
219 }
220
221 void Polynom::whoAmI(void)
222 {
223     std::cout << "types::SinglePoly";
224 }
225
226 std::wstring& Polynom::getVariableName()
227 {
228     return m_szVarName;
229 }
230
231 void Polynom::setVariableName(const std::wstring& _szVarName)
232 {
233     m_szVarName = _szVarName;
234 }
235
236 bool Polynom::isComplex()
237 {
238     if (m_iSize && m_pRealData[0])
239     {
240         return m_pRealData[0]->isComplex();
241     }
242
243     return false;
244 }
245
246 Polynom* Polynom::setComplex(bool _bComplex)
247 {
248     if (_bComplex == isComplex())
249     {
250         return this;
251     }
252
253     typedef Polynom* (Polynom::*setcplx_t)(bool);
254     Polynom* pIT = checkRef(this, (setcplx_t)&Polynom::setComplex, _bComplex);
255     if (pIT != this)
256     {
257         return pIT;
258     }
259
260     for (int i = 0 ; i < getSize() ; i++)
261     {
262         get(i)->setComplex(_bComplex);
263     }
264
265     return this;
266 }
267
268 Polynom* Polynom::clone()
269 {
270     Polynom* pMP = new Polynom(getVariableName(), getDims(), getDimsArray());
271     for (int i = 0 ; i < getSize() ; i++)
272     {
273         pMP->set(i, m_pRealData[i]);
274     }
275
276     return pMP;
277 }
278
279 bool Polynom::transpose(InternalType *& out)
280 {
281     if (isScalar())
282     {
283         out = clone();
284         return true;
285     }
286
287     if (m_iDims == 2)
288     {
289         int piNewDims[2] = {m_piDims[1], m_piDims[0]};
290         Polynom* pPoly = new Polynom(m_szVarName, m_iDims, piNewDims);
291         Transposition::transpose_clone(getRows(), getCols(), m_pRealData, pPoly->get());
292         out = pPoly;
293         return true;
294     }
295
296     return false;
297
298 }
299
300 bool Polynom::adjoint(InternalType *& out)
301 {
302     if (isComplex())
303     {
304         if (m_iDims == 2)
305         {
306             int piNewDims[2] = {m_piDims[1], m_piDims[0]};
307             Polynom* pPoly = new Polynom(m_szVarName, m_iDims, piNewDims);
308             Transposition::adjoint_clone(getRows(), getCols(), m_pRealData, pPoly->get());
309             out = pPoly;
310             return true;
311         }
312         else
313         {
314             return false;
315         }
316     }
317     else
318     {
319         return transpose(out);
320     }
321 }
322
323 Double* Polynom::evaluate(Double* _pdblValue)
324 {
325     double *pR = _pdblValue->getReal();
326     double *pI = _pdblValue->getImg();
327     int iRows  = _pdblValue->getRows();
328     int iCols  = _pdblValue->getCols();
329
330     double *pReturnR = NULL;
331     double *pReturnI = NULL;
332     Double *pReturn  = new Double(getRows() * iRows, getCols() * iCols, &pReturnR, &pReturnI);
333     pReturn->setComplex(_pdblValue->isComplex());
334
335     int i = 0;
336     //all lines of the matrix remplacement
337     for (int iCol = 0 ; iCol < iCols ; iCol++)
338     {
339         for (int iPolyCol = 0 ; iPolyCol < getCols() ; iPolyCol++)
340         {
341             for (int iRow = 0 ; iRow < iRows ; iRow++)
342             {
343                 for (int iPolyRow = 0 ; iPolyRow < getRows() ; iPolyRow++)
344                 {
345                     double OutR = 0;
346                     double OutI = 0;
347
348                     SinglePoly *pPoly = get(iPolyRow, iPolyCol);
349                     if (pReturn->isComplex())
350                     {
351                         pPoly->evaluate(pR[iCol * iRows + iRow], pI[iCol * iRows + iRow], &OutR, &OutI);
352                         pReturnR[i] = OutR;
353                         pReturnI[i] = OutI;
354                     }
355                     else
356                     {
357                         pPoly->evaluate(pR[iCol * iRows + iRow], 0, &OutR, &OutI);
358                         pReturnR[i] = OutR;
359                     }
360                     i++;
361                 }
362             }
363         }
364     }
365     return pReturn;
366 }
367
368 void Polynom::updateRank(void)
369 {
370     for (int i = 0 ; i < getSize() ; i++)
371     {
372         m_pRealData[i]->updateRank();
373     }
374 }
375
376 int Polynom::getMaxRank(void)
377 {
378     int *piRank = new int[getSize()];
379     getRank(piRank);
380     int iMaxRank = 0;
381     for (int i = 0 ; i < getSize() ; i++)
382     {
383         iMaxRank = std::max(iMaxRank, piRank[i]);
384     }
385     delete[] piRank;
386     return iMaxRank;
387 }
388
389 Double* Polynom::getCoef(void)
390 {
391     int iMaxRank = getMaxRank();
392     int iColsOut = getCols() * (iMaxRank + 1);
393
394     Double *pCoef = new Double(getRows(), iColsOut, isComplex());
395     pCoef->setZeros();
396     double *pCoefR = pCoef->getReal();
397
398     if (isComplex())
399     {
400         double *pCoefI = pCoef->getImg();
401         for (int i = 0 ; i < m_iSize ; i++)
402         {
403             SinglePoly *pPoly = m_pRealData[i];
404             int iSize = pPoly->getSize();
405             double *pR = pPoly->get();
406             double *pI = pPoly->getImg();
407
408             for (int iRank = 0 ; iRank < iSize ; iRank++)
409             {
410                 pCoefR[iRank * m_iSize + i] = pR[iRank];
411                 pCoefI[iRank * m_iSize + i] = pI[iRank];
412             }
413         }
414     }
415     else
416     {
417         for (int i = 0 ; i < m_iSize ; i++)
418         {
419             SinglePoly *pPoly = m_pRealData[i];
420             int iSize = pPoly->getSize();
421             double *pR = pPoly->get();
422             for (int iRank = 0 ; iRank < iSize ; iRank++)
423             {
424                 pCoefR[iRank * m_iSize + i] = pR[iRank];
425             }
426         }
427     }
428
429     return pCoef;
430 }
431
432 Polynom* Polynom::setCoef(Double *_pCoef)
433 {
434     typedef Polynom* (Polynom::*setCoef_t)(Double*);
435     Polynom* pIT = checkRef(this, (setCoef_t)&Polynom::setCoef, _pCoef);
436     if (pIT != this)
437     {
438         return pIT;
439     }
440
441     setComplex(_pCoef->isComplex());
442     double *pR = _pCoef->getReal();
443
444     if (isComplex())
445     {
446         double *pI = _pCoef->getImg();
447         for (int i = 0 ; i < m_iSize ; i++)
448         {
449             SinglePoly *pPoly = m_pRealData[i];
450             int iSize = pPoly->getSize();
451             double* pTempR = pPoly->get();
452             double* pTempI = pPoly->getImg();
453
454             for (int iRank = 0 ; iRank < iSize ; iRank++)
455             {
456                 pTempR[iRank] = pR[iRank * m_iSize + i];
457                 pTempI[iRank] = pI[iRank * m_iSize + i];
458             }
459         }
460     }
461     else
462     {
463         for (int i = 0 ; i < m_iSize ; i++)
464         {
465             SinglePoly *pPoly = m_pRealData[i];
466             int iSize = pPoly->getSize();
467             double* pTempR = pPoly->get();
468
469             for (int iRank = 0 ; iRank < iSize ; iRank++)
470             {
471                 pTempR[iRank] = pR[iRank * m_iSize + i];
472             }
473         }
474     }
475
476     return this;
477 }
478
479 bool Polynom::subMatrixToString(std::wostringstream& ostr, int* _piDims, int _iDims)
480 {
481     std::wostringstream osExp;
482     std::wostringstream osPoly;
483
484     std::list<std::wstring>::const_iterator it_Exp;
485     std::list<std::wstring>::const_iterator it_Coef;
486     std::list<std::wstring> listExpR, listWstPoly, listExpI, listCoefI;
487
488     //Matrix
489     if (isComplex())
490     {
491         ostr << L"Real part" << std::endl << std::endl;
492         ostr << getMatrixString(_piDims, _iDims, false);
493         ostr << L"Imaginary part" << std::endl << std::endl;
494         ostr << getMatrixString(_piDims, _iDims, true);
495     }
496     else
497     {
498         ostr << getMatrixString(_piDims, _iDims, false);
499     }
500     return true;
501 }
502
503 std::wstring Polynom::getMatrixString(int* _piDims, int /*_iDims*/, bool _bComplex)
504 {
505     int iLineLen = ConfigVariable::getConsoleWidth();
506
507     std::wostringstream ostr;
508     std::wostringstream osPoly;
509
510     std::list<std::wstring>::const_iterator it_Coef;
511     std::list<std::wstring> listWstPoly;
512
513     int iLen        = 0;
514     int iLastCol    = 0;
515     bool bWordWarp  = false;
516
517     int *piMaxLen = new int[abs(getCols())];
518     memset(piMaxLen, 0x00, sizeof(int) * abs(getCols()));
519
520     //find the largest row for each col
521     for (int iCols1 = 0 ; iCols1 < abs(getCols()) ; iCols1++)
522     {
523         for (int iRows1 = 0 ; iRows1 < abs(getRows()) ; iRows1++)
524         {
525             int iLength = 0;
526             _piDims[0] = iRows1;
527             _piDims[1] = iCols1;
528             int iPos = getIndex(_piDims);
529             if (_bComplex)
530             {
531                 get(iPos)->toStringImg(getVariableName(), &listWstPoly);
532             }
533             else
534             {
535                 get(iPos)->toStringReal(getVariableName(), &listWstPoly);
536             }
537
538             for (auto it : listWstPoly)
539             {
540                 iLength += static_cast<int>(it.size());
541             }
542             piMaxLen[iCols1] = std::min(std::max(piMaxLen[iCols1], iLength), iLineLen);
543             listWstPoly.clear();
544         }
545
546         //We know the length of the column
547         if (static_cast<int>(iLen + piMaxLen[iCols1]) >= iLineLen && iLen != 0)
548         {
549             //if the max length exceeded
550             std::wostringstream ostemp;
551             bWordWarp = true;
552             for (int iRows2 = 0 ; iRows2 < abs(getRows()) ; iRows2++)
553             {
554                 bool bMultiLine = false;
555                 for (int iCols2 = iLastCol ; iCols2 < iCols1; iCols2++)
556                 {
557                     _piDims[0] = iRows2;
558                     _piDims[1] = iCols2;
559
560                     int iPos = getIndex(_piDims);
561                     if (_bComplex)
562                     {
563                         get(iPos)->toStringImg(getVariableName(),  &listWstPoly);
564                     }
565                     else
566                     {
567                         get(iPos)->toStringReal(getVariableName(),  &listWstPoly);
568                     }
569
570                     if (listWstPoly.size() > 1)
571                     {
572                         for (auto it : listWstPoly)
573                         {
574                             osPoly << it << std::endl;
575                             bMultiLine = true;
576                         }
577                     }
578                     else
579                     {
580                         osPoly << listWstPoly.front();
581                         addSpaces(&osPoly, piMaxLen[iCols2] - static_cast<int>(listWstPoly.front().size()));
582                         bMultiLine = false;
583                     }
584                     listWstPoly.clear();
585                 }
586
587                 if (bMultiLine == false)
588                 {
589                     osPoly << std::endl;
590                 }
591                 ostemp << osPoly.str() << std::endl;
592                 osPoly.str(L"");
593
594             }
595             iLen = piMaxLen[iCols1];
596
597             //write "column x to y"
598             addColumnString(ostr, iLastCol + 1, iCols1);
599             ostr << ostemp.str() << std::endl;
600
601             iLastCol = iCols1;
602         }
603         else //if((int)(iLen + piMaxLen[iCols1]) <= iLineLen)
604         {
605             iLen += piMaxLen[iCols1];
606         }
607     }//for(int iCols1 = 0 ; iCols1 < getCols() ; iCols1++)
608
609     if (bWordWarp)
610     {
611         addColumnString(ostr, iLastCol + 1, getCols());
612     }
613
614     //print the end
615     for (int iRows2 = 0 ; iRows2 < abs(getRows()) ; iRows2++)
616     {
617         for (int iCols2 = iLastCol ; iCols2 < abs(getCols()) ; iCols2++)
618         {
619             _piDims[0] = iRows2;
620             _piDims[1] = iCols2;
621
622             int iPos = getIndex(_piDims);
623             if (_bComplex)
624             {
625                 get(iPos)->toStringImg(getVariableName(), &listWstPoly);
626             }
627             else
628             {
629                 get(iPos)->toStringReal(getVariableName(), &listWstPoly);
630             }
631
632             if (listWstPoly.size() > 1)
633             {
634                 for (auto it : listWstPoly)
635                 {
636                     osPoly << it << std::endl;
637                 }
638             }
639             else
640             {
641                 osPoly << listWstPoly.front();
642                 addSpaces(&osPoly, piMaxLen[iCols2] - static_cast<int>(listWstPoly.front().size()));
643             }
644             listWstPoly.clear();
645         }
646
647         osPoly << std::endl;
648         if (isIdentity())
649         {
650             ostr << L"eye *" << std::endl << std::endl;
651         }
652         ostr << osPoly.str() << std::endl;
653         osPoly.str(L"");
654     }
655
656     delete[] piMaxLen;
657     return ostr.str();
658 }
659
660
661 Double* Polynom::extractCoef(int _iRank)
662 {
663     Double *pdbl = new Double(getRows(), getCols(), isComplex());
664     pdbl->setZeros();
665     double *pReal = pdbl->getReal();
666
667     if (isComplex())
668     {
669         double *pImg = pdbl->getImg();
670         for (int i = 0 ; i < getSize() ; i++)
671         {
672             SinglePoly *pPoly = m_pRealData[i];
673             if (pPoly->getRank() >= _iRank)
674             {
675                 pReal[i] = pPoly->get()[_iRank];
676                 pImg[i]  = pPoly->getImg()[_iRank];
677             }
678         }
679     }
680     else
681     {
682         for (int i = 0 ; i < getSize() ; i++)
683         {
684             SinglePoly *pPoly = m_pRealData[i];
685             if (pPoly->getRank() >= _iRank)
686             {
687                 pReal[i] = pPoly->get()[_iRank];
688             }
689         }
690     }
691
692     return pdbl;
693 }
694
695 bool Polynom::insertCoef(int _iRank, Double* _pCoef)
696 {
697     double *pReal = _pCoef->getReal();
698     if (isComplex())
699     {
700         double *pImg  = _pCoef->getImg();
701         for (int i = 0 ; i < getSize() ; i++)
702         {
703             SinglePoly *pPoly = m_pRealData[i];
704             if (pPoly->getRank() <= _iRank)
705             {
706                 return false;
707             }
708
709             pPoly->get()[_iRank] = pReal[i];
710             pPoly->getImg()[_iRank] = pImg[i];
711         }
712     }
713     else
714     {
715         for (int i = 0 ; i < getSize() ; i++)
716         {
717             SinglePoly *pPoly = m_pRealData[i];
718             if (pPoly->getRank() <= _iRank)
719             {
720                 return false;
721             }
722
723             pPoly->get()[_iRank] = pReal[i];
724         }
725     }
726
727     return true;
728 }
729
730 bool Polynom::operator==(const InternalType& it)
731 {
732     if (const_cast<InternalType &>(it).isPoly() == false)
733     {
734         return false;
735     }
736
737     Polynom* pM = const_cast<InternalType &>(it).getAs<types::Polynom>();
738
739     if (pM->getRows() != getRows() || pM->getCols() != getCols())
740     {
741         return false;
742     }
743
744     for (int i = 0 ; i < getSize() ; i++)
745     {
746         SinglePoly* p1 = get(i);
747         SinglePoly* p2 = pM->get(i);
748
749         if (*p1 != *p2)
750         {
751             return false;
752         }
753     }
754     return true;
755 }
756
757 bool Polynom::operator!=(const InternalType& it)
758 {
759     return !(*this == it);
760 }
761
762 SinglePoly* Polynom::getNullValue()
763 {
764     return new SinglePoly();
765 }
766
767 Polynom* Polynom::createEmpty(int _iDims, int* _piDims, bool /*_bComplex*/)
768 {
769     return new Polynom(getVariableName(), _iDims, _piDims, NULL);
770 }
771
772 SinglePoly* Polynom::copyValue(SinglePoly* _pData)
773 {
774     if (_pData == NULL)
775     {
776         return NULL;
777     }
778     return _pData->clone();
779 }
780
781 void Polynom::deleteAll()
782 {
783     for (int i = 0 ; i < m_iSizeMax ; i++)
784     {
785         m_pRealData[i]->killMe();
786     }
787     delete[] m_pRealData;
788     m_pRealData = NULL;
789     deleteImg();
790 }
791
792 void Polynom::deleteImg()
793 {
794
795 }
796
797 SinglePoly** Polynom::allocData(int _iSize)
798 {
799     SinglePoly** pData = new SinglePoly*[_iSize];
800     memset(pData, 0x00, _iSize * sizeof(SinglePoly*));
801     return pData;
802 }
803
804 void Polynom::deleteData(SinglePoly* data)
805 {
806     if (data)
807     {
808         data->killMe();
809     }
810 }
811
812 //overload to check variable name and call arrayof<>::insert after
813 Polynom* Polynom::insert(typed_list* _pArgs, InternalType* _pSource)
814 {
815     Polynom* p = _pSource->getAs<Polynom>();
816     if (p->getVariableName() != getVariableName())
817     {
818         char szError[512];
819         os_sprintf(szError, _("Input arguments should have the same formal variable name.\n"));
820         wchar_t* pwstError = to_wide_string(szError);
821         std::wstring wstError(pwstError);
822         FREE(pwstError);
823         throw ast::InternalError(wstError);
824     }
825
826     return ArrayOf<SinglePoly*>::insert(_pArgs, _pSource)->getAs<Polynom>();
827 }
828
829 Polynom* Polynom::Dollar()
830 {
831     int iRank = 1;
832     Polynom* pDollar = new Polynom(L"$", 1, 1, &iRank);
833     double* pdblCoef = pDollar->get(0)->get();
834     pdblCoef[0] = 0;
835     pdblCoef[1] = 1;
836
837     return pDollar;
838 }
839
840 bool Polynom::isDollar()
841 {
842     if (m_szVarName != L"$" || getSize() != 1)
843     {
844         return false;
845     }
846
847     double* pCoef = get(0)->get();
848
849     if (pCoef[0] != 0 && pCoef[1] != 1)
850     {
851         return false;
852     }
853
854     return true;
855 }
856
857 }
858