Main page

---

Polynomial.h

Go to the documentation of this file.

// MathCore = a WYSIWYG equation editor + a powerful math engine     //
// Copyright (C) 2003 by Francesco Montorsi                          //
//                                                                   //
// This library is free software; you can redistribute it and/or     //
// modify it under the terms of the GNU Lesser General Public        //
// License as published by the Free Software Foundation; either      //
// version 2.1 of the License, or (at your option) any later         //
// version.                                                          //
//                                                                   //
// This library is distributed in the hope that it will be useful,   //
// but WITHOUT ANY WARRANTY; without even the implied warranty of    //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      //
// GNU Lesser General Public License for more details.               //
//                                                                   //
// You should have received a copy of the GNU Lesser General Public  //
// License along with this program; if not, write to the Free        //
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,   //
// MA 02111-1307, USA.                                               //
//                                                                   //
// For any comment, suggestion or feature request, please contact    //
// the administrator of the project at frm@users.sourceforge.net     //
//                                                                   //



#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H

// optimization for GCC compiler
#ifdef __GNUG__
#pragma interface "Polynomial.h"
#endif

// required includes
#include "mc/ElementArray.h"
#include "mc/Monomial.h"


// defined later
class mcMonomialHelpers;
class mcMonomial;
class mcRadical;

mcDEFINE_HELPER_CLASSES(mcPolynomial)
extern mcPolynomial mcEmptyPolynomial;



#define mcMAKEPOL_IDX(midx, eidx)  (((midx) << 16) | (eidx))


class mcPolynomialHelpers : public mcElementArrayHelpers
{
 mcDEFINE_REFERENCE_DATA(mcPolynomial, mcET_POLYNOMIAL);

#ifdef mcENABLE_GUI
public:    // customizable variables

 static int sgui_nSpaceBetween;

 int gui_GetSpaceBetweenRatio() const  
  { return sgui_nSpaceBetween/(gui_GetExpDepth()+1); }

 bool mgui_bRemoveParenthesis;
 bool mgui_bMoveCursorAtBracketBegin;

 mcElement mgui_pBracketToReplace;
 bool mgui_bRemoveLeftParenthesis;

#endif


#ifdef mcENABLE_MATH
public:   // static utilities

 static mcPolynomial *smath_pOne;

 static mcPolynomial *smath_pEmpty;

#endif



public:

 mcPolynomialHelpers() { data_Init(); }
 virtual ~mcPolynomialHelpers() {}

protected:

 void gui_Init() {
  mgui_bRemoveParenthesis = FALSE;
  mgui_bMoveCursorAtBracketBegin = FALSE;
  mgui_bRemoveLeftParenthesis = FALSE;
  mcElementArrayHelpers::gui_Init();
 }




#ifdef mcENABLE_DATA
protected:

 int data_GetIdxFromEntry(const mcArrayEntry *p) const
 { return p->mdata_idx & ~(0xFFFF<<16); }
 int data_GetMonomialIdxFromEntry(const mcArrayEntry *p) const
 { return (p->mdata_idx >> 16); }

 mcElement &data_GetRefFromEntry(const mcArrayEntry *p)
 {
  int midx = data_GetMonomialIdxFromEntry(p), eidx = data_GetIdxFromEntry(p);
  if (eidx != -1) {
   mcASSERT(data_Get(eidx).data_GetType() == mcET_MONOMIAL, wxT("idx is not valid"));
   return ((mcMonomial &)data_Get(midx)).data_Get(eidx);
  }

  return data_Get(midx);
 }

public:

 int math_GetIdxFromEntry(const mcArrayEntry *p) const
 { return math_DataToMathIdx(data_GetIdxFromEntry(p)); }
 int math_GetMonomialIdxFromEntry(const mcArrayEntry *p) const
 { return math_DataToMathIdx(data_GetMonomialIdxFromEntry(p)); }


public:
#ifdef __MCDEBUG__

 void data_Check() const;
#endif

 void data_DeepCopy(const mcElementHelpers *e) {
  const mcPolynomialHelpers *p = (const mcPolynomialHelpers *)e;
  mgui_bMoveCursorAtBracketBegin = p->mgui_bMoveCursorAtBracketBegin;
  mgui_bRemoveLeftParenthesis = p->mgui_bRemoveLeftParenthesis;
  mgui_bRemoveParenthesis = p->mgui_bRemoveParenthesis;
  mcElementArrayHelpers::data_DeepCopy(e);
 }





 int data_AddNewMonomialContaining(mcElement *contents, int count = 1, 
          int pos = -1, bool bOverwrite = FALSE);

 int data_AddNewMonomialContaining(mcElement &monomialinit, 
         int pos, bool bOverwrite = FALSE)
  { return data_AddNewMonomialContaining(&monomialinit, 1, pos, bOverwrite); }

 int data_AddNewMonomial(const mcMonomial &toinsert, int pos = -1, 
       bool bOverwrite = FALSE)
  { return data_AddElements((mcElement*)(&toinsert), 1, pos, bOverwrite); }

 void data_AddNewEmptyBox(int pos)
  { data_AddNewEmptyMonomial(pos); }

 int data_AddNewEmptyMonomial(int pos = -1);

 mcElement &data_AddNewWrappedElement(mcElementType t, 
    bool bOverwrite = FALSE, int pos = -1);

 int data_FindMonomialContaining(int occ, const mcElement &elem) const;

 void data_DetachAndShiftMonomial(int n);

 virtual bool data_isWrappingOnly(mcElementType t) const;
 virtual const mcElement &data_GetWrapped(mcElementType t) const;





 bool data_CreateFirstOp();

 void data_DeleteFirstOp();
 
 bool data_ReplaceParentheses(bool bMoveAtBracketEnd);
 bool data_ReplaceParentheses(int, int, int, int, bool);

 void data_ReplaceAllParentheses();


#endif  // mcENABLE_DATA



#ifdef mcENABLE_GUI
public:


 bool gui_isBeginKey(const mcKey &) const  { return FALSE; }

 int gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl) const;

 void gui_ExOnSelect(wxDC &dc, wxRect &rc, int cl);

 mcInputRes gui_BackInput(const mcKey &key, mcElement *pnewelem, int n);

 mcInputRes gui_Input(const mcKey &key, mcElement *pnewelem);

 mcInsertRes gui_Insert(const mcElement &toinsert, mcElement *);
 
 
 void gui_DoSplit(mcElementType type, const mcKey &ev);
 void gui_SetCursorPos(const mcCursorPos &code);

 void gui_OnSelect(wxDC &dc, wxRect &rc) {
  // call the overloaded version;
  gui_ExOnSelect(dc, rc, -1);
 }

 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const {
  // call the overloaded version
  return gui_ExDraw(dc, x, y, flags, pt, -1);
 }
 




 bool gui_isArrEndKey(const mcKey &) const   { return FALSE; }

 bool gui_isArrayEmpty();

 void gui_CheckCursorPos() const;

 void gui_OnNewParenthesis(bool leftpar) { 
  mgui_bRemoveParenthesis = TRUE;
  mgui_bMoveCursorAtBracketBegin = leftpar;
 }

 void gui_SetBracketToReplace(const mcBracket &p, bool leftpar) {
  mgui_pBracketToReplace = (const mcElement &)p;
  mgui_bRemoveLeftParenthesis = leftpar;
 }

 void gui_ReplaceBracket(const mcBracket &, bool left);

 // these two are very different from data_XXXX corrispondents.
 int gui_AddNewElement(mcElementType type, const mcKey &key, int pos = -1); 

 void gui_AddNewEmptyMonomial(int pos = -1);


#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
protected:

 mcExpSimRes math_Reorder();

 void math_DistributeBracket(int mdataidx, int bridx);

 virtual void math_EndSimSteps() {/* math_SyncCoeffWithSigns();*/ }

 virtual void math_EndExpSteps() { /*math_SyncCoeffWithSigns();*/ }

 mcExpSimRes math_SimplifySolveOp(long flags);


public:


 virtual int math_GetCount() const 
  { return data_GetNumOfElemType(mcET_MONOMIAL); }

 const mcMonomial &math_Get(int n) const 
  { return (const mcMonomial &)(data_GetElemOfType(n, mcET_MONOMIAL)); }
 mcMonomial &math_Get(int n)
  { return (mcMonomial &)data_GetElemOfType(n, mcET_MONOMIAL); }

 //const mcMonomialHelpers *math_GetHlp(int n) const;
 //mcMonomialHelpers *math_GetHlp(int n);

 virtual bool math_isWrappingOnly(mcElementType t) const;
 virtual const mcElement &math_GetWrapped(mcElementType t) const;

 int math_FindMonomialContaining(const mcElement &elem, int occ = 0, int *n = NULL) const;

 const mcMonomial &math_GetMonomialContaining(const mcElement &elem, 
          int occ = 0, int *n = NULL) const;

 mcMonomial math_GetCoeffOf(int mathidx, const mcElement *toremove, int ntoremove) const;

 mcMonomial math_GetCoeffOf(const mcSymbolProperties *sym, const mcPolynomial &exp, int occ = 0) const;

 mcMonomial math_GetCoeffOf(const mcSymbolProperties *sym, const mcRealValue &exp, int occ = 0) const;

 //void math_AddMonomial(const mcMonomial &p);
 //void math_Monomial(const mcMonomial &p);

 //int GetIndexOf(const mcMonomial &tofind) const;

 bool math_isFactorized() const  { return math_GetCount() == 1; }

 bool math_isFirstMonomialNegative() const
  { if (data_isArrayEmpty()) return FALSE; else return (math_GetSign(0)==-1); }


 void math_Factorize(int *n, int count);

 void math_FactoreOut(int *n, int count, bool bForceUseless);
 void math_FactoreOutAll(bool bForceUseless) 
  { math_FactoreOut(NULL, -1, bForceUseless); }

 void math_FactoreOut(const mcSymbolProperties *unk, const mcPolynomial &pol, bool bForceUseless);
 void math_FactoreOutFreeOf(const mcSymbolProperties *unk, const mcPolynomial &pol, bool bForceUseless);

 void math_FactoreOut(const mcSymbolArray *arr);
 void math_FactoreOutUnknowns();
 void math_FactoreOutParameters();
 void math_FactoreOutConstants();


 mcArrayEntry math_EmbedInBracket(int *n, int count);

 mcArrayEntry math_GetIndexOf(int occ, const mcMonomial &tofind, bool positivesign) const;

 //void math_ExpandContaining(
 mcExpSimRes math_HandleExpSimFlag(mcExpSimRes r, mcElement *pnew, int i);





 int math_DataToMathIdx(int dataindex) const;

 int math_MathToDataIdx(int mathindex) const;

 mcElementType math_GetNeutralOpType() const  { return mcET_ADDOP; }
 double math_GetNeutralValue() const    { return 0.0; }

 mcPolynomial math_GetPolynomialWrapper() const;
 mcArrayEntry math_WrapMonomial(const mcMonomial &);
 mcArrayEntry math_WrapSimple(const mcElement &);
 mcElementArray math_CreateWrapperFor(const mcElement &p) const;

 //void &math_GetFactors();

 mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *) const;





 int math_GetSign(int n) const;

 const mcNumber &math_GetNumSign(const mcMonomial &m, int occ = 0) const;

 void math_SetSign(int n, int sgn);

 void math_ChangeSign(int n)  { math_SetSign(n, -math_GetSign(n)); }

 void math_ChangeAllSigns();

 void math_SyncCoeffWithSigns();

 void math_PackSign(mcMonomial &m, int occ = 0) const;
 
 bool math_DeleteFirstOp();





 int math_GetSelCount() const 
  { return gui_GetSelElemCountOfType(mcET_MONOMIAL); }

 int math_GetSelIndex(int n) const 
  { return gui_GetSelElemIndexOfType(n, mcET_MONOMIAL); }

 const mcMonomial &math_GetSel(int n) const 
  { return (const mcMonomial &)gui_GetSelElemOfType(n, mcET_MONOMIAL); }

 mcMonomial &math_GetSel(int n) 
  { return (mcMonomial &)gui_GetSelElemOfType(n, mcET_MONOMIAL); }

 void math_DeleteSelection();




 
 mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add);
 mcBasicOpRes math_Subtract(const mcElement &, mcElement *p);
 mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *p);
 mcBasicOpRes math_DivideBy(const mcElement &, mcElement *p);
 
 mcMonomial math_GetLCM(const mcElement &p) const;
 mcMonomial math_GetGCD(const mcElement &p) const;

 mcMonomial math_GetGCDFor(int *n, int count) const;
 
 mcExpSimRes math_Simplify(long flags, mcElement *newelem);
  mcExpSimRes math_Simplify(long flags)
  { return math_Simplify(flags, NULL); }

 mcIntegerValue math_RaiseGetCoeff(int *indexes, int m);
 bool math_CanBeRaisedTo(const mcPolynomial &) const;
 
 void math_RaiseTo(const mcRealValue &n);
 mcBasicOpRes math_RaiseTo(const mcPolynomial &);

 virtual int math_GetOrderPos() const   { return -1; }
 
#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

 wxXml2Node io_GetMathML(bool bGetPresentation) const;
 wxString io_GetInlinedExpr() const;

 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);
 bool io_ImportInlinedExpr(const wxString &todecode, int *, wxString &pErr, int mlimit);
 bool io_ImportInlinedExpr(const wxString &todecode, int *p, wxString &pErr)
  { return io_ImportInlinedExpr(todecode, p, pErr, -1); }

#endif  // mcENABLE_IO
};



class mcPolynomial : public mcElementArray
{
 mcDEFINE_MAIN_CLASS(Polynomial, mcElementArray);

public:

 // these constructors must use only data_**** functions
 mcPolynomial(const mcMonomial &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddElements(&towrap, 1); }

 // math constructors
 mcPolynomial(const mcSymbol &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddNewMonomialContaining((mcElement *)&towrap, 1); }
 mcPolynomial(const mcNumber &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddNewMonomialContaining((mcElement *)&towrap, 1); }
 mcPolynomial(const mcSymbolProperties *towrap)
 { data_SetRefData(new mcPolynomialHelpers); math_WrapSymbol(towrap); }
 mcPolynomial(const mcRealValue &towrap)
 { data_SetRefData(new mcPolynomialHelpers); math_WrapNumber(towrap); }

 mcPolynomial(const mcRadical &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddNewMonomialContaining((mcElement *)&towrap, 1); }
 mcPolynomial(const mcBracket &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddNewMonomialContaining((mcElement *)&towrap, 1); }
 mcPolynomial(const mcFraction &towrap)
 { data_SetRefData(new mcPolynomialHelpers); data_AddNewMonomialContaining((mcElement *)&towrap, 1); }


 // unary negation
 mcPolynomial &operator-()
  { this->math_ChangeAllSigns(); return *this; }


#ifdef mcENABLE_DATA
public:

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_POLYNOMIAL; }

 mcWRAPPER bool data_CreateFirstOp()
  { return hlp()->data_CreateFirstOp(); }
 mcWRAPPER void data_DeleteFirstOp()
  { hlp()->data_DeleteFirstOp(); }

 mcWRAPPER int data_AddNewMonomialContaining(mcElement *contents, 
        int n = 1, int pos = -1, bool bOverwrite = FALSE)
  { return hlp()->data_AddNewMonomialContaining(contents, n, pos, bOverwrite); }

 mcWRAPPER int data_AddNewMonomialContaining(mcElement &monomialinit, 
        int pos = -1, bool bOverwrite = TRUE)
  { return hlp()->data_AddNewMonomialContaining(monomialinit, pos, bOverwrite); }

 mcWRAPPER int data_AddNewMonomial(const mcMonomial &toinsert, 
        int pos = -1, bool bOverwrite = FALSE)
  { return hlp()->data_AddNewMonomial(toinsert, pos, bOverwrite); }

 mcWRAPPER int data_AddNewEmptyMonomial(int pos = -1)
  { return hlp()->data_AddNewEmptyMonomial(pos); }
/*
 mcWRAPPER mcElement &data_AddNewWrappedElement(mcElementType t, bool bOverwrite = FALSE, int pos = -1);
 mcWRAPPER int data_FindMonomialContaining(const mcElement &elem, int occ = 0) const;
 mcWRAPPER void data_DetachAndShiftMonomial(int n);*/ 

#endif

  
#ifdef mcENABLE_GUI
public:

 mcWRAPPER void gui_AddNewEmptyMonomial(int pos = -1)
  { hlp()->gui_AddNewEmptyMonomial(pos); }

 mcWRAPPER int gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl) const
  { return hlp()->gui_ExDraw(dc, x, y, flags, pt, cl); }
 
/* 
 int gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl) const;
 void gui_ExOnSelect(wxDC &dc, int x, int y, wxRect &rc, int cl);
 mcInputRes gui_BackInput(const mcKey &key, mcElement *pnewelem, int n);
 mcInputRes gui_Input(const mcKey &key, mcElement *pnewelem);
 void gui_DoSplit(mcElementType type, const mcKey &ev);
 void gui_SetCursorPos(const mcCursorPos &code);

 void gui_OnSelect(wxDC &dc, wxRect &rc) {
  // call the overloaded version;
  gui_ExOnSelect(dc, x, y, rc, -1);
 }

 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const {
  // call the overloaded version
  return gui_ExDraw(dc, x, y, flags, pt, -1);
 }
 bool gui_isArrEndKey(const mcKey &) const   { return FALSE; }
 bool gui_isArrayEmpty();
 void gui_CheckCursorPos() const;
 void gui_OnNewParenthesis(bool leftpar) { 
  mgui_bRemoveParenthesis = TRUE;
  mgui_bMoveCursorAtBracketBegin = leftpar;
 }
 void gui_SetBracketToReplace(const mcBracket &p, bool leftpar) {
  mgui_pBracketToReplace = (const mcElement &)p;
  mgui_bRemoveLeftParenthesis = leftpar;
 }
 void gui_ReplaceBracket(const mcBracket &, bool left);
 int gui_AddNewElement(mcElementType type, const mcKey &key, int pos = -1); 
 void gui_AddNewEmptyMonomial(int pos = -1);
  //{ mgui_nCursorPos = data_AddNewEmptyMonomial(pos); }
*/
#endif


 mcWRAPPER const mcMonomial &math_Get(int n) const 
  { return hlp()->math_Get(n); }
 mcWRAPPER mcMonomial &math_Get(int n)
  { return hlp()->math_Get(n); }


 mcWRAPPER int math_FindMonomialContaining(const mcElement &elem, int occ = 0, int *n = NULL) const
  { return hlp()->math_FindMonomialContaining(elem, occ, n); }
 mcWRAPPER const mcMonomial &math_GetMonomialContaining(const mcElement &elem, int occ = 0, int *n = NULL) const
  { return hlp()->math_GetMonomialContaining(elem, occ, n); }
 mcWRAPPER mcMonomial math_GetCoeffOf(int mathidx, const mcElement *toremove, int ntoremove) const
  { return hlp()->math_GetCoeffOf(mathidx, toremove, ntoremove); }
 mcWRAPPER mcMonomial math_GetCoeffOf(const mcSymbolProperties *sym, const mcPolynomial &exp, int occ = 0) const
  { return hlp()->math_GetCoeffOf(sym, exp, occ); }
 mcWRAPPER mcMonomial math_GetCoeffOf(const mcSymbolProperties *sym, const mcRealValue &exp, int occ = 0) const
  { return hlp()->math_GetCoeffOf(sym, exp, occ); }


 mcWRAPPER bool math_isFactorized() const
  { return hlp()->math_isFactorized(); }
 mcWRAPPER bool math_isFirstMonomialNegative() const
  { return hlp()->math_isFirstMonomialNegative(); }
 mcWRAPPER mcMonomial math_GetFactors() const
  { return ((mcElementArrayHelpers*)hlp())->math_GetFactors(); }

 mcWRAPPER void math_Factorize(int *n, int count)
  { hlp()->math_Factorize(n, count); }
 mcWRAPPER void math_FactoreOut(int *n, int count, bool bForceUseless)
  { hlp()->math_FactoreOut(n, count, bForceUseless); }
 mcWRAPPER void math_FactoreOutAll(bool bForceUseless)
  { hlp()->math_FactoreOutAll(bForceUseless); }


 mcWRAPPER void math_FactoreOut(const mcSymbolProperties *unk, const mcPolynomial &pol, bool bForceUseless)
  { hlp()->math_FactoreOut(unk, pol, bForceUseless); }
 mcWRAPPER void math_FactoreOutFreeOf(const mcSymbolProperties *unk, const mcPolynomial &pol, bool bForceUseless)
  { hlp()->math_FactoreOutFreeOf(unk, pol, bForceUseless); }

 mcWRAPPER void math_FactoreOut(const mcSymbolArray *arr)
  { hlp()->math_FactoreOut(arr); }
 mcWRAPPER void math_FactoreOutUnknowns()
  { hlp()->math_FactoreOutUnknowns(); }
 mcWRAPPER void math_FactoreOutParameters()
  { hlp()->math_FactoreOutParameters(); }
 mcWRAPPER void math_FactoreOutConstants()
  { hlp()->math_FactoreOutConstants(); }


 mcWRAPPER mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *s) const
  { return hlp()->math_GetMaxDegreeFor(s); }


 mcWRAPPER int math_GetSign(int n) const
  { return hlp()->math_GetSign(n); }
 mcWRAPPER const mcNumber &math_GetNumSign(const mcMonomial &m, int occ = 0) const
  { return hlp()->math_GetNumSign(m, occ); }

 mcWRAPPER void math_SetSign(int n, int sgn)
  { hlp()->math_SetSign(n, sgn); } 
 mcWRAPPER void math_ChangeSign(int n)
  { hlp()->math_ChangeSign(n); } 
 mcWRAPPER void math_ChangeAllSigns()
  { hlp()->math_ChangeAllSigns(); } 
 mcWRAPPER void math_PackSign(mcMonomial &m, int occ = 0) const
  { hlp()->math_PackSign(m, occ); } 
 mcWRAPPER bool math_DeleteFirstOp()
  { return hlp()->math_DeleteFirstOp(); } 

 mcWRAPPER bool math_CanBeRaisedTo(const mcPolynomial &n)
  { return hlp()->math_CanBeRaisedTo(n); } 

 mcWRAPPER mcArrayEntry math_GetIndexOf(int occ, const mcMonomial &tofind, bool b) const
 { return hlp()->math_GetIndexOf(occ, tofind, b); }

 mcWRAPPER int math_GetMonomialIdxFromEntry(const mcArrayEntry &p) const
  { return hlp()->math_GetMonomialIdxFromEntry(&p); }
 mcWRAPPER int math_GetIdxFromEntry(const mcArrayEntry &p) const
  { return hlp()->math_GetIdxFromEntry(&p); }
};


#endif // POLYNOMIAL_H

---

Documentation generated with Doxygen on Sun Feb 6 17:10:48 2005 Visit MathStudio home page for more info

[ Top ]