Main page

---

MathSystem.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 "MathSystem.h"
#endif

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/MathCore.h"
 #include "mc/Text.h"
 #include "mc/MathLine.h"
 #include "mc/MathSystem.h"
#endif

#include <wx/tokenzr.h>  // not included in wx.h



// global objects
mcMathSystem mcEmptySystem;



// --------------------------------
// mcMATHSYSTEMDATA
// --------------------------------

#ifdef __MCDEBUG__

void mcMathSystemHelpers::data_Check() const
{ mcAbstractArray::data_Check(); }

#endif

void mcMathSystemHelpers::data_DeepCopy(const mcElementHelpers *p)
{
 const mcMathSystemHelpers *ms = (const mcMathSystemHelpers *)p;

 // copy all the lines contained
 mcAbstractArray::data_DeepCopy(*ms);
 
 // copy all other simple variables
 mgui_fLastFont = ms->mgui_fLastFont;
 mgui_szSymbol = ms->mgui_szSymbol;
 mgui_nSel = ms->mgui_nSel;
 mgui_nLastActive = ms->mgui_nLastActive;
 mgui_nCurrentActive = ms->mgui_nCurrentActive;
}

/*
void mcMathAndSystem::data_OnArrayChange()
{
 if (!mcMathCore::isOk() || !mcMathCore::Get()->isGUIEnabled())
  return;

 // update gui
 gui_UpdateSystemSym(); 
 gui_CheckSelLineIdx(); 
}*/




// --------------------------------
// mcMATHSYSTEMGUI
// --------------------------------

// mcMATHSYSTEM rendering system (for the horizontal orientation):
//  ________________________________________
// !                                        ! <- a
// ! .----.          .----.          .----. !
// ! |0   | .------. |1   | .------. |2   | !
// ! |    | |or/and| |    | |or/and| |    | !
// ! ·----· ·------· ·----· ·------· ·----· !
// !l______x________x______x________x______l! <- a
//
// where the columns marked with
//   "x" stay for the value returned by gui_GetSpaceBetween()
//   "l" stay for the value returned by gui_GetSpaceLeftRight()
// and the rows marked with
//   "a" stay for the value returned by gui_GetSpaceAboveBelow()
// and the boxes number from 0 to n, are of a variable width,
// and the OR/AND boxes are all of the same size (gui_GetSymbolSize())

int mcMathSystemHelpers::gui_GetXOf(int n) const
{ 
 if (gui_DrawHorizontally()) {

  // since we are drawn with horizontal horientation, 
  // we need to take in count the size of all previous elements...
  // the size of the symbols among them and the space to leave
  // between them:
  int x = gui_GetSpaceLeftRight();
  for (int i=0; i<n; i++)
   x += data_Get(i).gui_GetWidth()+
    gui_GetSymbolSize().GetWidth()+gui_GetSpaceBetween()*2;
  return x;
 }

 // we don't need to add gui_GetSpaceLeftRight() because it should
 // have been already counted in gui_GetWidth()...
 return (gui_GetWidth()-data_Get(n).gui_GetWidth())/2;
}

int mcMathSystemHelpers::gui_GetYOf(int n) const
{ 
 if (gui_DrawVertically()) {

  // since we are NOT drawn with horizontal horientation, 
  // we need to take in count the size of all previous elements...
  // the size of the symbols among them and the space to leave
  // between them:
  int x = gui_GetSpaceAboveBelow();
  for (int i=0; i<n; i++)
   x += data_Get(i).gui_GetHeight()+
    gui_GetSymbolSize().GetHeight()+gui_GetSpaceBetween()*2;
  return x;
 }

 // we don't need to add gui_GetSpaceLeftRight() because it should
 // have been already counted in gui_GetWidth()...
 return (gui_GetHeight()-data_Get(n).gui_GetHeight())/2;
}

int mcMathSystemHelpers::gui_GetYOfSymbol(int n) const
{
 // if we need the Y for the n-th connector symbol,
 // then we need to add to the Y for the n-th element 
 // the n-th element's height and the space between constant...
 if (gui_DrawVertically())
  return gui_GetYOf(n)+data_Get(n).gui_GetHeight()+gui_GetSpaceBetween();

 // center the symbol into this array...
 return (gui_GetHeight()-gui_GetSymbolSize().GetHeight())/2;
}

int mcMathSystemHelpers::gui_GetXOfSymbol(int n) const
{
 // if we need the X for the n-th connector symbol,
 // then we need to add to the X for the n-th element 
 // the n-th element's width and the space between constant...
 if (gui_DrawHorizontally())
  return gui_GetXOf(n)+data_Get(n).gui_GetWidth()+gui_GetSpaceBetween();

 // center the symbol into this array...
 return (gui_GetWidth()-gui_GetSymbolSize().GetWidth())/2;
}

int mcMathSystemHelpers::gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &p) const
{
 // first of all, draw the symbols of the system...
 gui_DrawSystemSymbols(dc, x, y, flags);

 // now, just draw the elements contained at their positions...
 int ret = mcDRW_NOACTIVEELEM;
 for (int i=0; i<data_GetCount(); i++) {

  // we just need to offset with (x; y) the rect returned
  // by #gui_GetRectOf because it already took in count
  // the space left/right and above/below...
  wxRect rc(gui_GetRectOf(i));
  rc.Offset(x, y);

  if (rc.Inside(p)) {

   ret = data_Get(i).gui_Draw(dc, rc.x, rc.y, flags, p);

  } else {

   // force the bmp update without caring about the point
   data_Get(i).gui_Draw(dc, rc.x, rc.y, flags & ~mcDRW_USEPOINT, p);
  }
 }

#ifdef mcMATHSYSTEM_DRAW_BOUNDINGBOX
 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 dc.DrawRectangle(x, y, gui_GetWidth(), gui_GetHeight());
#endif

 return ret;
}

int mcMathSystemHelpers::gui_DrawBmp(wxDC &dc, int x, int y) const
{
 gui_DrawSystemSymbols(dc, x, y, 0);

 for (int i=0; i<data_GetCount(); i++)
  gui_Get(i)->gui_DrawBmp(dc, x+gui_GetXOf(i), y+gui_GetYOf(i));

#ifdef mcMATHSYSTEM_DRAW_BOUNDINGBOX
 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 dc.DrawRectangle(x, y, gui_GetWidth(), gui_GetHeight());
#endif
 return mcDRW_NOACTIVEELEM;
}

int mcMathSystemHelpers::gui_ForceBmpUpdate(int x, int y, long flags, const wxPoint &p)
{
 if (!(flags & mcDRW_USEPOINT)) {

  // just propagate the call to the elements contained recursively...
  // we can safely ignore the given point's coordinates because
  // "flags" does not contain mcDRW_USEPOINT
  for (int j=0; j<data_GetCount(); j++)
   gui_Get(j)->gui_ForceBmpUpdate(x+gui_GetXOf(j), y+gui_GetYOf(j), flags, p);
  return mcDRW_NOACTIVEELEM;
 }

 // we need to care about point coordinates...
 int ret = mcDRW_NOACTIVEELEM;
 for (int i=0; i<data_GetCount(); i++) {

  // we just need to offset with (x; y) the rect returned
  // by #gui_GetRectOf because it already took in count
  // the space left/right and above/below...
  wxRect rc(gui_GetRectOf(i));
  rc.Offset(x, y);

  if (rc.Inside(p)) {

   ret = gui_Get(i)->gui_ForceBmpUpdate(rc.x, rc.y, flags, p);

  } else {

   // force the bmp update without caring about the point
   gui_Get(i)->gui_ForceBmpUpdate(rc.x, rc.y, flags & ~mcDRW_USEPOINT, p);
  }
 }

 return ret;
}

int mcMathSystemHelpers::gui_UpdateBmp(int x, int y, long flags, const wxPoint &p)
{
 if (!(flags & mcDRW_USEPOINT)) {
 
  // since we don't have to care about the given point, update the selected line
  gui_Get(mgui_nSel)->gui_UpdateBmp(x+gui_GetXOf(mgui_nSel), 
        y+gui_GetYOf(mgui_nSel), flags, p);
  return mcDRW_NOACTIVEELEM;
 }

 // the user has given us a valid pointer... we must update
 // only that line containing the given point.
 wxPoint pt(p);

 // translate absolute coord to relative coord
 pt.x -= x;
 pt.y -= y;

 int nline = gui_GetElemContaining(pt);
 if (nline == -1) {
 
  // we should draw everything as non-active
  //for (int i=0; i<data_GetCount(); i++)
  // gui_Get(i)->gui_UpdateBmp(0, 0, mcDRW_NONACTIVE, p);
  mgui_nLastActive = mgui_nCurrentActive;
  mgui_nCurrentActive = -1;

  if (mgui_nLastActive != -1)
   gui_Get(mgui_nLastActive)->gui_UpdateBmp(0, 0, mcDRW_NONACTIVE, p);

  return mcDRW_NOACTIVEELEM;  // no element containing that point !
 }

 // save the last active line
 mgui_nLastActive = mgui_nCurrentActive;
 mgui_nCurrentActive = nline;

 // update the active elem
 return gui_Get(nline)->gui_UpdateBmp(x+gui_GetXOf(nline), y+gui_GetYOf(nline), flags, p);
}

bool mcMathSystemHelpers::gui_NeedsRefresh() const
{
 // check if something changed...
 if (mgui_nCurrentActive == mgui_nLastActive) {

  // if the last active line as still the same active element,
  // then the ID has not changed...
  if (mgui_nCurrentActive != -1)
   return gui_Get(mgui_nCurrentActive)->gui_NeedsRefresh();
  return FALSE;
 }

 return TRUE;
}

void mcMathSystemHelpers::gui_SetMask(const wxColour &col) 
{
 // just update the masks of all our elements...
 for (int i=0; i<data_GetCount(); i++)
  gui_Get(i)->gui_SetMask(col);
}

void mcMathSystemHelpers::gui_SetBmpBackgroundBrush(const wxBrush &br)
{
 // just update the brushes of all our elements...
 for (int i=0; i<data_GetCount(); i++)
  gui_Get(i)->gui_SetBmpBackgroundBrush(br);
}

/*{
 if (!mcMathCore::Get()->isGUIEnabled() ||
  data_GetCount() == 0)
  return;

 wxScreenDC dc;
 int w, h;

 // update the font used to draw the system symbol
 // (we added a new math line => height change of the system)
 const mcTextSettings *p = gui_GetStyle(0)->GetTextSettingsFor(mcET_ADDOP);
 mgui_fLastFont.SetFaceName(p->m_hFont.GetFaceName());
 mgui_fLastFont.SetPointSize((int)mcElementHelpers::gui_Pixels2PointSize(gui_GetContentHeight()));
 mgui_fLastFont.SetWeight(wxLIGHT);

 // update the font & the font size
 dc.SetFont(mgui_fLastFont);
 dc.GetTextExtent(wxT("{"), &w, &h);
 mgui_szSymbol.SetWidth(w);
 mgui_szSymbol.SetHeight(h);
}*/

void mcMathSystemHelpers::gui_SetCursorPos(const mcCursorPos &cp)
{
 if (cp.isBegin())
  mgui_nSel = 0;
 else if (cp.isEnd())
  mgui_nSel = data_GetCount()-1;
 else
  mgui_nSel = cp.gui_Last();//mcASSERT(0, "Invalid cursor position");

 // always update also the line recursively
 mcCursorPos tmp(cp);
 tmp.gui_Pop();
 gui_GetFocus().gui_SetCursorPos(tmp);
}

void mcMathSystemHelpers::gui_GetCursorPos(mcCursorPos &cp) const
{
 if (mgui_nSel == 0 && data_Get(0).gui_GetCursorPos().isBegin())
  cp.gui_Push(mcCP_BEGIN);
 else if (mgui_nSel == data_GetCount()-1 && data_GetLast().gui_GetCursorPos().isEnd())
  cp.gui_Push(mcCP_END);

 cp.gui_Push(mgui_nSel);
 data_Get(mgui_nSel).gui_GetCursorPos(cp);
}

mcInputRes mcMathSystemHelpers::gui_Input(const mcKey &ev, mcElement *newelem)
{
 // just drop GUI input to the line which has the keyboard focus...
 mcInputRes r = gui_GetFocus().gui_Input(ev, newelem);

 gui_RecalcSize();
 return r;
}

mcInsertRes mcMathSystemHelpers::gui_Insert(const mcElement &toinsert, mcElement *newelem)
{
 gui_GetFocus().gui_Insert(toinsert, NULL);

 gui_RecalcSize();
 return mcINSR_OKAY;
}

void mcMathSystemHelpers::gui_DoRecalcSize()
{
 // the space left/right, above/below must be left
 // not only before the leftmost/abovemost element but
 // also at the end of the rightmost/bottommost element
 mgui_sz.Set(gui_GetSpaceLeftRight()*2, gui_GetSpaceAboveBelow()*2);

 for (int i=0; i<data_GetCount(); i++) {

  // if this is the 2nd, 3rd, n-th element, then there
  // is a connector symbol placed before it which has
  // a width and an height, too...
  if (i > 0) {

   if (gui_DrawHorizontally())
    mgui_sz.SetWidth(mgui_sz.GetWidth()+gui_GetSymbolSize().GetWidth()+
       gui_GetSpaceBetween()*2);
   else
    mgui_sz.SetHeight(mgui_sz.GetHeight()+gui_GetSymbolSize().GetHeight()+
       gui_GetSpaceBetween()*2);
  }

  if (gui_DrawHorizontally())
   mgui_sz.Set(mgui_sz.GetWidth()+data_Get(i).gui_GetWidth(), 
    mcMAX(mgui_sz.GetHeight(), data_Get(i).gui_GetHeight()));
  else
   mgui_sz.Set(mcMAX(mgui_sz.GetWidth(), data_Get(i).gui_GetWidth()), 
    mgui_sz.GetHeight()+data_Get(i).gui_GetHeight());
 }

 if (gui_DrawHorizontally())
  mgui_sz.SetHeight(mgui_sz.GetHeight()+gui_GetSpaceAboveBelow()*2);
 else
  mgui_sz.SetWidth(mgui_sz.GetWidth()+gui_GetSpaceLeftRight()*2);

 // don't forget to recalculate symbol size
 gui_RecalcSymbolSize();
}

void mcMathSystemHelpers::gui_CheckSelLineIdx()
{
 // adjust the selected line index if it's wrong
 if (mgui_nSel < 0) mgui_nSel = 0;
 if (mgui_nSel >= data_GetCount()) mgui_nSel = data_GetCount()-1;

 // if the array is empty, the index will be set to -1
}

wxRect mcMathSystemHelpers::gui_GetRectOf(int n) const
{
 // using simpler functions, it's not a problem to code such a function !!!
 return wxRect(gui_GetXOf(n), gui_GetYOf(n),
  data_Get(n).gui_GetWidth(), data_Get(n).gui_GetHeight());
}
/*
mcElement &mcMathSystemHelpers::gui_GetActiveElem(int x, int y, const wxPoint &pt)
{
 for (int i=0; i < data_GetCount(); i++) {

  // create the bounding box of this line
  wxRect rc(x+gui_GetLineXPos(i), y+gui_GetLineYPos(i),
     data_Get(i).gui_GetWidth(), data_Get(i).gui_GetHeight());

  // then check if it contains the given point
  if (rc.Inside(pt))
   return data_Get(i).gui_GetActiveElem(rc.x, rc.y, pt);
 }

 return mcEmptyElement;
}
*/

void mcMathSystemHelpers::gui_OnSelect(wxDC &dc, wxRect &rc)
{
 // remove old selection
 gui_DeSelect();

 // create new
 for (int i=0; i<data_GetCount(); i++) {
  wxRect irc(gui_GetRectOf(i));

  if (irc.Intersects(rc)) {

   rc.Offset(-irc.x, -irc.y);
   gui_SetFocusIdx(i);
   gui_GetFocus().gui_OnSelect(dc, rc);
   break;
  }
 }

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

int mcMathSystemHelpers::gui_GetRelCursorPos(wxDC &dc, wxPoint *p) const
{
 int ret = gui_GetFocus().gui_GetRelCursorPos(dc, p);

 p->x += gui_GetXOf(gui_GetFocusIdx());
 p->y += gui_GetYOf(gui_GetFocusIdx());
 return ret;
}

wxPoint mcMathSystemHelpers::gui_GetRelCursorPos(wxDC &dc, int x, int y, int *height) const
{
 wxPoint pt;
 
 int h = gui_GetFocus().gui_GetRelCursorPos(dc, &pt);
 pt.x += x+gui_GetXOf(gui_GetFocusIdx());
 pt.y += y+gui_GetYOf(gui_GetFocusIdx());
 if (height) *height = h;

 return pt;
}

mcMoveCursorRes mcMathSystemHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes res = gui_GetFocus().gui_MoveCursor(flag, modifiers);

 // handle the possible return codes
 switch (res) {
 case mcMCR_SETFOCUS_ABOVE:
  if (mgui_nSel > 0) {

   // select previous line and return a success code
   mgui_nSel--;
   return mcMCR_OKAY;
  }
  break;

 case mcMCR_SETFOCUS_BELOW:
  if (mgui_nSel < data_GetCount()-1) {

   // select previous line and return a success code
   mgui_nSel++;
   return mcMCR_OKAY;
  }
  break;

 case mcMCR_OKAY:
 case mcMCR_SETFOCUS_PREVIOUS:
 case mcMCR_SETFOCUS_NEXT:
 case mcMCR_CANNOT_SETFOCUS:
  break;
 }

 return res;
}

int mcMathSystemHelpers::gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &pos)
{
 mcGUILOG(wxT("mcMathSystemHelpers::gui_MoveCursorUsingPoint - moving to [%d;%d]"), pos.x, pos.y);
 int idx = gui_GetElemContaining(pos);

 // an invalid point ?
 if (idx < 0 || idx >= data_GetCount())
  return mcMCR_CANNOT_SETFOCUS;

 // adjust point's coords
 wxPoint pt(pos);
 pt.x -= gui_GetXOf(idx);
 pt.y -= gui_GetYOf(idx);

 // update selected line & move the cursor
 gui_SetFocusIdx(idx);
 return gui_GetFocus().gui_MoveCursorUsingPoint(dc, pt);
}

wxBitmap mcMathSystemHelpers::gui_GetBmp() const
{
 // do not allocate a wxBitmap through the new() function since
 // wxBitmap just contains a pointer to data which is copied
 // on function exit (a very fast operation !)
 wxBitmap result(gui_GetWidth(), gui_GetHeight(), -1);
 wxMemoryDC dc;

 dc.SelectObject(result);
 gui_Draw(dc, 0, 0, mcDRW_NOFLAGS, wxPoint(-1,-1));
 dc.SelectObject(wxNullBitmap);

 return result;
}

int mcMathSystemHelpers::gui_GetElemContaining(const wxPoint &pt) const
{
 for (int i=0; i<data_GetCount(); i++) {

  // just check which bounding box contains the given point
  wxRect rc(gui_GetRectOf(i));
  if (rc.Inside(pt))
   return i;
 }

 return -1;  // not found
}

void mcMathSystemHelpers::gui_UpdateExpDepth()
{
 // the call to mcElementHelpers::gui_SetExpDepth
 // will automatically:
 // 1) update the exponent depth of all children of our
 //    children
 // 2) recalc the size of all the elements
 for (int i=0; i<data_GetCount(); i++)
  data_Get(i).gui_SetExpDepth(0);

 // we must call the base version _always_
 mcElementHelpers::gui_UpdateExpDepth();
}

wxString mcMathSystemHelpers::gui_GetSelInlinedExpr() const
{
 // get the selection
 mcMathSystem ms(gui_GetSelection());
 if (ms == mcEmptySystem) return wxEmptyString;

 wxString str = ms.io_GetInlinedExpr();    // copy only selection....
 if (ms.data_GetCount() == 1) {

  // adjust the exported line...
  /*wxString sym = ms.data_GetLine(0)->GetSeparatorSymbol(FALSE);
  int n = str.Find(sym);

  if (n != -1) {
   wxString l = str.Left(n);
   wxString r = str.Right(str.Len()-n-sym.Len());
   
   // remove empty members
   if (l == mcEmptyBoxHelpers::io_GetInlinedExprTag())
    str = r;
   if (r == mcEmptyBoxHelpers::io_GetInlinedExprTag())
    str = l;
  }*/
 }

 return str;
}





// -----------------------------
// mcMATHSYSTEM - IO functions
// -----------------------------

wxString mcMathSystemHelpers::io_GetInlinedExpr() const
{
 wxString res;
 res.Alloc(data_GetCount()*32);

 // encode as inlined expression the entire system
 for (int i=0; i < data_GetCount(); i++) {

  if (i>0) res += wxT(" ") + io_GetInlinedExprOfLogicalOperator() + wxT(" ");
  res += data_Get(i).io_GetInlinedExpr();
 }

 return res;
}

wxString mcMathSystemHelpers::io_GetInlinedExprOfLogicalOperator(mcLogicOperator op, 
                bool shortversion) const
{
 switch (op) {
 case mcLO_AND:
  if (shortversion)
   return wxT("&");
  return wxT("AND");
 case mcLO_OR:
  if (shortversion)
   return wxT("|");
  return wxT("OR");

 case mcLO_NOTSET:
 case mcLO_MAX:
  return wxEmptyString;
 }

 return wxEmptyString;
}

wxString mcMathSystemHelpers::io_GetInlinedExprOfAllLogicalOp() const
{
 wxString str;

 for (int i=0; i < mcLO_MAX; i++)
  str += io_GetInlinedExprOfLogicalOperator((mcLogicOperator)i);
 return str;
}

wxXml2Node mcMathSystemHelpers::io_GetMathML(bool bGetPresentation) const
{
 // with a single line to export, we don't need to 
 if (data_GetCount() == 1)
  return data_Get(0).io_GetMathML(bGetPresentation);

 // enclose all the lines we contain into an MROW tag
 wxXml2Node total(wxXML_ELEMENT_NODE, wxXml2EmptyNode, wxT("mrow"));
 for (int i=0; i < data_GetCount(); i++) {
  wxXml2Node tmp(data_Get(i).io_GetMathML(bGetPresentation));
  total.AddChild(tmp);
 }

 return total;
}

bool mcMathSystemHelpers::io_ImportPresentationMathML(wxXml2Node pDoc, wxString &pErr)
{
 // FIXME: by now, just import a single line
 data_Clear();
 //data_AddEmptyLine();

 return data_Get(0).io_ImportPresentationMathML(pDoc, pErr);
}

int mcMathSystemHelpers::io_FilterInlinedExpr(wxString &str)
{
 const wxString allowed = wxT("abcdefghijklmnopqrstuvwxyz")
       wxT("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
       wxT("0123456789.,+-*/:^_<>=()[]{}");
 int out = 0;

 // scan the string removing unwanted characters
 for (int i=0; i < (int)str.Len(); i++) {
  if (!allowed.Contains(str.GetChar(i))) {

   // remove this character
   str.Remove(i, 1);
   out++;
  }
 }

 mcIOLOG(wxT("mcMathSystemHelpers::io_FilterInlinedExpr - filtered string: [%s] ")
      wxT("(%d characters filtered out)"), str.c_str(), out);
 return out;
}

bool mcMathSystemHelpers::io_ImportInlinedExpr(const wxString &str, int *, wxString &perr)
{
 mcIOLOG(wxT("mcMathSystemHelpers::io_ImportInlinedExpr - going to import [%s]"), str.c_str());

 // remove everything before importing
 data_Clear();

 if (str.IsEmpty())
  return TRUE;  // our task is complete...

 // we have to be sure not to import something which could be
 // "dangerous" for our input system like strange characters...
 wxString toimport = str;
 io_FilterInlinedExpr(toimport);

 // we'll now substitute our logical operator (AND or OR) with "#":
 // it is a special character which was removed by user input in the 
 // previous step and we are now going to use as delimiter for our tokens
 for (int i=0; i < mcLO_MAX; i++)
  toimport.Replace(io_GetInlinedExprOfLogicalOperator(), wxT("#"), TRUE);

 // break in various tokens the string to import
 wxStringTokenizer tkz(toimport, wxT("#"));
 while (tkz.HasMoreTokens()) {
  wxString token = tkz.GetNextToken();
  
  // trim both left & right spaces
  token.Trim(FALSE);
  token.Trim(TRUE);  
  
  // create a new line chaining it with the previous ones through the
  // operator found at the end of the previous line
  // NOTE: on first line, lastop will be set to mcLO_NOTSET since
  //       no lines were imported before but this is okay: it does not
  //       make sense setting the chain operator for the first line.
  if (!io_ImportToken(token, &perr))
   return FALSE;
 }

 data_Check();
 return TRUE;
}




// --------------------------------
// mcMATHSYSTEMMATH
// --------------------------------
/*
mcMathAndSystem *mcMathAndSystem::math_Merge(const mcMathAndSystem *p) const
{
 mcMATHLOG(wxT("mcMathAndSystem::math_Merge [%s] - merging with [%s]"), 
    mcTXTTHIS, p->io_GetInlinedExpr().c_str());
 mcMathAndSystem *res = new mcMathAndSystem(*this);

 for (int i=0; i<p->data_GetLineCount(); i++)
  res->data_AddLine(new mcMathLine(*p->data_GetLine(i)));

 mcMATHLOG(wxT("mcMathAndSystem::math_Merge - result is [%s]"), 
   res->io_GetInlinedExpr().c_str());
 return res;
}*/


#define mcMATHSYSTEM_SIMPLE_PROPAGATION(func)    \
 for (int i=0; i < data_GetCount(); i++)     \
  data_Get(i).func;         \
 return mcBOR_REMOVE_OPERAND;

mcBasicOpRes mcMathSystemHelpers::math_MultiplyBy(const mcElement &pol, mcElement *)
{ mcMATHSYSTEM_SIMPLE_PROPAGATION(math_SimpleMultiplyBy(pol)); }

mcBasicOpRes mcMathSystemHelpers::math_DivideBy(const mcElement &pol, mcElement *)
{ mcMATHSYSTEM_SIMPLE_PROPAGATION(math_SimpleDivideBy(pol)); }

mcBasicOpRes mcMathSystemHelpers::math_Add(const mcElement &pol, mcElement *, bool add)
{ mcMATHSYSTEM_SIMPLE_PROPAGATION(math_SimpleAdd(pol, add)); }

mcBasicOpRes mcMathSystemHelpers::math_Subtract(const mcElement &pol, mcElement *)
{ mcMATHSYSTEM_SIMPLE_PROPAGATION(math_SimpleSubtract(pol)); }

mcBasicOpRes mcMathSystemHelpers::math_RaiseTo(const mcPolynomial &pol)
{
 for (int i=0; i < data_GetCount(); i++)
  data_Get(i).math_SimpleRaiseTo(pol);

 return mcBOR_REMOVE_OPERAND;
}

bool mcMathSystemHelpers::math_Compare(const mcElement &p, long flags) const
{
 bool res = TRUE;

 // first of all, be sure we are of the same type
 if (!math_CompareThisOnly(p, flags))
  return FALSE;

 // compare each element
 const mcMathSystem &arr = (const mcMathSystem &)p;
 for (int i=0; i < data_GetCount(); i++)
  for (int j=0; j < arr.data_GetCount(); j++)
   res &= data_Get(i).math_Compare(arr.data_Get(j), flags);

 return res;
}
/*
mcElement mcMathSystemHelpers::math_Find(int n, const mcElement &tofind, 
          long flags, int *pos, int *entry) const
{
 for (int i=0; i < data_GetCount(); i++) {
  
  // check if this line contains the requid occurrence...
  int count = data_Get(i).math_GetCountOf(tofind, flags);
  if (count <= n) {
  
   // this line does not contain enough occurrences
   n -= count;
  } else {
  
   // ok; this is the line we were searching for...
   if (entry) *entry = i;
   return data_Get(i).math_Find(n, tofind, flags, pos);
  }
 }
 
 return mcEmptyElement; // not found
}

int mcMathSystemHelpers::math_GetCountOf(const mcElement &tocount, long flags) const
{
 int total = 0;
 for (int i=0; i < data_GetCount(); i++)
  total += data_Get(i).math_GetCountOf(tocount, flags);
 return total;
}*/

/*mcRealValue mcMathSystemHelpers::math_Evaluate() const
{
 const mcMathLine *p = ((n == -1) ? gui_GetFocus() : data_GetLine(n));

 // it does not make sense to evaluate all the lines of this
 // system: we would get an useless set of numbers.
 return p->math_Evaluate();
}*/

mcExpSimRes mcMathSystemHelpers::math_ExpSimAllLines(bool simp)
{
 mcExpSimRes res, r = mcESR_DONE;
 long flags = mcEXPSIM_NOFLAGS;
 mcElement *pp = NULL;
  
 // try to make a simplification step in all lines
 for (int i=0; i < data_GetCount(); i++) {
  
  if (simp)
   res = data_Get(i).math_Simplify(flags, pp);
  else
   res = data_Get(i).math_Expand(flags, pp);
  
  // if at least one of the line returns mcESR_NOTFINISHED
  // keep this result as the global result.
  // Same for INVALID_DATA (but this has higher priority)
  if (res == mcESR_NOTFINISHED && r != mcESR_INVALID_DATA)
   r = mcESR_NOTFINISHED;
  else if (res == mcESR_INVALID_DATA)
   r = mcESR_INVALID_DATA;
 }
 
 return r;
}

mcExpSimRes mcMathSystemHelpers::math_Simplify(long flags, mcElement *)
{
 mcExpSimRes r = math_ExpSimAllLines(TRUE);
 
 // TODO: what should we simplify here ?
 return r;
}

mcExpSimRes mcMathSystemHelpers::math_Expand(long flags, mcElement *)
{
 mcExpSimRes r = math_ExpSimAllLines(FALSE);
 
 // TODO
 return r;
}

mcRealValue mcMathSystemHelpers::math_GetLenght() const
{
 mcMathSystemType t(math_GetMathSystemType());

 switch (t.m_tMath1) {
 case mcMSTL1_MIXED:
  return 2.0;  // this is the most complex
 case mcMSTL1_INEQUALITIES:
  return 1.5;
 case mcMSTL1_EQUATIONS:
  return 1.0;
 case mcMSTL1_EXPRESSION:
  return 0.5;

 case mcMSTL1_NOT_RECOGNIZED:
 default:
  // an unrecognized mathsystem type ?
   return -1000;
  }  
}
/*
int mcMathSystemHelpers::math_Replace(const mcElement &tofind, int n, long flags,
        const mcElement &replacement, bool bAttachChildren)
{
 int total = 0;
 for (int i=0; i < data_GetCount(); i++)
  total += data_Get(i).math_Replace(tofind, n, flags, 
         replacement, bAttachChildren);
 
  return total;
}
*/

mcMathType mcMathSystemHelpers::math_GetMathType() const
{
 mcMathType res(mcMTL1_POLYNOMIAL, mcMTL2_ALGEBRAIC, mcMTL3_CONSTANT);

 // just take the math type of each line and merge it
 // with the type of the previous ones as if they were
 // all joined using a "+"
 for (int i=0; i < data_GetCount(); i++)
  res.math_Add(data_Get(i).math_GetMathType());
 return res;
}

---

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

[ Top ]