Main page

---

Monomial.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 MONOMIAL_H
#define MONOMIAL_H

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

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


// defined later
class mcExpElement;
class mcRadical;
class mcBracket;
class mcSymbol;

mcDEFINE_HELPER_CLASSES(mcMonomial)
extern mcMonomial mcEmptyMonomial;



class mcMonomialHelpers : public mcElementArrayHelpers
{
 mcDEFINE_REFERENCE_DATA(mcMonomial, mcET_MONOMIAL);

#ifdef mcENABLE_GUI
public:    // customizable variables

 static bool sgui_bEmptyBoxReplacing;

 static bool sgui_bFunctionScanEnabled;

 static bool sgui_bTransformDivInFractions;

 static int sgui_nSpaceBetween;

 int gui_GetSpaceBetweenRatio() const { return sgui_nSpaceBetween; }

#endif


#ifdef mcENABLE_MATH
public:   // customizable variables

 static mcMonomial *smath_pZero;
 static mcMonomial *smath_pOne;

#endif


#ifdef mcENABLE_IO
public:   // customizable variables

 static bool sio_bAutoConvertDivOpToFractions;

#endif



public:

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



#ifdef mcENABLE_DATA
protected:

 int data_GetIdxFromEntry(const mcArrayEntry *p) const
 { return p->mdata_idx; }

 mcElement &data_GetRefFromEntry(const mcArrayEntry *p)
 { return data_Get(p->mdata_idx); }

public:

#ifdef __MCDEBUG__

 void data_Check() const;

#endif

 void data_Repair();

 void data_TransformDivOp();

#endif  // mcENABLE_DATA



#ifdef mcENABLE_GUI
public:



 int gui_AddNewElement(mcElementType type, const mcKey &key, int pos = -1);

 void gui_CheckCursorPos() const;
 
 void gui_ScanArrayForFunctions();

 void gui_ReplaceSymbolsWithFunction(int idx, int fnc);
 




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

 bool gui_isArrEndKey(const mcKey &key) const { 
  mcElementType m = mcElementHelpers::gui_isKeyBeginKey(key);

  if (m == mcET_ADDOP || m == mcET_SUBOP)
   return TRUE;
  return FALSE;
 }

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

 int gui_DeleteFirstOp();

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

 mcInsertRes gui_Insert(const mcElement *toinsert, int n);
 mcInsertRes gui_Insert(const mcElement &toinsert, mcElement *);

 void gui_Replace(mcElement *);

 bool gui_Split(mcElement *);
 void gui_DoSplit(mcElementType type, const mcKey &key);
 bool gui_MergeWith(const mcElement &);

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


#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
protected:

 virtual mcExpSimRes math_HandleExpSimFlag(mcExpSimRes r, mcElement *newelem, int i);
 
 mcExpSimRes math_Reorder();

 //void ReorderSymbols(mcSymbol **arr, int nsymbols);

 virtual mcExpSimRes math_BeginSimSteps();

 virtual void math_EndSimSteps();

public:



 int math_MathToDataIdx(int dataindex) const;
 int math_DataToMathIdx(int mathindex) const;
 
 void math_PrepareForComparison(mcElementArray &p) const;

 mcElementType math_GetNeutralOpType() const  { return mcET_MULTOP; }
 double math_GetNeutralValue() const    { return 1.0; }
 
 mcPolynomial math_GetPolynomialWrapper() const;
 mcArrayEntry math_WrapMonomial(const mcMonomial &);
 mcArrayEntry math_WrapSimple(const mcElement &);
 //void math_GetFactors();

// void math_FactoreOut();
/* const mcElement &math_Get(int n) const 
  { return (const mcElement &)mcElementArrayHelpers::math_Get(n); }
 mcElement &math_Get(int n) 
  { return (mcElement &)mcElementArrayHelpers::math_Get(n); }
*/
 //void math_RaiseChildrenTo(const mcRealValue &n);
 mcBasicOpRes math_RaiseTo(const mcPolynomial &p);
 



 
 void math_Abs();

 //bool SetSign(int n);

 //bool ChangeSign();

 //int GetSign() const;

 //bool GetParentPos(const mcPolynomial &*pol = NULL, int *idx = NULL) const;
 //bool GetParentPos(mcPolynomial &*pol = NULL, int *idx = NULL);

 bool math_isSimilarTo(const mcMonomial &) const;

 void math_TransformDivOp();

 void math_RemoveAllOp(); 
 
 mcMonomial math_DetachNonCommonFactors(const mcMonomial &);

 mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *) const;

 mcIntegerValue math_GetMaxDegreeForSymbolArray(const mcSymbolArray *p) const;


 


  
 void math_SimplifyCoeff();
 void math_RemoveCoeff();
 void math_SetCoeff(const mcNumber &);
 void math_ChangeCoeffSign();
 mcRealValue math_GetCoeff() const;





 bool math_CanBeAddedWith(const mcElement &p) const;

 mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add);
 mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *p);
 mcBasicOpRes math_DivideBy(const mcElement &, mcElement *p);

 int math_GetOrderPos() const;

 mcMonomial math_GetLCM(const mcElement &) const;
 mcMonomial math_GetGCD(const mcElement &) const;


#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

 wxXml2Node io_GetMathML(bool bGetPresentation) const;

 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);
 bool io_ImportInlinedExpr(const wxString &, int *, wxString &pErr);

 void io_PostProcess();

#endif  // mcENABLE_IO
};


class mcMonomial : public mcElementArray 
{
 friend class mcPolynomial;
 mcDEFINE_MAIN_CLASS(Monomial, mcElementArray);

public:

 mcMonomial(const mcSymbol &towrap); 
 mcMonomial(const mcNumber &towrap);
 mcMonomial(const mcRadical &towrap);
 mcMonomial(const mcBracket &towrap);
 mcMonomial(const mcFraction &towrap);


 mcMonomial operator*(const mcMonomial &m) const
 { mcMonomial ret(*this); ret.math_SimpleMultiplyBy(m); return ret; }
 mcMonomial operator/(const mcMonomial &m) const
 { mcMonomial ret(*this); ret.math_SimpleDivideBy(m); return ret; }
 mcMonomial operator-(const mcMonomial &m) const
 { mcMonomial ret(*this); ret.math_SimpleSubtract(m); return ret; }
 mcMonomial operator+(const mcMonomial &m) const
 { mcMonomial ret(*this); ret.math_SimpleAdd(m); return ret; }

 mcMonomial operator+=(const mcMonomial &m)  { *this = *this+m;return *this; }
 mcMonomial operator-=(const mcMonomial &m)  { *this = *this-m;return *this; }
 mcMonomial operator*=(const mcMonomial &m)  { *this = *this*m;return *this; }
 mcMonomial operator/=(const mcMonomial &m)  { *this = *this/m;return *this; }



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

 mcWRAPPER void math_RemoveAllOp()
  { hlp()->math_RemoveAllOp(); }


 mcWRAPPER void math_Abs()
  { hlp()->math_Abs(); }
/* mcWRAPPER bool math_isSimilarTo(const mcMonomial &) const;
 mcWRAPPER void math_TransformDivOp();

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

 mcWRAPPER mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *p) const
  { return hlp()->math_GetMaxDegreeFor(p); }
 mcWRAPPER mcIntegerValue math_GetMaxDegreeForSymbolArray(const mcSymbolArray *p) const
  { return hlp()->math_GetMaxDegreeForSymbolArray(p); }

 mcWRAPPER void math_SimplifyCoeff()
  { hlp()->math_SimplifyCoeff(); }
 mcWRAPPER void math_SetCoeff(const mcNumber &n)
  { hlp()->math_SetCoeff(n); }
 mcWRAPPER void math_RemoveCoeff()
  { hlp()->math_RemoveCoeff(); }
 mcWRAPPER mcRealValue math_GetCoeff() const
  { return hlp()->math_GetCoeff(); }

 mcWRAPPER void math_ChangeCoeffSign()
  { hlp()->math_ChangeCoeffSign(); }
};


#endif // MONOMIAL_H

---

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

[ Top ]