Main page

---

MathMng.cpp

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     //
//                                                                   //



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

// includes
#include "mc/mcprec.h"
#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/MathMng.h"
 #include "mc/Monomial.h"
 #include "mc/Number.h"
 #include "mc/Symbol.h"
#endif



// setup customizable variables
int mcMathMngHelpers::sgui_nSpaceLeftRight = 1;
int mcMathMngHelpers::sgui_nSpaceAroundSeparator = 5;
mcStyleArray *mcMathMngHelpers::sgui_pNormalStyles = NULL;
mcStyleArray *mcMathMngHelpers::sgui_pSmallStyles = NULL;
mcStyleArray *mcMathMngHelpers::sgui_pBigStyles = NULL;

mcMathMngCmd mcMathMngHelpers::sgui_cmd[] = 
{ 
 mcMathMngCmd(mcMMC_MOVE_SEL, wxT("Move the selection")),
 mcMathMngCmd(mcMMC_MULT_SEL, wxT("Multiply everything by this")),
 mcMathMngCmd(mcMMC_DIV_SEL, wxT("Divide everything by this")),
 mcMathMngCmd(mcMMC_ADDSUB_SEL, wxT("Add this")),

 mcMathMngCmd(mcMMC_SIMPLIFY, wxT("Simplify selection")),
 mcMathMngCmd(mcMMC_EXPAND, wxT("Expand selection"))
};




// ----------------------------------------
// mcMATHMNG - general functions
// ----------------------------------------

#ifdef __MCDEBUG__

void mcMathMngHelpers::data_Check() const
{
 bool leftempty = data_GetLeftMem().data_isArrayEmpty();

 // if we are a mcMMT_EXPRESSION then the right member should not be empty
 // (unless also the left member is empty: in this case, we are just
 //  uninitialized but we are still valid)
 mcASSERT(mdata_nDataType != mcMMT_EXPRESSION ||
  !data_GetRightMem().data_isArrayEmpty() ||
  leftempty, 
  wxT("The second member is empty while it should not be"));
 mcUNUSED(leftempty);

 // recurse in the children
 mcElementHelpers::data_Check();
}

wxString mcMathMngHelpers::data_Debug(long flags) const
{
 int n = mcMathCore::Get()->m_nIndentationStep;
 wxString str = wxT("mcMathMng [\n") + wxString(wxT(' '), n) + wxT("LEFT MEMBER - ") + 
     data_GetLeftMem().data_GetDebug(n, flags) + 
     wxT("\n\n") + wxString(wxT(' '), n) + wxT("RIGHT MEMBER - ") +
     data_GetRightMem().data_GetDebug(n, flags) + 
     wxT("mcMathMng ]\n");
 return str;
}

#endif  // __MCDEBUG__

void mcMathMngHelpers::data_DeepCopy(const mcElementHelpers *p)
{
 const mcMathMngHelpers *mm = (const mcMathMngHelpers *)p;

 // use standard copy for simple variables
 mdata_nDataType = mm->mdata_nDataType;
 mgui_nCursorPos = mm->mgui_nCursorPos;
 
 // this will copy just the pointer and this is what we want...
 mgui_pStyleArray = mm->mgui_pStyleArray;
 
 // use deep copy for mcPolynomials
 if (mm->mdata_eLMember != mcEmptyElement)
  mdata_eLMember.data_DeepCopy(mm->mdata_eLMember);

 if (mm->mdata_eRMember != mcEmptyElement)
  mdata_eRMember.data_DeepCopy(mm->mdata_eRMember);
}

void mcMathMngHelpers::data_SetFilter(const mcFilter *p)
{
 mdata_eLMember.data_SetFilter(p);
 mdata_eRMember.data_SetFilter(p);
}
/*
mcElement mcMathMngHelpers::data_GetElemFromID(int id)
{
 mcElement p = data_GetLeftMem().data_GetElemFromID(id);  // BAD
 if (p == mcEmptyElement)
  return data_GetRightMem().data_GetElemFromID(id);
 return p;
}*/

void mcMathMngHelpers::data_GetConstSourceDest(const mcPolynomialHelpers **s, 
         const mcPolynomialHelpers **d, bool toleft) const
{
 if (!toleft) {

  // the elements to modify are placed in the first member
  if (s) *s = mdata_eLMember.hlp();
  if (d) *d = mdata_eRMember.hlp();

 } else {

  // the elements to modify are placed in the second member
  if (d) *d = mdata_eLMember.hlp();
  if (s) *s = mdata_eRMember.hlp();
 }
}

void mcMathMngHelpers::data_SetMember(bool left, const mcPolynomial &p, mcMathMngType newtype)
{
 if (p == mcEmptyPolynomial)
  return;

 // copy the given pointer
 if (left)
  data_GetLeftMem().data_DeepCopy(p.hlp());
 else
  data_GetRightMem().data_DeepCopy(p.hlp());

 // change our type ID
 mdata_nDataType = newtype;
}





// ----------------------------------------
// mcMATHMNG - GUI position functions
// ----------------------------------------

int mcMathMngHelpers::gui_GetXOfLeftMem() const
{
 // easy enough...
 return sgui_nSpaceLeftRight;
}

int mcMathMngHelpers::gui_GetXOfSeparator(int yoff) const
{
 mcUNUSED(yoff);
 return gui_GetXOfLeftMem()+data_GetLeftMem().gui_GetWidth()+sgui_nSpaceAroundSeparator;
}

int mcMathMngHelpers::gui_GetXOfRightMem() const
{
 return gui_GetXOfLeftMem()+data_GetLeftMem().gui_GetWidth()+sgui_nSpaceAroundSeparator+
   gui_GetSeparatorSize().GetWidth()+sgui_nSpaceAroundSeparator;
}


int mcMathMngHelpers::gui_GetYOfLeftMem() const
{
 // mcMathMng does not add any space above & below
 return 0;
}

int mcMathMngHelpers::gui_GetYOfSeparator(int yoff) const
{
 if (yoff < 0) yoff = gui_GetYAnchor();
 return yoff-(gui_GetSeparatorSize().GetHeight()/2);
}

int mcMathMngHelpers::gui_GetYOfRightMem() const
{
 return 0;
}

wxRect mcMathMngHelpers::gui_GetRectOfLeftMem() const
{
 return wxRect(gui_GetXOfLeftMem(), gui_GetYOfLeftMem(), 
   data_GetLeftMem().gui_GetWidth(), data_GetLeftMem().gui_GetHeight());
}

wxRect mcMathMngHelpers::gui_GetRectOfRightMem() const
{
 return wxRect(gui_GetXOfRightMem(), gui_GetYOfRightMem(), 
   data_GetRightMem().gui_GetWidth(), data_GetRightMem().gui_GetHeight());
}




// ----------------------------------------
// mcMATHMNG - GUI functions
// ----------------------------------------

// mcMATHMNG rendering:
//
//   x LEFTMEM y SEPARATOR y RIGHTMEM x
//
// where
//   x is sgui_nSpaceLeftRight
//   y is sgui_nSpaceAroundSeparator
//

void mcMathMngHelpers::gui_InitStyles()
{
 gui_DeleteStyles();
 
 // create the small & big styles copying the normal one...
 sgui_pNormalStyles = new mcStyleArray(mcElementHelpers::sgui_pDefaultStyles);
 sgui_pSmallStyles = new mcStyleArray(sgui_pNormalStyles);
 sgui_pBigStyles = new mcStyleArray(sgui_pNormalStyles);
 
 // they are all identic now: change the sizes
 sgui_pSmallStyles->ScaleSize(0.7f);
 sgui_pBigStyles->ScaleSize(2.0f);
}

void mcMathMngHelpers::gui_DeleteStyles()
{
 mcSAFE_DELETE(sgui_pSmallStyles);
 mcSAFE_DELETE(sgui_pNormalStyles);
 mcSAFE_DELETE(sgui_pBigStyles);
}

int mcMathMngHelpers::gui_GetYAnchor() const
{
 return mcMAX(data_GetLeftMem().gui_GetCenterLine(),
  data_GetRightMem().gui_GetCenterLine());
}

void mcMathMngHelpers::gui_DoRecalcSize()
{
 // first of all, recalc our separator's size
 gui_RecalcSeparatorSize();

 // set the height of this object
 mgui_sz.SetHeight(mcMAX(gui_GetYOfLeftMem(), gui_GetYOfRightMem())+
   mcMAX(data_GetLeftMem().gui_GetHeight(), data_GetRightMem().gui_GetHeight()));

 if (mdata_nDataType == mcMMT_EXPRESSION) {
 
  mgui_sz.SetWidth(gui_GetXOfLeftMem()+data_GetLeftMem().gui_GetWidth()+
      sgui_nSpaceLeftRight);

 } else {

  mgui_sz.SetWidth(gui_GetXOfRightMem()+data_GetRightMem().gui_GetWidth()+
      sgui_nSpaceLeftRight);
 }
}

void mcMathMngHelpers::gui_SelectSeparatorStyle(wxDC &dc) const
{
 // use the special text-settings
 gui_GetStyle(0)->GetSpecialTextSettings()->gui_Select(dc);
}

void mcMathMngHelpers::gui_RecalcSeparatorSize()
{
 // cannot calculate separator size if separator doesn't exist
 if (mdata_nDataType == mcMMT_EXPRESSION)
  return;

 // always use first member's style
 wxScreenDC dc;
 gui_SelectSeparatorStyle(dc);
 mgui_szSeparator = mcElementHelpers::gui_GetSizeOf(&dc, io_GetSeparatorSymbol());
}

void mcMathMngHelpers::gui_GetConstSelectionSourceDest(const mcPolynomialHelpers **s, 
           const mcPolynomialHelpers **d) const
{
 // use selected element count to decide
 if (data_GetLeftMem().gui_GetSelElemCount() > 0) {

  // the elements to modify are placed in the first member
  if (s) *s = mdata_eLMember.hlp();
  if (d) *d = mdata_eRMember.hlp();

 } else {

  // the elements to modify are placed in the second member
  if (d) *d = mdata_eLMember.hlp();
  if (s) *s = mdata_eRMember.hlp();
 }
}

int mcMathMngHelpers::gui_Draw(wxDC &hDC, int x, int y, long flags, const wxPoint &pt) const
{
 mcGUILOG(wxT("mcMathMngHelpers::gui_Draw [%s]"), mcTXTTHIS);
 
 long f1=mcDRW_ALLOW_TOTAL_SELECTION, f2=mcDRW_ALLOW_TOTAL_SELECTION;
 int n=-1, m, yoff;

 flags |= mcDRW_ALLOW_TOTAL_SELECTION;

/* // if a special array has been selected, reselect it here
 if (mgui_pStyleArray) {

  // use the mcElement::gui_SetStyleArray instead of the
  // mcElementHelpers::sgui_SetStyleArray: in this way the style
  // update will be recursive
  data_GetLeftMem().gui_SetStyleArray(mgui_pStyleArray);
  data_GetRightMem().gui_SetStyleArray(mgui_pStyleArray);
 }*/

 switch (mdata_nDataType) {
 case mcMMT_EXPRESSION:

  // draw only the left member
  n = data_GetLeftMem().gui_Draw(hDC, x+gui_GetXOfLeftMem(), 
         y+gui_GetYOfLeftMem(), flags, pt);
  break;

 case mcMMT_EQUATION:
 case mcMMT_INEQUALITY_NE:
 case mcMMT_INEQUALITY_G:
 case mcMMT_INEQUALITY_GE:
 case mcMMT_INEQUALITY_L:
 case mcMMT_INEQUALITY_LE:

  // is the mouse cursor over the left member ?
  if (flags & mcDRW_USEPOINT) {
   wxRect rc(gui_GetRectOfLeftMem());
   rc.Offset(x, y);

   if (rc.Inside(pt)) {
    f1 |= mcDRW_USEPOINT;
    f2 |= mcDRW_NONACTIVE;
   } else {
    f1 |= mcDRW_NONACTIVE;
    f2 |= mcDRW_USEPOINT;
   }
  }

  // this function is slow; call only once
  yoff = gui_GetYAnchor();

  // draw the first member aligned with tallest member
  n = data_GetLeftMem().gui_ExDraw(hDC, x+gui_GetXOfLeftMem(),
        y+gui_GetYOfLeftMem(), f1, pt, yoff);

  // draw the separator symbol vertically centered
  // using the style of the first member
  gui_SelectSeparatorStyle(hDC);
  hDC.DrawText(io_GetSeparatorSymbol(),
   x+gui_GetXOfSeparator(yoff),
   y+gui_GetYOfSeparator(yoff));

  // also draw the second member vertically centered
  m = data_GetRightMem().gui_ExDraw(hDC, x+gui_GetXOfRightMem(), 
        y+gui_GetYOfRightMem(), f2, pt, yoff);

  // set to the correct value the return value
  if (n == -1) n = m;
  break;

 default:
  mcASSERT(0, wxT("Invalid datatype value"));
 }

 return n;
}

mcElement &mcMathMngHelpers::gui_GetActiveElem(int x, int y, const wxPoint &pt)
{
 wxRect rc(gui_GetRectOfLeftMem());
 rc.Offset(x, y);
 int yoff = gui_GetYAnchor();

 // is it inside the left member ?
 if (rc.Inside(pt))
  return data_GetLeftMem().gui_ExGetActiveElem(rc.x, rc.y, pt, yoff);

 // or the right one ?
 return data_GetRightMem().gui_ExGetActiveElem(x+gui_GetXOfRightMem(), 
          y+gui_GetYOfRightMem(), pt, yoff);
}

mcMoveCursorRes mcMathMngHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes code;

 // move the cursor using the functions of the mcPolynomials
 if (mgui_nCursorPos == mcMATHMNG_LEFT)
  code = data_GetLeftMem().gui_MoveCursor(flag, modifiers);
 else
  code = data_GetRightMem().gui_MoveCursor(flag, modifiers);

 // check return code
 if (code == mcMCR_SETFOCUS_PREVIOUS) {

  if (mgui_nCursorPos == mcMATHMNG_LEFT || mdata_nDataType == mcMMT_EXPRESSION) {
   return mcMCR_SETFOCUS_PREVIOUS;
  } else {

   // cursor si now on the first member
   data_GetLeftMem().gui_SetCursorPos(mcCP_END);
   mgui_nCursorPos = mcMATHMNG_LEFT;
  }
 }

 if (code == mcMCR_SETFOCUS_NEXT) {
  if (mgui_nCursorPos == mcMATHMNG_RIGHT || mdata_nDataType == mcMMT_EXPRESSION) {
   return mcMCR_SETFOCUS_NEXT;
  } else {

   // cursor is now on the second member
   data_GetRightMem().gui_SetCursorPos(mcCP_BEGIN);
   mgui_nCursorPos = mcMATHMNG_RIGHT;
  }
 }

 if (code == mcMCR_SETFOCUS_ABOVE || code == mcMCR_SETFOCUS_BELOW)
  return code;
 return mcMCR_OKAY;
}

int mcMathMngHelpers::gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p)
{
 mcGUILOG(wxT("mcMathMngHelpers::gui_MoveCursorUsingPoint - moving to [%d;%d]"), p.x, p.y);

 // find in which rect is the mouse cursor located
 wxRect rc(gui_GetRectOfLeftMem());
 wxPoint pt(p);

 // is it in the first member ?
 if (rc.Inside(p)) {
  mgui_nCursorPos = mcMATHMNG_LEFT;

  pt.x -= rc.x;
  pt.y -= rc.y;
  return data_GetLeftMem().gui_MoveCursorUsingPoint(dc, p);
 }

 if (mdata_nDataType != mcMMT_EXPRESSION) {
 
  rc.x = gui_GetXOfSeparator();
  rc.y = gui_GetYOfSeparator();
  rc.width = gui_GetSeparatorSize().GetWidth();
  rc.height = gui_GetSeparatorSize().GetHeight();
  
  // is it on the separator symbol ?
  if (rc.Inside(p)) {
   
   // then we have to decide for the left or the right member:
   // the cursor cannot be in the middle of the symbol !!!
   rc.width /= 2;
   if (rc.Inside(p)) {
       mgui_nCursorPos = mcMATHMNG_LEFT;
          data_GetLeftMem().gui_SetCursorPos(mcCP_END);
           } else {
            mgui_nCursorPos = mcMATHMNG_RIGHT;
          data_GetRightMem().gui_SetCursorPos(mcCP_BEGIN);
            }
    }
 
  rc = gui_GetRectOfRightMem();

  // is it in the second member ?
  if (rc.Inside(p)) {
   mgui_nCursorPos = mcMATHMNG_RIGHT;

   pt.x -= rc.x;
   pt.y -= rc.y;
   return data_GetRightMem().gui_MoveCursorUsingPoint(dc, pt);
  }
 }

 return mcMCR_CANNOT_SETFOCUS;
}

int mcMathMngHelpers::gui_GetRelCursorPos(wxDC &hDC, wxPoint *ptCursorPos) const
{
 int n, yoff = -1;

 if (mdata_nDataType != mcMMT_EXPRESSION) {

  // get the center line from the tallest member
  yoff = gui_GetYAnchor();
 }

 if (mgui_nCursorPos == mcMATHMNG_LEFT) {

  n = data_GetLeftMem().gui_ExGetRelCursorPos(hDC, ptCursorPos, yoff);
  ptCursorPos->x += gui_GetXOfLeftMem();
  ptCursorPos->y += gui_GetYOfLeftMem();
 
 } else {

  n = data_GetRightMem().gui_ExGetRelCursorPos(hDC, ptCursorPos, yoff);
  ptCursorPos->x += gui_GetXOfRightMem();
  ptCursorPos->y += gui_GetYOfRightMem();
 }

 return n;
}

void mcMathMngHelpers::gui_OnSelect(wxDC &hDC, wxRect &rc)
{
 // check which mcPolynomial we must call
 wxRect leftrc(gui_GetRectOfLeftMem());
 wxRect rightrc(gui_GetRectOfRightMem());

 // and deselect the other
 if (leftrc.Intersects(rc)) {

  // select the left member
  rc.Offset(-leftrc.x, -leftrc.y);
  data_GetLeftMem().gui_OnSelect(hDC, rc);
  data_GetRightMem().gui_DeSelect();

 } else if (mdata_nDataType != mcMMT_EXPRESSION &&
    rightrc.Intersects(rc)) {

  // select the right member
  rc.Offset(-rightrc.x, -rightrc.y);
  data_GetRightMem().gui_OnSelect(hDC, rc);
  data_GetLeftMem().gui_DeSelect();

 } else {

  // deselect everything since the given rect does not intersect anything...
  gui_DeSelect();
  return;
 }

 // mark also ourselves as selected if we contain
 // something which is selected...
 if (data_GetLeftMem().gui_isSelected() ||
  data_GetRightMem().gui_isSelected())
  gui_Select();
}

void mcMathMngHelpers::gui_SetCursorPos(const mcCursorPos &cp)
{
 if (cp.isBegin()) {

  data_GetLeftMem().gui_SetCursorPos(mcCP_BEGIN);
  mgui_nCursorPos = mcMATHMNG_LEFT;

 } else if (cp.isEnd()) {

  // if the data inserted is an expression, the mcMATHMNG_RIGHT member is hidden:
  // we must move the cursor at the end of the mcMATHMNG_LEFT member...
  if (mdata_nDataType != mcMMT_EXPRESSION) {
   data_GetRightMem().gui_SetCursorPos(mcCP_END);
   mgui_nCursorPos = mcMATHMNG_RIGHT;
  } else {
   data_GetLeftMem().gui_SetCursorPos(mcCP_END);
   mgui_nCursorPos = mcMATHMNG_LEFT;
  }

 } else {

  mcASSERT(0, wxT("invalid flag"));
 }
}

void mcMathMngHelpers::gui_GetCursorPos(mcCursorPos &cp) const
{
 if (mgui_nCursorPos == mcMATHMNG_LEFT && 
  data_GetLeftMem().gui_GetCursorPos().isBegin()) {
  cp.gui_Push(mcCP_BEGIN);
  return;
 }

 if (mgui_nCursorPos == mcMATHMNG_RIGHT && 
  data_GetRightMem().gui_GetCursorPos().isEnd()) {
  cp.gui_Push(mcCP_END);
  return;
 }

 cp.gui_Push(mgui_nCursorPos);
 if (mgui_nCursorPos == mcMATHMNG_LEFT)
  data_GetLeftMem().gui_GetCursorPos(cp);
 else
  data_GetRightMem().gui_GetCursorPos(cp);
}

mcInputRes mcMathMngHelpers::gui_Input(const mcKey &key, mcElement *)
{
 mcMathMngType t = mcMMT_NOT_SET;
 mcElement p;
 int r;

 // intercept here the keypressed used to create the relational operators....
 if (gui_isRelationalOp(key)) {

  // convert keypress to relational operator...
  t = math_GetMathTypeFrom(key);
  
  // change current data type....
  mcMathMngType old = mdata_nDataType;
  bool b = (t == mdata_nDataType);
  if (t != mcMMT_NOT_SET) mdata_nDataType = t;

  // did the user already typed such relation operator ?
  if (b && t != mcMMT_NOT_SET) {
   
   // ...yes...
   mcMathCore::Get()->SyntaxError(wxT("This data already contains this symbol"));
   return mcIR_OKAY;
  }
  
  // special case: there was no previous relational operator...
  if (old == mcMMT_EXPRESSION) {
   
   // start to put data in second member;
   mgui_nCursorPos = mcMATHMNG_RIGHT;   // switch to the second member
   data_GetRightMem().gui_SetCursorPos(mcCP_BEGIN);
   
   // reset the mcMATHMNG_RIGHT member
   data_GetRightMem().data_DeleteAll();
   data_GetRightMem().gui_AddNewEmptyMonomial();
   gui_RecalcSize();
  }
  
  return mcIR_OKAY;
 }

 // let our mcPolynomial do everything
 mcGUILOG(wxT("mcMathMngHelpers::gui_Input - the character to process is [%c]"), key.GetKeyCode());
 mcPolynomial &pmem = (mgui_nCursorPos == mcMATHMNG_LEFT) ? data_GetLeftMem() : data_GetRightMem();
 r = pmem.gui_Input(key, &p); 

 switch (r) {
 case mcIR_OKAY:
  break;

 case mcIR_DELETE_PREVIOUS:
 case mcIR_DELETE_NEXT:
  if ((r == mcIR_DELETE_PREVIOUS && mgui_nCursorPos == mcMATHMNG_LEFT) ||
   (r == mcIR_DELETE_NEXT && mgui_nCursorPos == mcMATHMNG_RIGHT)) {

   // there is nothing before...
   mcMathCore::Get()->SyntaxError(wxT("Cannot delete !!"));
  } else {

   // delete the separator symbol
   mdata_nDataType = mcMMT_EXPRESSION;
   gui_SetCursorPos(mcCP_END);
  }
  break;

 case mcIR_DELETE_THIS:
  if (mgui_nCursorPos == mcMATHMNG_LEFT) {

   // user is trying to delete the only empty box remained
   // in the expression... stop him
   mcMathCore::Get()->SyntaxError(wxT("Cannot delete this empty box"));

   // reset the mcMATHMNG_LEFT member
   data_GetLeftMem().gui_AddNewEmptyMonomial();

  } else {

   // delete the separator symbol and modify data type
   mdata_nDataType = mcMMT_EXPRESSION;
   mgui_nCursorPos = mcMATHMNG_LEFT;
   data_GetLeftMem().gui_SetCursorPos(mcCP_END);
  }
  break;

 default:
  mcASSERT(0, wxT("Unhandled return flag..."));
 }


 mcGUILOG(wxT("mcMathMngHelpers::gui_Input - after processing: [%s]"), io_GetInlinedExpr().c_str());
 gui_RecalcSize();

 return mcIR_OKAY;
}

mcInsertRes mcMathMngHelpers::gui_Insert(const mcElement &toinsert, mcElement *newelem)
{
 switch (mgui_nCursorPos) {
 case mcMATHMNG_LEFT:
  data_GetLeftMem().gui_Insert(toinsert, NULL);
  break;

 case mcMATHMNG_RIGHT:
  data_GetRightMem().gui_Insert(toinsert, NULL);
  break;
 }

 return mcINSR_OKAY;
}

mcElement mcMathMngHelpers::gui_GetSelection() const
{
 // just create a new mcMathMng containing the selected
 // portions of the two members.
 // Since only one of the two members can contain selections,
 // one of the two members of the returned mcMathMng will be empty...
 mcMathMng res;

 if (data_GetLeftMem().gui_isSelected()) {
  res.data_GetLeftMem() = data_GetLeftMem().gui_GetSelection();
 } else {
  res.data_GetRightMem() = data_GetRightMem().gui_GetSelection();
 }

 return res;
}

void mcMathMngHelpers::gui_DeleteSelection()
{
 data_GetLeftMem().gui_DeleteSelection();
 data_GetRightMem().gui_DeleteSelection();

 if (data_GetLeftMem().data_isArrayEmpty())
  data_GetLeftMem().gui_AddNewEmptyMonomial();
 if (data_GetRightMem().data_isArrayEmpty())
  data_GetRightMem().gui_AddNewEmptyMonomial();

 gui_SetCursorPos(mcCP_BEGIN);
 gui_RecalcSize();
}

bool mcMathMngHelpers::gui_isRelationalOp(const mcKey &key)
{
 wxChar c = key.GetKeyCode();

 if ((c == mcMMRO_LESS ||
  c == mcMMRO_GREATER ||
  c == mcMMRO_EQUAL) &&
  key.isSpecialKey())
  return TRUE;

 if ((c == mcMMRO_LESS_OR_EQUAL ||
  c == mcMMRO_GREATER_OR_EQUAL ||
  c == mcMMRO_NOT_EQUAL) &&
  key.isSpecialKey())
  return TRUE;

 return FALSE;
}

void mcMathMngHelpers::gui_UpdateExpDepth()
{
 data_GetLeftMem().gui_SetAtSameLevelOf(this);
 data_GetRightMem().gui_SetAtSameLevelOf(this);

 // always call base version
 mcElementHelpers::gui_UpdateExpDepth();
}




// ----------------------------------------
// mcMATHMNG - GUI+MATH functions
// ----------------------------------------

void mcMathMngHelpers::gui_MoveSel()
{
 mcPolynomialHelpers *psource, *pdest;

 // init the psource and pdest variables
 gui_GetSelectionSourceDest(&psource, &pdest);

 // be sure that the selection is extended at least to an entire monomial
 if (psource->math_GetSelCount() == 1)
  psource->math_GetSel(0).gui_SelectAll();

 // first of all, move the selection in a temporary polynomial
 mcPolynomial sel(psource->gui_GetSelection());
 psource->gui_DeleteSelection();

 // change all the signs of the temporary polynomial
 sel.math_ChangeAllSigns();

 // add the temporary polynomial to the destination
 pdest->math_Add(sel, NULL, TRUE);

 // clean up and reset
 //ResetGUI();
}

void mcMathMngHelpers::gui_AddSubSel()
{
 mcPolynomialHelpers *psource;

 // init the psource and pdest variables
 gui_GetSelectionSourceDest(&psource, NULL);

 // be sure that the selection is extended at least to an entire monomial
 if (psource->math_GetSelCount() == 1)
  psource->math_GetSel(0).gui_SelectAll();

 // just create two copies of the selection
 mcPolynomial sel(psource->gui_GetSelection());
 mcPolynomial sel2(sel);

 // and add/sub both of them in the source pointer
 psource->math_SimpleAdd(sel);
 psource->math_SimpleSubtract(sel2);

 // clean up and reset
 //ResetGUI();
}

void mcMathMngHelpers::gui_MultiplyBySel(bool bDivide)
{
 mcElement tmp;

 // a little check
 mcASSERT(mdata_nDataType != mcMMT_EXPRESSION, wxT("Invalid data type"));

 // find which is the member which contains selected elements
 int n1 = data_GetLeftMem().gui_GetSelElemCount();
 int n2 = data_GetRightMem().gui_GetSelElemCount();

 // gets the selection (the gui_GetSelection() function returns a copy
 // of the selection, so we need to delete the tmp pointer at the
 // end of the function...)
 if (n1)
  tmp = data_GetLeftMem().gui_GetSelection();
 else if (n2)
  tmp = data_GetRightMem().gui_GetSelection();
 else
  return;   // no selection

 // the gui_GetSelection() function may return something different from
 // a mcPolynomial... check it
 /*if (tmp.data_GetType() != mcET_ELEMENTARRAY) {

 }*/

 // now, multiply both expressions by tmp
 if (bDivide) {
  data_GetLeftMem().math_SimpleDivideBy(tmp);
  data_GetRightMem().math_SimpleDivideBy(tmp);
 } else {
  data_GetLeftMem().math_SimpleMultiplyBy(tmp);
  data_GetRightMem().math_SimpleMultiplyBy(tmp);
 }

 //ResetGUI();
}

void mcMathMngHelpers::gui_GetPossibleOperations(mcMathMngCmdID *pCmdID) const
{
 mcASSERT(pCmdID != NULL, wxT("invalid pointer"));
 switch (mdata_nDataType) {

 case mcMMT_NOT_SET:
 case mcMMT_EXPRESSION:

  // don't break here

  // for equations and all type of inequalities...
 case mcMMT_EQUATION:
 case mcMMT_INEQUALITY_NE:
 case mcMMT_INEQUALITY_G:
 case mcMMT_INEQUALITY_GE:
 case mcMMT_INEQUALITY_L:
 case mcMMT_INEQUALITY_LE:

  pCmdID[0] = mcMMC_SIMPLIFY;
  pCmdID[1] = mcMMC_EXPAND;

  break;
 }
}

wxArrayString mcMathMngHelpers::gui_GetPossibleOpOnSel(mcMathMngCmd *pCmdID) const
{
 wxArrayString arr;
 wxString str;

 // WARNING: PREREQUISITE FOR THIS FUNCTION IS THAT
 //      AT LEAST ONE MONOMIAL IS SELECTED SOMEWHERE
 //      IN THE OBJECT

 mcASSERT(pCmdID != NULL, wxT("invalid pointer"));

/* switch (mdata_nDataType) {

 case mcMMT_NOT_SET:
 case mcMMT_EXPRESSION:

  // don't break here

  // for equations and all type of inequalities...
 case mcMMT_EQUATION:
 case mcMMT_INEQUALITY_NE:
 case mcMMT_INEQUALITY_G:
 case mcMMT_INEQUALITY_GE:
 case mcMMT_INEQUALITY_L:
 case mcMMT_INEQUALITY_LE:

  // add the "move" commands
  if (data_GetLeftMem().gui_GetSelElemCount() > 0) {

   // this element is placed on the first member
   arr.Add(wxT("Move to second member"));
  } else if (data_GetRightMem().gui_GetSelElemCount() > 0) {

   // this element is placed on the second member
   arr.Add(wxT("Move to first member"));
  }

  pCmdID[0] = mcMMC_MOVE_SEL;

  // add the "multiply by" command
  str.Printf(wxT("Multiply everything by this"));
  arr.Add(str);
  pCmdID[1] = mcMMC_MULT_SEL;

  // add the "divide by" command
  str.Printf(wxT("Divide everything by this"));
  arr.Add(str);
  pCmdID[2] = mcMMC_DIV_SEL;

  // add the "add and subtract by" command
  str.Printf(wxT("math_Add and subtract this"));
  arr.Add(str);
  pCmdID[3] = mcMMC_ADDSUB_SEL;

  break;
 }*/

 return arr;
}

void mcMathMngHelpers::gui_ExecCmdOnSel(mcMathMngCmdID cmdid)
{
 long flags = mcEXPSIM_NOFLAGS;

 switch (cmdid) {

  // operations available on selection
 case mcMMC_MOVE_SEL:
  gui_MoveSel();
  break;
 case mcMMC_MULT_SEL:
  gui_MultiplyBySel(FALSE);
  break;
 case mcMMC_DIV_SEL:
  gui_MultiplyBySel(TRUE);
  break;
 case mcMMC_ADDSUB_SEL:
  gui_AddSubSel();
  break;

  // global operations
 case mcMMC_SIMPLIFY:
  math_Simplify(flags, (mcElement *)NULL);
  break;
 case mcMMC_EXPAND:
  math_Expand(flags, (mcElement *)NULL);

  // here I usually put debug routines just to test some
  // functions....
  //bool b = data_GetLeftMem().math_hasSameContentOf(&m_eRMember);
  //bool b = data_GetLeftMem().math_ContainsUnknowns(NULL);

  //mcNumber *mynum = new mcNumber(NULL);
  //mynum.math_Set(2.0);
  //mcElement p = data_GetLeftMem().math_Find(1, mynum);

  break;
 }
}






// ----------------------------------------
// mcMATHMNG - IO functions
// ----------------------------------------

wxXml2Node mcMathMngHelpers::io_GetMathML(bool bGetPresentation) const
{
 wxString opname;

 // export MathML
 switch (mdata_nDataType) {
 case mcMMT_NOT_SET:
  break;

 case mcMMT_EXPRESSION:
  return data_GetLeftMem().io_GetMathML(bGetPresentation);

 case mcMMT_EQUATION:
 case mcMMT_INEQUALITY_G:
 case mcMMT_INEQUALITY_L:
  opname = io_GetSeparatorSymbol();
  break;

 case mcMMT_INEQUALITY_NE:
  opname = wxT("&#x02260;");
  break;

 case mcMMT_INEQUALITY_GE:
  opname = wxT("&#x02265;");
  break;

 case mcMMT_INEQUALITY_LE:
  opname = wxT("&#x02264;");
  break;
 }

 wxXml2Node global, op;
 wxXml2Node left(data_GetLeftMem().io_GetMathML(bGetPresentation));
 wxXml2Node right(data_GetRightMem().io_GetMathML(bGetPresentation));
 
 if (bGetPresentation) {

  // create an MROW using the <MO>opname</MO> to divide the two members
   global.CreateTemp(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("mrow"));
  op.CreateTemp(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mo"), opname);
  
 } else {
 
  // THIS HAS NOT BEEN CHECKED !!!
  global.CreateTemp(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("apply"));
  op.CreateTemp(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("EQ"));
  }

 // set the MathML of the left & right member
 global.AddChild(left);
 global.AddChild(op);
 global.AddChild(right);

 return global;
}

wxString mcMathMngHelpers::io_GetSeparatorSymbol(bool bUseSpecialChars) const
{
 if (!bUseSpecialChars) {
  switch (mdata_nDataType) {
  case mcMMT_INEQUALITY_NE:
   return wxT("!=");
  case mcMMT_INEQUALITY_GE:
   return wxT(">=");
  case mcMMT_INEQUALITY_LE:
   return wxT("<=");

  default: // all other cases are handled below...
   break;
  }
 }
 
 if (mdata_nDataType == mcMMT_EXPRESSION)
  return wxEmptyString;
 
 // see math_GetMathTypeFrom() for more info...
 wxChar sym = (wxChar)math_GetRelationalOpFor(mdata_nDataType);
 
 return wxString(sym);
}
 /*dest = wxString(wxT(' '), indent) + wxT("<SEMANTICS>\n") + io_GetMathML(indent+mcMathCore::Get()->m_nIndentationStep) +
  wxString(wxT(' '), indent+mcMathCore::Get()->m_nIndentationStep) + wxT("<ANNOTATION-XML ENCODING=\")MathML-Content\wxT(">\n") +
  GetContentMathML(indent+2*mcMathCore::Get()->m_nIndentationStep) + wxString(wxT(' '), indent+mcMathCore::Get()->m_nIndentationStep) +
  wxT("</ANNOTATION-XML>\n") + wxString(wxT(' '), indent) + wxT("</SEMANTICS>\n");*/

wxString mcMathMngHelpers::io_GetInlinedExpr() const
{
 // just merge the two inlined expressions...
 wxString res = data_GetLeftMem().io_GetInlinedExpr();
 
 if (mdata_nDataType != mcMMT_EXPRESSION)
  res += io_GetSeparatorSymbol(FALSE) + data_GetRightMem().io_GetInlinedExpr();

 return res;
}

bool mcMathMngHelpers::io_ImportPresentationMathML(wxXml2Node maintag, wxString &pErr)
{
 // import only presentation math ml... ignore semantics\annotation TAGS
 if (maintag.GetName() == wxT("semantics"))
  maintag = maintag.GetChildren();

 // presentation markup should begin with an MROW tag
 if (maintag.GetName() != wxT("mrow")) {
  if (pErr) pErr = wxT("Presentation markup should be enclosed in MROW tag");
  return FALSE;
 }

 // search a separator symbol
 //if (XmlSearchTagInChildren(main, "mo")

 // all import functions requires the tags (not their content)
 // to be lowercase...
 maintag.MakeLower();

 data_GetLeftMem().io_ImportPresentationMathML(maintag, pErr);

 return TRUE;
}

bool mcMathMngHelpers::io_ImportInlinedExpr(const wxString &toimport, int *, wxString &perr)
{
 wxString lmem, rmem;
 wxString err;

 // reset left & right members
 data_GetLeftMem().data_DeleteAll();
 data_GetRightMem().data_DeleteAll();

 // VERY IMPORTANT: remove all the spaces from the input string
 wxString str(toimport);
 str.Replace(wxT(" "), wxT(""));
 if (str.IsEmpty()) 
  return TRUE;  // nothing to import ?

 // check which type of math data we must decode...
 if (str.Contains(wxT(">=")))
  mdata_nDataType = mcMMT_INEQUALITY_GE;
 else if (str.Contains(wxT("<=")))
  mdata_nDataType = mcMMT_INEQUALITY_LE;
 else if (str.Contains(wxT(">")))
  mdata_nDataType = mcMMT_INEQUALITY_G;
 else if (str.Contains(wxT("<")))
  mdata_nDataType = mcMMT_INEQUALITY_L;
 else if (str.Contains(wxT("!=")))
  mdata_nDataType = mcMMT_INEQUALITY_NE;
 else if (str.Contains(wxT("=")) || str.Contains(wxT("==")))
  mdata_nDataType = mcMMT_EQUATION;
 else
  mdata_nDataType = mcMMT_EXPRESSION;

 // now, split the given string in two main tokens;
 // one for the left and one for the right member
 int n = str.Len();
 if (mdata_nDataType != mcMMT_EXPRESSION) {
  int s = str.Find(io_GetSeparatorSymbol(FALSE));

  mcASSERT(n != -1, wxT("A separator has been previously detected..."));
  lmem = str.Left(s);

  // in right member string to import, do not include
  // the separator symbol....
  rmem = str.Right(n-s-1);

 } else {

  // the entire string should be parsed by left member...
  lmem = str;
 }

 // import LEFT member string
 bool b = data_GetLeftMem().io_ImportInlinedExpr(lmem, &n, err);  

 // eventually import RIGHT member string
 if (mdata_nDataType != mcMMT_EXPRESSION) {

  if (rmem.IsEmpty())
   data_GetRightMem().math_WrapNumber(0);
  else
   b &= data_GetRightMem().io_ImportInlinedExpr(rmem, &n, err);
 }

 // if we have to report an error, copy the string into the given pointer
 if (perr) perr = err;

 return b;
}







// ----------------------------------------
// mcMATHMNG - math functions
// ----------------------------------------

/*void mcMathMngHelpers::ResetGUI()
{
 if (!mcMathCore::Get()->isGUIEnabled())
  return;
 
 // update gui
 gui_DeepRecalcSize();
 gui_DeSelect();

 // old cursor position maybe wrong now....
 gui_SetCursorPos(mcCP_BEGIN);
}*/
bool mcMathMngHelpers::math_Compare(const mcElement &p, long flags) const
{
 if (!math_CompareThisOnly(p, flags))
  return FALSE;

 const mcMathMng &m = (const mcMathMng &)p;
 if (!data_GetLeftMem().math_Compare(m.data_GetLeftMem(), flags))
  return FALSE;
 if (!data_GetRightMem().math_Compare(m.data_GetRightMem(), flags))
  return FALSE;
 return TRUE;
}

mcMathMngRelationalOp mcMathMngHelpers::math_GetRelationalOpFor(mcMathMngType type)
{
 switch (type) {
 case mcMMT_INEQUALITY_L:
  return mcMMRO_LESS;
 case mcMMT_INEQUALITY_G:
  return mcMMRO_GREATER;
 case mcMMT_EQUATION:
  return mcMMRO_EQUAL;
 case mcMMT_INEQUALITY_GE:
  return mcMMRO_GREATER_OR_EQUAL;
 case mcMMT_INEQUALITY_NE:
  return mcMMRO_NOT_EQUAL;
 case mcMMT_INEQUALITY_LE:
  return mcMMRO_LESS_OR_EQUAL;

 case mcMMT_NOT_SET:  // invalid values of type
 case mcMMT_EXPRESSION:
  return (mcMathMngRelationalOp)-1;
 }
 
 return mcMMRO_EQUAL;
}

mcMathMngType mcMathMngHelpers::math_GetMathTypeFor(mcMathMngRelationalOp type)
{
 switch (type) {
 case mcMMRO_LESS:
  return mcMMT_INEQUALITY_L;
 case mcMMRO_GREATER:
  return mcMMT_INEQUALITY_G;
 case mcMMRO_EQUAL:
  return mcMMT_EQUATION;
 case mcMMRO_GREATER_OR_EQUAL:
  return mcMMT_INEQUALITY_GE;
 case mcMMRO_NOT_EQUAL:
  return mcMMT_INEQUALITY_NE;
 case mcMMRO_LESS_OR_EQUAL:
  return mcMMT_INEQUALITY_LE;
 }
 
 return mcMMT_NOT_SET;
}

mcMathMngType mcMathMngHelpers::math_GetMathTypeFrom(const mcKey &key)
{
 // the mcMathMngRelationalOp enumeration values coincide with the
 // ASCII values of the keys used to produce them...
 mcMathMngRelationalOp r = (mcMathMngRelationalOp)key.GetKeyCode();

 // but to produce a relational op, we must also check that
 // the key used was a special key...
 if (!key.isSpecialKey())
  return mcMMT_NOT_SET;

 return math_GetMathTypeFor(r);
}

bool mcMathMngHelpers::math_CompareThisOnly(const mcElement &e, long flags) const
{
 const mcMathMng &p = (const mcMathMng &)e;
 bool res = TRUE;

 if (!mcElementHelpers::math_CompareThisOnly(p, flags))
  return FALSE;
 
 // compare members
 res &= data_GetLeftMem().math_Compare(p.data_GetLeftMem(), flags);
 res &= data_GetRightMem().math_Compare(p.data_GetRightMem(), flags);

 return res;
}

bool mcMathMngHelpers::math_ContainsInvalidSymbols() const
{
 // check if we have some unregistered symbols in the left/right member...
 if (data_GetLeftMem().math_ContainsInvalidSymbols() ||
  data_GetRightMem().math_ContainsInvalidSymbols())
  return TRUE;
 return FALSE;
}

mcExpSimRes mcMathMngHelpers::math_Simplify(long lflags, long rflags)
{
 // simplify the left member
 mcLOG(wxT("mcMathMngHelpers::math_Simplify [%s] - simplifying the left member"), mcTXT(mdata_eLMember));
 mcExpSimRes n1 = data_GetLeftMem().math_Simplify(lflags);

 if (mdata_nDataType == mcMMT_EXPRESSION)
  return n1;  // we have finished...

 // simplify the right member
 mcLOG(wxT("mcMathMngHelpers::math_Simplify [%s] - simplifying the right member"), mcTXT(mdata_eRMember));
 mcExpSimRes n2 = data_GetRightMem().math_Simplify(rflags);

 // if we have finished to simplify the two polynomials
 if (n1 == n2 && n1 == mcESR_DONE) {

  // now the hard work: our aim is to make the data shorter.
  // thus, we must move the unknowns to the left...
  //for (int i=0; i < 
 }

 // if both left & right member has completed their simplification...
 if (n1 == n2 && n1 == mcESR_DONE)
  return mcESR_DONE;
 return mcESR_NOTFINISHED;
}

mcExpSimRes mcMathMngHelpers::math_Expand(long lflags, long rflags)
{
 mcExpSimRes n1 = data_GetLeftMem().math_Expand(lflags);

 if (mdata_nDataType != mcMMT_EXPRESSION)
  data_GetRightMem().math_Expand(rflags);

 //ResetGUI();
 return n1;
}
/*
bool mcMathMngHelpers::isComplete() const
{
 // mcEmptyBox and mcParenthesis (which are different from mcBracket)
 // are not accepted in math operations...
 if (data_GetLeftMem().data_GetNumOfElemType(mcET_EMPTYBOX) > 0)
  return FALSE;
 if (data_GetLeftMem().data_GetNumOfElemType(mcET_PARENTHESIS) > 0)
  return FALSE;

 if (mdata_nDataType != mcMMT_EXPRESSION) {
  if (data_GetRightMem().data_GetNumOfElemType(mcET_EMPTYBOX) > 0)
   return FALSE;
  if (data_GetRightMem().data_GetNumOfElemType(mcET_PARENTHESIS) > 0)
   return FALSE;
 }

 return TRUE;
}*/

bool mcMathMngHelpers::math_isMaxSimplified() const
{
 // both left & right members must be simplified to
 // consider this entire object as simplified...
 return data_GetLeftMem().math_isMaxSimplified(mcEXPSIM_NOFLAGS) &&
  data_GetRightMem().math_isMaxSimplified(mcEXPSIM_NOFLAGS);
}

bool mcMathMngHelpers::math_isConstant() const
{
 return data_GetLeftMem().math_isConstant() &&
  data_GetRightMem().math_isConstant();
}

mcMathType mcMathMngHelpers::math_GetMathType() const
{
 // get polynomial classifications
 mcMathType mt = data_GetLeftMem().math_GetMathType();
 switch (mdata_nDataType) {

 case mcMMT_NOT_SET:
 case mcMMT_EXPRESSION:
  return mt;

  // for equations and all type of inequalities...
 case mcMMT_EQUATION:
 case mcMMT_INEQUALITY_NE:
 case mcMMT_INEQUALITY_G:
 case mcMMT_INEQUALITY_GE:
 case mcMMT_INEQUALITY_L:
 case mcMMT_INEQUALITY_LE:
  mt.math_Add(data_GetRightMem().math_GetMathType());
  return mt;
 }

 // this should never be returned !
 mcMathType invalid(mcMTL1_NOT_RECOGNIZED, 
  mcMTL2_NOT_RECOGNIZED, mcMTL3_NOT_RECOGNIZED);
 return invalid;
}

void mcMathMngHelpers::math_Move(int mathidx, bool toleft)
{
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);
 
 mcASSERT(mathidx < s->math_GetCount(), wxT("invalid index"));
 
 // do not move a monomial containing a zero mcNumber
 if (s->math_Get(mathidx).math_isWrappingOnly(0.0))
  return;

 // before removing the monomial, get its sign
 int sign = s->math_GetSign(mathidx);

 // clone & remove from the source member the mathidx-th monomial 
 mcMonomial p = s->math_Get(mathidx);
 s->math_Remove(mathidx);
 
 // put it in the left member adding/subtracting if the sign
 // is respectively negative/positive...
 d->math_SimpleAdd(p, (sign == -1 ? TRUE : FALSE));
}

void mcMathMngHelpers::math_MoveSymbol(const mcSymbolProperties *sym, bool toleft)
{
 int offset = 0;
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);

 // we need to do s.math_GetCount() cycles and to start
 // with the elements placed on the left of the source polynomial
 // (offset is initially zero) so that we can be sure that the
 // first offset-th elements must not be moved and "offset" is a
 // valid index; if we would have started from the right, then
 // the index could become invalid in some cases...
 for (int i=s->math_GetCount(); i > 0; i--) {

  // move only monomials containing a symbol contained in the given mcSymbolArray...
  if (s->math_Get(offset).math_ContainsSymbol(sym))
   math_Move(offset, toleft); // still try with the offset-th
  else
   offset++; // try with next
 }
}

void mcMathMngHelpers::math_MoveFreeFrom(const mcSymbolProperties *sym, bool toleft)
{
 int offset = 0;
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);

 for (int i=s->math_GetCount(); i > 0; i--) {

  // move only monomials that do not contain symbols...
  if (!s->math_Get(offset).math_ContainsSymbol(sym))
   math_Move(offset, toleft); // still try with the offset-th
  else
   offset++; // try with next
 }
}

void mcMathMngHelpers::math_MoveSymbols(const mcSymbolArray *arr, bool toleft)
{
 int offset = 0;
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);

 for (int i=s->math_GetCount(); i > 0; i--) {

  // move only monomials containing a symbol contained in the given mcSymbolArray...
  if (s->math_Get(offset).math_ContainsOneOf(arr))
   math_Move(offset, toleft); // still try with the offset-th
  else
   offset++; // try with next
 }
}

void mcMathMngHelpers::math_MoveNonSymbol(bool toleft)
{
 int offset = 0;
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);

 for (int i=s->math_GetCount(); i > 0; i--) {

  // move only monomials that do not contain symbols...
  if (!s->math_Get(offset).math_ContainsSymbols())
   math_Move(offset, toleft); // still try with the offset-th
  else
   offset++; // try with next
 }
}

void mcMathMngHelpers::math_MoveUnknowns(bool toLeft)
{ math_MoveSymbols(&mcSymbol::arrUnknowns, toLeft); }

void mcMathMngHelpers::math_MoveConstants(bool toLeft)
{ math_MoveSymbols(&mcSymbol::arrConstants, toLeft); }

void mcMathMngHelpers::math_MoveParameters(bool toLeft)
{ math_MoveSymbols(&mcSymbol::arrParameters, toLeft); }

void mcMathMngHelpers::math_MoveAll(bool toleft)
{
 mcPolynomialHelpers *s = NULL, *d = NULL;
 data_GetSourceDest(&s, &d, toleft);

 // move all...
 for (int i=s->math_GetCount(); i > 0; i--)
  math_Move(0, toleft);
}




// -------------------------------------------------
// mcMATHMNG - functions working with polynomials 
// -------------------------------------------------

mcBasicOpRes mcMathMngHelpers::math_MultiplyBy(const mcElement &pol, mcElement *pp)
{
 mcBasicOpRes r = data_GetLeftMem().math_MultiplyBy(pol, pp);

 if (mdata_nDataType != mcMMT_EXPRESSION)
  data_GetRightMem().math_SimpleMultiplyBy(pol);

 return r;
}

mcBasicOpRes mcMathMngHelpers::math_DivideBy(const mcElement &p, mcElement *pp)//mcPolynomial &pol)
{
 /*data_GetLeftMem().math_SimpleDivideBy(pol);
 
 if (mdata_nDataType != mcMMT_EXPRESSION)
  data_GetRightMem().math_SimpleDivideBy(pol);*/

 mcBasicOpRes r2 = data_GetLeftMem().math_DivideBy(p, pp);
 r2 = data_GetRightMem().math_DivideBy(p, pp);

 return r2;
}

mcBasicOpRes mcMathMngHelpers::math_Add(const mcElement &p, mcElement *pp, bool add)
{
 mcBasicOpRes r = data_GetLeftMem().math_Add(p, pp, add);

 if (mdata_nDataType != mcMMT_EXPRESSION)
  data_GetRightMem().math_SimpleAdd(p, add);

 return r;
}

mcBasicOpRes mcMathMngHelpers::math_Subtract(const mcElement &p, mcElement *pp)
{
 mcBasicOpRes r = data_GetLeftMem().math_Subtract(p, pp);
 
 if (mdata_nDataType != mcMMT_EXPRESSION)
  data_GetRightMem().math_SimpleSubtract(p);

 return r;
}




// -------------------------------------------------
// mcMATHMNG - functions working with monomials 
// -------------------------------------------------

#define WRAP_MONOMIAL(fncname)        \
 mcPolynomial pol;          \
 pol.data_AddNewMonomial(mon, -1, TRUE);     \
 fncname(pol); 

void mcMathMngHelpers::math_MultiplyBy(const mcMonomial &mon)
{ WRAP_MONOMIAL(math_MultiplyBy); }

void mcMathMngHelpers::math_DivideBy(const mcMonomial &mon)
{ WRAP_MONOMIAL(math_DivideBy); }




// -------------------------------
// mcMATHMNG - general functions
// -------------------------------

mcRealValue mcMathMngHelpers::math_Evaluate() const
{
 mcRealValue val1 = data_GetLeftMem().math_Evaluate();
 if (mdata_nDataType == mcMMT_EXPRESSION) return val1;
 
 // calc also right member's value
 mcRealValue val2 = data_GetRightMem().math_Evaluate();
 if (val1 == *mcRealValue::pNAN || val2 == *mcRealValue::pNAN)
  return *mcRealValue::pNAN;

 return val1-val2;  // transport right member's result to left member...
}

mcRealValue mcMathMngHelpers::math_GetLenght() const
{
 if (mdata_nDataType == mcMMT_EXPRESSION)
  return 0.5;  // the simplest
 if (mdata_nDataType == mcMMT_EQUATION)
  return 1.0;

 // inequalities are the most difficult...
 return 1.5;
}

mcRealValue mcMathMngHelpers::math_GetTotalLenght() const
{
 if (mdata_nDataType == mcMMT_EXPRESSION)
  return data_GetLeftMem().math_GetTotalLenght()+math_GetLenght();
  
 // just sum the lenght of the two members + a little value for the separator
 return data_GetLeftMem().math_GetTotalLenght()+
    data_GetRightMem().math_GetTotalLenght()+math_GetLenght();
}

mcElement mcMathMngHelpers::math_Find(int n, const mcElement &tofind, long flags, int *pos) const
{
 int left = data_GetLeftMem().math_GetCountOf(tofind, flags);
 if (left <= n) {
  // the left member does not have enough occurrences of 'tofind'
  n-=left;
 } else {
 
  // the required occurrence is in the left member
  if (pos) *pos = 0;
   return data_GetLeftMem().math_Find(n, tofind, flags);  
 }

 if (pos) *pos = 1;
 return data_GetRightMem().math_Find(n, tofind, flags);
}

int mcMathMngHelpers::math_GetCountOf(const mcElement &tocount, long flags) const
{
 return data_GetLeftMem().math_GetCountOf(tocount, flags) +
   data_GetRightMem().math_GetCountOf(tocount, flags);
}

int mcMathMngHelpers::math_Replace(const mcElement &tofind, int occ, long flags,
        const mcElement &replacement, bool addchildren)
{
 int total = 0;
 total += data_GetLeftMem().math_Replace(tofind, occ, flags, replacement, addchildren);
 total += data_GetRightMem().math_Replace(tofind, occ, flags, replacement, addchildren);

 return total;
}

int mcMathMngHelpers::math_GetSymbolList(mcSymbol **arr, int size, const mcSymbol &tofind, 
        bool left) const
{
 if (left)
  return data_GetLeftMem().math_GetSymbolList(arr, size, tofind);
 return data_GetRightMem().math_GetSymbolList(arr, size, tofind);
}

mcBasicOpRes mcMathMngHelpers::math_RaiseTo(const mcPolynomial &pol)
{
 data_GetLeftMem().math_SimpleRaiseTo(pol);
 data_GetRightMem().math_SimpleRaiseTo(pol);
 return mcBOR_REMOVE_OPERAND;
}
/*
void mcMathMngHelpers::math_SimpleRaiseTo(const mcPolynomial &pol)
{
 mcMATHLOG(wxT("mcMathMngHelpers::math_SimpleRaiseTo [%s] - raising to [%s]"), mcTXTTHIS, mcTXT(pol));

 if (pol.math_isFactorized()) {

  const mcMonomial &elem = pol.math_Get(0);
  if (elem.math_GetCount() == 1) {

   const mcElement &num = elem.math_Get(0);
   if (num.data_GetType() == mcET_NUMBER) {

    mcRealValue n = pol.math_GetSign(0)*
        mcNumber(num).data_Get();

    math_RaiseTo(n);
    return;
   }
  }
 }

 math_RaiseTo(pol);
}*/

bool mcMathMngHelpers::math_ContainsSymbol(const mcSymbolProperties *sym) const
{
 return data_GetLeftMem().math_ContainsSymbol(sym) ||
   data_GetRightMem().math_ContainsSymbol(sym);
}

mcIntegerValue mcMathMngHelpers::math_GetMaxDegreeFor(const mcSymbolProperties *sym) const
{
 mcIntegerValue m1, m2;

 // get the max degree
 m1 = data_GetLeftMem().math_GetMaxDegreeFor(sym);
 m2 = data_GetRightMem().math_GetMaxDegreeFor(sym);

 // the given symbol has a non-numeric exponent somewhere in *this ?
 if (!m1.isValid() || !m2.isValid())
  return *mcIntegerValue::pNAN;

 return mcMAX(m1, m2);
}

void mcMathMngHelpers::math_FactoreOut(const mcSymbolProperties *sym,
        const mcPolynomial &pol,
        bool bForceUseless)
{
 mcMATHLOG(wxT("mcMathMngHelpers::math_FactoreOut [%s]"), io_GetInlinedExpr().c_str());
 data_GetLeftMem().math_FactoreOut(sym, pol, bForceUseless);
 data_GetRightMem().math_FactoreOut(sym, pol, bForceUseless);
}

void mcMathMngHelpers::math_FactoreOutFreeOf(const mcSymbolProperties *sym,
        const mcPolynomial &pol,
        bool bForceUseless)
{
 data_GetLeftMem().math_FactoreOutFreeOf(sym, pol, bForceUseless);
 data_GetRightMem().math_FactoreOutFreeOf(sym, pol, bForceUseless);
}

void mcMathMngHelpers::math_FactoreOutAll(bool bForceUseless)
{
 data_GetLeftMem().math_FactoreOutAll(bForceUseless);
 data_GetRightMem().math_FactoreOutAll(bForceUseless);
}

bool mcMathMngHelpers::math_isFactorized() const
{
 return data_GetLeftMem().math_isFactorized() &&
  data_GetRightMem().math_isFactorized();
}

---

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

[ Top ]