Main page

---

MathMng.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 MATHMNG_H
#define MATHMNG_H

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

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


class mcMathMngHelpers : public mcElementHelpers
{
 mcDEFINE_REFERENCE_DATA(mcMathMng, mcET_MATHMNG);

#ifdef mcENABLE_DATA
protected:  // internal variables

 mcPolynomial mdata_eLMember;
 
 mcPolynomial mdata_eRMember;

 mcMathMngType mdata_nDataType;

#endif


#ifdef mcENABLE_GUI
protected:
 
 int mgui_nCursorPos;
 
#define mcMATHMNG_LEFT  0  
#define mcMATHMNG_RIGHT  1  


 wxSize mgui_szSeparator;

public:    // customizable variables
 
 static int sgui_nSpaceAroundSeparator;
 
 static int sgui_nSpaceLeftRight;

 
 static mcStyleArray *sgui_pNormalStyles;  
 static mcStyleArray *sgui_pSmallStyles;   
 static mcStyleArray *sgui_pBigStyles;   


 static mcMathMngCmd sgui_cmd[mcMMC_LAST];

#endif

 
public:
 
 mcMathMngHelpers() { data_Init(); }
 virtual ~mcMathMngHelpers() {}
 

protected:

 void data_Init() {
  mdata_nDataType = mcMMT_EXPRESSION;
  mcElementHelpers::data_Init();
 }

 void gui_Init() {  
  mgui_nCursorPos = mcMATHMNG_LEFT;
  
  // the style array *must* always be valid !
  mgui_pStyleArray = sgui_pNormalStyles;  
  mcElementHelpers::gui_Init();
 }

 

#ifdef mcENABLE_DATA
protected:   // internal functions

 void data_GetConstSourceDest(const mcPolynomialHelpers **s, 
    const mcPolynomialHelpers **d, bool toleft) const;

 void data_GetSourceDest(mcPolynomialHelpers **s, mcPolynomialHelpers **d, bool toleft)
  { data_GetConstSourceDest((const mcPolynomialHelpers **)s, 
   (const mcPolynomialHelpers **)d, toleft); }

public:

#ifdef __MCDEBUG__

 void data_Check() const;
 
 virtual wxString data_Debug(long flags) const;

#endif

 int data_GetChildrenCount() const {
  // we _always_ have both a left & a right member
  return mcElementHelpers::data_GetChildrenCount()+2;
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcElementHelpers);
  if (n == 0)
   return data_GetLeftMem();
  if (n == 1)
   return data_GetRightMem();
  return mcEmptyElement;
 } 

 void data_DeepCopy(const mcElementHelpers *mm); 

 virtual void data_SetFilter(const mcFilter *p);

 virtual void data_SetMember(bool left, const mcPolynomial &, 
        mcMathMngType newtype = mcMMT_EQUATION);

 const mcPolynomial &data_GetLeftMem() const    { return mdata_eLMember; }
 const mcPolynomial &data_GetRightMem() const   { return mdata_eRMember; }
 mcPolynomial &data_GetLeftMem()       { return mdata_eLMember; }
 mcPolynomial &data_GetRightMem()      { return mdata_eRMember; }

#endif  // mcENABLE_DATA



#ifdef mcENABLE_GUI
protected:

 void gui_GetConstSelectionSourceDest(const mcPolynomialHelpers **s, const mcPolynomialHelpers **d) const;
 void gui_GetSelectionSourceDest(mcPolynomialHelpers **s, mcPolynomialHelpers **d)
  { gui_GetConstSelectionSourceDest((const mcPolynomialHelpers **)s, (const mcPolynomialHelpers **)d); }

 static bool gui_isRelationalOp(const mcKey &key);


public:


 static void gui_InitStyles();

 static void gui_DeleteStyles();
 
 wxSize gui_GetSeparatorSize() const
  { return mgui_szSeparator; }

 void gui_RecalcSeparatorSize();

 int gui_GetXOfSeparator(int centerLine = -1) const;
 int gui_GetYOfSeparator(int centerLine = -1) const;

 int gui_GetXOfLeftMem() const;
 int gui_GetYOfLeftMem() const;

 int gui_GetXOfRightMem() const;
 int gui_GetYOfRightMem() const;

 void gui_SelectSeparatorStyle(wxDC &) const;
 int gui_GetYAnchor() const; 

 wxRect gui_GetRectOfLeftMem() const;
 wxRect gui_GetRectOfRightMem() const;

 mcPolynomial &gui_GetFocusMem()
  { return (mgui_nCursorPos == mcMATHMNG_LEFT) ? mdata_eLMember : mdata_eRMember; }

 const mcPolynomial &gui_GetFocusMem() const
  { return (mgui_nCursorPos == mcMATHMNG_LEFT) ? mdata_eLMember : mdata_eRMember; }





 
 // these does not apply to a mcMathSystem
 bool gui_isBeginKey(const mcKey &key) const 
  { return FALSE; }
 bool gui_isEndKey(const mcKey &key) const
  { return FALSE; }
 
 virtual int gui_Draw(wxDC &h, int x, int y, long flags, const wxPoint &p) const;
 
 virtual mcInputRes gui_Input(const mcKey &key, mcElement *);
 
 mcInsertRes gui_Insert(const mcElement &, mcElement *);

 virtual mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 virtual int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const;
 virtual void gui_SetCursorPos(const mcCursorPos &code);
 virtual void gui_GetCursorPos(mcCursorPos &) const;
 virtual int gui_MoveCursorUsingPoint(wxDC &, const wxPoint &);
 virtual void gui_OnSelect(wxDC &dc, wxRect &rc);
 virtual void gui_DoRecalcSize();

 virtual mcElement &gui_GetActiveElem(int x, int y, const wxPoint &pt);

 virtual mcElement gui_GetSelection() const;

 virtual void gui_DeleteSelection();

 virtual void gui_UpdateExpDepth();





 virtual void gui_MultiplyBySel(bool bDivide = FALSE);
 virtual void gui_MoveSel();
 virtual void gui_AddSubSel();

 virtual void gui_ExecCmdOnSel(mcMathMngCmdID);
 virtual void gui_GetPossibleOperations(mcMathMngCmdID *) const;

 virtual wxArrayString gui_GetPossibleOpOnSel(mcMathMngCmd *) const;

 
#endif  // mcENABLE_GUI



#ifdef mcENABLE_MATH
protected:

 static mcMathMngRelationalOp math_GetRelationalOpFor(mcMathMngType type);

 static mcMathMngType math_GetMathTypeFor(mcMathMngRelationalOp type);

 static mcMathMngType math_GetMathTypeFrom(const mcKey &);

public:


 // functions working with mcPolynomials
 mcBasicOpRes math_Add(const mcElement &, mcElement *, bool add);
 mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *);
 mcBasicOpRes math_DivideBy(const mcElement &e, mcElement *pp);
 mcBasicOpRes math_Subtract(const mcElement &, mcElement *);

 bool math_Compare(const mcElement &p, long flags) const;

 // functions working with mcMonomials
 void math_MultiplyBy(const mcMonomial &);
 void math_DivideBy(const mcMonomial &);
 void math_MultiplyBy(int nID);

 void math_MoveSymbols(const mcSymbolArray *arr, bool toLeft);
 void math_MoveSymbol(const mcSymbolProperties *sym, bool toLeft);
 void math_MoveFreeFrom(const mcSymbolProperties *sym, bool toLeft);
 void math_MoveUnknowns(bool toLeft);
 void math_MoveConstants(bool toLeft);
 void math_MoveParameters(bool toLeft);
 void math_MoveNonSymbol(bool toLeft);
 void math_MoveAll(bool toleft);
 void math_Move(int mathidx, bool toleft);
 
 mcBasicOpRes math_RaiseTo(const mcPolynomial &p);
 
 void math_RaiseTo(const mcRealValue &);
 void math_RaiseTo(int nID);
 void math_RaiseToSel();

 mcExpSimRes math_Simplify(long flags, mcElement *)
  { return math_Simplify(flags, flags); }
 mcExpSimRes math_Expand(long flags, mcElement *)
  { return math_Expand(flags, flags); }

 mcExpSimRes math_Simplify(long lflags, long rflags);
 mcExpSimRes math_Expand(long lflags, long rflags);

 bool math_isMaxSimplified() const;
 bool math_isConstant() const;
 bool math_isFactorized() const;

 mcRealValue math_Evaluate() const; 
 mcRealValue math_GetLenght() const;
 mcRealValue math_GetTotalLenght() const;
 

 mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *sym) const;

 int math_Replace(const mcElement &tofind, int occ, long flags, 
     const mcElement &replacement, bool addchildren);

 int math_GetCountOf(const mcElement &tocount, long flags) const;

 bool math_CompareThisOnly(const mcElement &, long flags) const;

 mcElement math_Find(int n, const mcElement &tofind, long flags, int *pos = NULL) const;
 
 /*mcElement math_Find(int n, const mcElement &tofind, long flags, int *pos = NULL)
  { return (mcElementHelpers *)math_Find(n, tofind, bStrict, pos); }*/

 //bool math_Contains(const mcElement &p, long flags = mcFIND_NOFLAGS) const;
 bool math_ContainsSymbol(const mcSymbolProperties *sym) const;
 bool math_ContainsNumber(const mcRealValue &sym) const;

 bool math_ContainsInvalidSymbols() const;
 int math_GetSymbolList(mcSymbol **, int size, 
  const mcSymbol &tofind, bool left = TRUE) const;

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

 mcMathMngType math_GetMathMngType() const
  { return mdata_nDataType; }

 void math_SetMathType(mcMathMngType newtype)
  { mdata_nDataType = newtype; }

 mcMathType math_GetMathType() const;


 // these does not have sense for a mcMathSystem
 int math_GetOrderPos() const   { return 0; }

 bool math_CanBeAddedWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeMultWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeDivBy(const mcElement &p) const  { return FALSE; }

 mcMonomial math_GetLCM(const mcElement &) const  { return mcEmptyMonomial; }
 mcMonomial math_GetGCD(const mcElement &) const  { return mcEmptyMonomial; }


#endif  // mcENABLE_MATH


 
#ifdef mcENABLE_IO
public:

 
 virtual wxXml2Node io_GetMathML(bool bGetPresentation) const;

 virtual wxString io_GetInlinedExpr() const;
 
 virtual bool io_ImportPresentationMathML(wxXml2Node tag, wxString &err);

 virtual bool io_ImportInlinedExpr(const wxString &str, int *count, wxString &perr);

 wxString io_GetSeparatorSymbol(bool bUseSpecialChars = TRUE) const;


 // these does not have sense for a mcMathSystem
 bool io_isBeginTag(const wxXml2Node &tag) const  { return FALSE; }
 bool io_isBeginChar(const wxString &str) const   { return FALSE; }


#endif  // mcENABLE_IO
};



class mcMathMng : public mcElement
{
 mcDEFINE_MAIN_CLASS(MathMng, mcElement);

protected:

 void data_Init(const mcPolynomial &left, const mcPolynomial &right)
 { data_GetLeftMem()=left; data_GetRightMem()=right; 
  math_SetMathType(mcMMT_EQUATION); }

public:

 mcMathMng(const mcPolynomial &left, const mcPolynomial &right)
 { data_SetRefData(new mcMathMngHelpers()); data_Init(left, right); }


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

 mcWRAPPER const mcPolynomial &data_GetLeftMem() const
  { return hlp()->data_GetLeftMem(); }
 mcWRAPPER const mcPolynomial &data_GetRightMem() const
  { return hlp()->data_GetRightMem(); }
 mcWRAPPER mcPolynomial &data_GetLeftMem()
  { return hlp()->data_GetLeftMem(); }
 mcWRAPPER mcPolynomial &data_GetRightMem()
  { return hlp()->data_GetRightMem(); }
 mcWRAPPER void data_SetFilter(const mcFilter *p)
  { hlp()->data_SetFilter(p); }



 mcWRAPPER void gui_MoveSel()
  { hlp()->gui_MoveSel(); }
 mcWRAPPER wxArrayString gui_GetPossibleOpOnSel(mcMathMngCmd *p) const
  { return hlp()->gui_GetPossibleOpOnSel(p); }
 mcWRAPPER void gui_GetPossibleOperations(mcMathMngCmdID *p) const
  { hlp()->gui_GetPossibleOperations(p); }
 mcWRAPPER void gui_MultiplyBySel()
  { hlp()->gui_MultiplyBySel(); }
 mcWRAPPER void gui_ExecCmdOnSel(mcMathMngCmdID n)
  { hlp()->gui_ExecCmdOnSel(n); }

 
 mcWRAPPER const mcPolynomial &gui_GetFocusMem() const
  { return hlp()->gui_GetFocusMem(); }
 mcWRAPPER mcPolynomial &gui_GetFocusMem()
  { return hlp()->gui_GetFocusMem(); }


 mcWRAPPER mcMathMngType math_GetMathMngType() const
  { return hlp()->math_GetMathMngType(); }
 mcWRAPPER mcExpSimRes math_Simplify(long flags, long rflags)
  { return hlp()->math_Simplify(flags, rflags); }
 mcWRAPPER mcExpSimRes math_Expand(long flags, long rflags)
  { return hlp()->math_Expand(flags, rflags); }

 mcWRAPPER void math_MoveConstants(bool toleft)
  { hlp()->math_MoveConstants(toleft); }
 mcWRAPPER void math_MoveParameters(bool toleft)
  { hlp()->math_MoveParameters(toleft); }
 mcWRAPPER void math_MoveUnknowns(bool toleft)
  { hlp()->math_MoveUnknowns(toleft); }
 mcWRAPPER void math_MoveNonSymbol(bool toleft)
  { hlp()->math_MoveNonSymbol(toleft); }
 mcWRAPPER void math_MoveSymbol(const mcSymbolProperties *sym, bool toleft)
  { hlp()->math_MoveSymbol(sym, toleft); }
 mcWRAPPER void math_MoveFreeFrom(const mcSymbolProperties *sym, bool toleft)
  { hlp()->math_MoveFreeFrom(sym, toleft); }
 mcWRAPPER void math_MoveAll(bool toleft)
  { hlp()->math_MoveAll(toleft); }

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

 mcWRAPPER mcIntegerValue math_GetMaxDegreeFor(const mcSymbolProperties *p) const
  { return hlp()->math_GetMaxDegreeFor(p); }
 mcWRAPPER mcElement math_Find(int n, const mcElement &tofind, 
       long flags, int *pos = NULL) const
  { return hlp()->math_Find(n, tofind, flags, pos); }
 mcWRAPPER void math_SetMathType(mcMathMngType t)
  { hlp()->math_SetMathType(t); }

 mcWRAPPER bool math_isFactorized() const
  { return hlp()->math_isFactorized(); }
};

#endif // MATHMNG_H

---

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

[ Top ]