Main page

---

Function.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 "Function.cpp"
#endif

// includes
#include "mc/mcprec.h"
#include <wx/filename.h>
#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef mcPRECOMP
 #include <wx/textfile.h>
 #include <wx/gdicmn.h>
 //#include <math.h>
 
 #include "mc/MathCore.h"  // mathcore includes
 #include "mc/Function.h"
 #include "mc/Symbol.h"
 #include "mc/Number.h"
#endif


mcIMPLEMENT_MAIN_CLASS(mcFunction, mcExpElement);


// setup customizable variables
int mcFunctionHelpers::sgui_nSpaceLeftRight = 0;
int mcFunctionHelpers::sgui_nSpaceAboveBelow = 0;

// init the array containing all scripted functions.
// the "mc" prefix will be stripped out all functions name, if present
#ifdef mcUSE_WXSCRIPT
wxScriptFunctionArray mcFunction::arrFunctions(wxT("mc"));
#else
wxScriptFunctionArray mcFunction::arrFunctions;
#endif

// This is the special key which must be used to create a new fraction
// through the mcElementGUI input system.
// This is not a simple CTRL+SHIFT+F combination because gui_isBeginKey() will
// return TRUE only if the given key is set as a special key.
mcKey *mcFunctionHelpers::sgui_pNewFunction = NULL;




// ----------------------------------------
// mcFUNCTION
// ----------------------------------------

int mcFunction::data_GetFunctionType(mcElement *s, int n)
{
 wxString str;

 // first of all, convert the given sequence of mcSymbols to
 // one single string
 for (int i=0; i < n; i++) {
  if (s[i].data_GetType() == mcET_SYMBOL) {
   
   // this is a mcSymbol, add it to the string
   str += mcSymbol(s[i]).data_GetSymbol();

  } else {
   
   // all the elements should be mcSymbols...
   return mcFUNCTION_TYPE_NOTFOUND;
  }
 }

 // then try to find a function with the name we built
 return data_GetFunctionType(str);
}

int mcFunction::data_GetFunctionType(const wxString &str)
{
#ifdef mcUSE_WXSCRIPT
 // check the given string against all the registered functions
 for (int f=0; f < (int)arrFunctions.GetCount(); f++) {
  
  // get function name, removing eventually the "mc" prefix
  // at the beginning of the string...
  wxString tmp = mcFunction::arrFunctions.GetName(f);  
  if (str.Left(tmp.Len()) == tmp)
   return f;
 }
#endif

 // no matching function names found...
 return mcFUNCTION_TYPE_NOTFOUND;
}

bool mcFunction::LoadScriptFile(const wxString &name)
{
#ifdef mcUSE_WXSCRIPT
 wxScriptFile *f = NULL;

 // load the given file
 if ((f = wxScriptInterpreter::Load(name)) == NULL)
  return FALSE;

 // append file's contents to the global array
 wxScriptFunctionArray arr;
 wxScriptInterpreter::GetTotalFunctionList(arr);

 // preserve old strip-off string
 wxString str = arrFunctions.GetPrefixToStrip();
 arrFunctions.DeepCopy(&arr);
 arrFunctions.SetPrefixToStrip(str);

 // cleanup
 mcSAFE_DELETE(f);

 return TRUE;

#else

 // cannot load anything without wxscript
 return FALSE;
#endif
}





// ----------------------------------------
// mcFUNCTIONDATA
// ----------------------------------------

#ifdef __MCDEBUG__

wxString mcFunctionHelpers::data_BaseDebug(long flags) const
{
 int n = mcMathCore::Get()->m_nIndentationStep;

 return wxT("mcFunction [\n") + 
  data_GetNameObj().data_GetDebug(n, flags) +
  data_GetArgObj().data_GetDebug(n, flags) + 
  wxT("----------------------------------------- mcFunction ]");
}

#endif

void mcFunctionHelpers::data_CreateSub()
{
 data_DestroyExpSub(FALSE);

 mcPolynomial mysub;
 mdata_pSub = mysub;
 mdata_pSub.gui_SetAsExpOf(this);
}

void mcFunctionHelpers::data_SetFncType(int n)
{
 mdata_nFncType = n;

 // change the name accordingly
 wxString newname;

 if (n == mcFUNCTION_TYPE_NOTSET)
  newname = wxEmptyString;
 else
#ifdef mcUSE_WXSCRIPT
 newname = mcFunction::arrFunctions.GetName(mdata_nFncType);
#else
 newname = wxT("fnc");
#endif

 // change function name
 data_SetName(newname);
}

wxString mcFunctionHelpers::data_GetName() const
{
 // get the name from the mcText which holds it...
 wxString name = data_GetNameObj().data_GetText().RemoveLast();
 return name;
}

void mcFunctionHelpers::data_CheckName()
{
#ifdef mcUSE_WXSCRIPT
 wxString ret = mcFunction::arrFunctions.GetName(mdata_nFncType);

 // do a little check
 mcASSERT(ret == data_GetName(), wxT("hmmm, something wrong"));
#endif
}

wxScriptFunction *mcFunctionHelpers::data_GetScript() const
{
#ifdef mcUSE_WXSCRIPT
 return mcFunction::arrFunctions.Get(data_GetFncType());
#else
 return NULL;
#endif
}





// ----------------------------------------
// mcFUNCTIONGUI
// ----------------------------------------

void mcFunctionHelpers::gui_DoRecalcBaseSize()
{
 data_GetNameObj().gui_RecalcSize();
 data_GetArgObj().gui_RecalcSize();

 // calc the size of the function name
 // add to it the width of the argument
 mgui_szBase.SetWidth(mcMAX(gui_GetNameOffsetx()+gui_GetSizeOfName().GetWidth(), 
  gui_GetArgOffsetx()+gui_GetSizeOfArg().GetWidth()));

 // and choose the maximum height...
 mgui_szBase.SetHeight(mcMAX(gui_GetNameOffsety()+ gui_GetSizeOfName().GetHeight(), 
  gui_GetArgOffsety()+gui_GetSizeOfArg().GetHeight()));
}

mcInputRes mcFunctionHelpers::gui_BaseInput(const mcKey &key, mcElement *pnew)
{
 mcInputRes res = mcIR_OKAY;
 int n;

 // discard the begin character used to create this element
 if (gui_isBeginKey(key) != FALSE && 
  !data_hasProperty(mcEP_INITIALIZED)) {

  // this element is now ready for input
  Init();

  return mcIR_OKAY;
 }

 switch (mgui_nCursorPos) {
 case mcFUNCTION_INSIDENAME:
  
  // handle the EDITEXP and EDITSUBSCRIPT keypresses
  if (gui_HandleSubExpEditKeys(key) == mcIR_OKAY)
   return mcIR_OKAY;

  res = data_GetNameObj().gui_Input(key, pnew);

  // recheck if the name matches one of the registered functions...
  n=mcFunction::data_GetFunctionType(data_GetName());

  // we allow the user to create mcFunctions with names which are
  // not on the registered function list...
  // note: we need to check if the n-th type of function have the
  //       same name we currently have since data_GetFunctionType()
  //       consider wxT("cosec") == "cos" (required to make IO function work)
  if (n!=mcFUNCTION_TYPE_NOTFOUND && 
   mcFunction::arrFunctions.GetName(n) == data_GetName())
   data_SetFncType(n);
  else
   mdata_nFncType = -1;

  // sometimes, mcText doesn't return mcIR_DELETE_THIS when it's empty...
  if (data_GetName().IsEmpty())
   res = mcIR_DELETE_THIS;

  // handle the mcText return flags
  switch (res) {
  case mcIR_OKAY:
  case mcIR_DELETE_PREVIOUS:   
   break;

  case mcIR_DELETE_NEXT:
   mcMathCore::Get()->SyntaxError(wxT("Cannot delete this bracket"));
   res = mcIR_OKAY;
   break;

  case mcIR_DIRECT_DELETE:
  case mcIR_REPLACE_THIS:
  case mcIR_DELETE_THIS:
   return mcIR_DELETE_THIS;
  }
  break;

 case mcFUNCTION_INSIDEARG:
  res = data_GetArgObj().gui_Input(key, pnew);

  // a little adjustment...
  if (res == mcIR_DISTRIBUTE)
   res = mcIR_DELETE_THIS;
  break;

 default:
  mcASSERT(0, wxT("unhandled cursor pos"));
 }

 gui_RecalcSize();

 return res;
}

int mcFunctionHelpers::gui_DrawBase(wxDC &hDC, int Offsetx, int Offsety, 
         long flags, const wxPoint &pt) const
{
 long fname=mcDRW_USEPOINT, farg=mcDRW_USEPOINT;
 wxPoint ptname = pt, ptarg = pt;
 int r = 0;

 // locate the cursor
 wxPoint nameorg(Offsetx+gui_GetNameOffsetx(), Offsety+gui_GetNameOffsety());
 wxPoint argorg(Offsetx+gui_GetArgOffsetx(), Offsety+gui_GetArgOffsety());

 if (flags & mcDRW_USEPOINT) {

  // if we must find where the point is placed, we need those rects
  wxRect namerc(nameorg, gui_GetSizeOfName());
  wxRect argrc(argorg, gui_GetSizeOfArg());

  if (namerc.Inside(pt)) {

   // if something must be drawn as active, 
   // it is not the name of the function...
   farg = mcDRW_NONACTIVE;
   ptarg = wxDefaultPosition;

  } else if (argrc.Inside(pt)) {

   r = 1;
   ptname = wxDefaultPosition;
   fname = mcDRW_NONACTIVE;
  }
 }

 // draw the function name
 // (overriding default color if this function is unregistered)
 bool breg = data_isRegistered();
 data_GetNameObj().gui_Draw(hDC, nameorg.x, nameorg.y, 
         fname, /*ptname,*/0, (breg ? NULL : wxRED));

 // draw the argument
 int r2 = data_GetArgObj().gui_Draw(hDC, argorg.x, argorg.y, farg, ptarg);

 // then return the right ID
 return (r == 0 ? data_GetID() : r2);
}

mcInsertRes mcFunctionHelpers::gui_BaseInsert(const mcElement &toinsert, mcElement *newelem)
{
 return mcINSR_OKAY;
}

mcMoveCursorRes mcFunctionHelpers::gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes res;

 switch (mgui_nCursorPos) {
 case mcFUNCTION_INSIDENAME:
  res = data_GetNameObj().gui_MoveCursor(flag, modifiers);

  switch (res) {
  case mcMCR_OKAY:
   break;

  case mcMCR_SETFOCUS_PREVIOUS:
  case mcMCR_SETFOCUS_ABOVE:
  case mcMCR_SETFOCUS_BELOW:
   return res;

  case mcMCR_SETFOCUS_NEXT:

   if (data_hasProperty(mcEP_HASEXPONENT))
    gui_EditExpSub(TRUE);
   else if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_EditExpSub(FALSE);
   else {
    
    mgui_nCursorPos = mcFUNCTION_INSIDEARG;
    data_GetArgObj().gui_SetCursorPos(mcCP_BEGIN);
    gui_BaseMoveCursor(mcMCF_RIGHT, modifiers);
   }
   break;

  default:
   mcASSERT(0, wxT("unhandled cursor pos"));   
  }
  break;


 case mcFUNCTION_INSIDEARG:
  res = data_GetArgObj().gui_MoveCursor(flag, modifiers);

  switch (res) {
  case mcMCR_OKAY:
   break;

  case mcMCR_SETFOCUS_NEXT:
  case mcMCR_SETFOCUS_ABOVE:
  case mcMCR_SETFOCUS_BELOW:
   return res;

  case mcMCR_SETFOCUS_PREVIOUS:
   mcASSERT(0, wxT("the cursor should never be placed on the leftmost point ")
    wxT("of the bracket: see the end of this function"));

   /* mgui_nCursorPos = mcFUNCTION_INSIDENAME;
    data_GetNameObj().gui_SetCursorPos(mcCP_END);
    gui_BaseMoveCursor(mcMCF_LEFT);*/
   break;

  default:
   mcASSERT(0, wxT("unhandled cursor pos"));   
  }
  break;

 default:
  mcASSERT(0, wxT("unhandled cursor pos"));
 }

 // cursor cannot be placed on the leftmost position of the
 // argument...
 if (mgui_nCursorPos == mcFUNCTION_INSIDEARG &&
  data_GetArgObj().gui_GetCursorPos().isBegin()) { 
  
  if (data_hasProperty(mcEP_HASEXPONENT))
   gui_EditExpSub(TRUE);
  else if (data_hasProperty(mcEP_HASSUBSCRIPT))
   gui_EditExpSub(FALSE);
  else {
   
   mgui_nCursorPos = mcFUNCTION_INSIDENAME;
   data_GetNameObj().gui_SetCursorPos(mcCP_END);
  }
 }

 return mcMCR_OKAY;
}

mcMoveCursorRes mcFunctionHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes n = mcMCR_OKAY;

 mcASSERT(mgui_bExpRight, wxT("A function should always have the exponent ")
       wxT("placed on the right of the function name"));

 if (gui_isCursorInExpSub(TRUE)) {

  n = gui_ExpSubMoveCursor(TRUE, flag, modifiers);

 } else if (gui_isCursorInExpSub(FALSE)) {

  n = gui_ExpSubMoveCursor(FALSE, flag, modifiers);

 } else if (gui_isCursorInBase()) {

  mcMoveCursorRes r = gui_BaseMoveCursor(flag, modifiers);

  switch (r) {
  case mcMCR_SETFOCUS_NEXT:
  case mcMCR_SETFOCUS_PREVIOUS:
  case mcMCR_CANNOT_SETFOCUS:
  case mcMCR_OKAY:
   return r;
   
  case mcMCR_SETFOCUS_BELOW:

   // check if the subscript is present
   if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_EditExpSub(FALSE);
   else
    return mcMCR_SETFOCUS_BELOW;
   break;
   
  case mcMCR_SETFOCUS_ABOVE:

   // check if the exponent is present
   if (data_hasProperty(mcEP_HASEXPONENT))
    gui_EditExpSub(TRUE);
   else
    return mcMCR_SETFOCUS_ABOVE;
   break;
  }
 }

 return n;
}

int mcFunctionHelpers::gui_BaseMoveCursorUsingPoint(wxDC &dc, const wxPoint &pt)
{
 // check if the given point is in the name rect
/* wxRect name(wxPoint(GetNameOffsetx(), GetNameOffsety()), gui_GetSizeOfName());
 if (name.Inside(*pt)) {
  
  // ... yes it is
  mgui_nCursorPos = mcFUNCTION_INSIDENAME;
  pt.x -= name.x;
  pt.y -= name.y;
  return data_GetNameObj().gui_MoveCursorUsingPoint(dc, pt);
  }
  
  // check if the given point is in the arg rect
  wxRect arg(wxPoint(GetArgOffsetx(), GetArgOffsety()), gui_GetSizeOfArg());
  if (arg.Inside(*pt)) {
  
   // ... yes it is
  mgui_nCursorPos = mcFUNCTION_INSIDEARG;
  pt.x -= arg.x;
  pt.y -= arg.y;
  return data_GetArgObj().gui_MoveCursorUsingPoint(dc, pt);
   }
    */
 return mcMCR_CANNOT_SETFOCUS;
}

int mcFunctionHelpers::gui_GetBaseRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 int res = 0;

 switch (mgui_nCursorPos) {
 case mcFUNCTION_INSIDENAME:
  res = data_GetNameObj().gui_GetRelCursorPos(hDC, pt);
  pt->x += gui_GetNameOffsetx();
  pt->y += gui_GetNameOffsety();
  break;

 case mcFUNCTION_INSIDEARG:
  res = data_GetArgObj().gui_GetRelCursorPos(hDC, pt);
  pt->x += gui_GetArgOffsetx();
  pt->y += gui_GetArgOffsety();
  break;

 default:
  mcASSERT(0, wxT("unhandled cursor pos"));
 }

 return res;
}

void mcFunctionHelpers::gui_GetBaseCursorPos(mcCursorPos &cp) const
{
 if (mgui_nCursorPos == mcFUNCTION_INSIDENAME &&
  data_GetNameObj().gui_GetCursorPos().isBegin()) {
  cp.gui_Push(mcCP_BEGIN);
  return;
 }

 // if the cursor is placed on the right of the last letter...
 if (mgui_nCursorPos == mcFUNCTION_INSIDEARG &&
  data_GetArgObj().gui_GetCursorPos().isEnd()) {
  cp.gui_Push(mcCP_END);
  return;
 }

 cp.gui_Push(mgui_nCursorPos);
}

void mcFunctionHelpers::gui_EditBase()
{
 // move the cursor inside the name
 mgui_nCursorPos = mcFUNCTION_INSIDENAME;
 mgui_nCursorLoc = mcECL_INSIDEBASE;
}

void mcFunctionHelpers::gui_EditBaseAndSetPos(const mcCursorPos &cp)
{
 gui_EditBase();
 data_GetNameObj().gui_SetCursorPos(cp);
}

void mcFunctionHelpers::gui_SetCursorPos(const mcCursorPos &code)
{
 if (code.isBegin()) {

  // the leftmost point for this element is the leftmost point
  // of the name object of this function...
  mgui_nCursorPos = mcFUNCTION_INSIDENAME;
  data_GetNameObj().gui_SetCursorPos(mcCP_BEGIN);

 } else {

  // the rightmost point for this element is the rightmost point
  // of the argument
  mgui_nCursorPos = mcFUNCTION_INSIDEARG;
  data_GetArgObj().gui_SetCursorPos(mcCP_END); 
 }
}

void mcFunctionHelpers::gui_Setup(int fnc)
{
 data_SetFncType(fnc);

 // a mcFunction is not allocated like the other mcElements:
 // a special function (mcMonomial::gui_ScanArrayForFunctions)
 // creates the mcFunctions which never receives the begin key
 // which doesn't exist through the gui_Input() function: so,
 // mcMonomial calls this function to init the element
 data_GetArgObj().data_GetContent().gui_AddNewEmptyMonomial();

 // we need a name; use the name of the first registered function
 mcASSERT(mcFunction::arrFunctions.GetCount() != 0, wxT("No function registered ?!?"));
 data_SetFncType(0);

 data_AddProperty(mcEP_INITIALIZED);
 gui_RecalcSize();
}

wxSize mcFunctionHelpers::gui_GetSizeOfArg() const
{ return data_GetArgObj().gui_GetSize(); }

wxSize mcFunctionHelpers::gui_GetSizeOfName() const
{ return data_GetNameObj().gui_GetSize(); }




// ARGUMENT offsets

int mcFunctionHelpers::gui_GetArgOffsetx() const
{ return mcMAX(gui_GetExpSubOffsetx(TRUE)+gui_GetExpSubSize(TRUE).GetWidth(),
    gui_GetExpSubOffsetx(FALSE)+gui_GetExpSubSize(FALSE).GetWidth()); }

int mcFunctionHelpers::gui_GetArgOffsety() const
{ return 0; }




// NAME offsets

int mcFunctionHelpers::gui_GetNameOffsetx() const
{ return 0; }

int mcFunctionHelpers::gui_GetNameOffsety() const
{ return (gui_GetBaseSize().GetHeight() - gui_GetSizeOfName().GetHeight())/2; }



// EXPONENT offsets

int mcFunctionHelpers::gui_GetExpOffsetx() const
{ return gui_GetSizeOfName().GetWidth(); }

int mcFunctionHelpers::gui_GetExpOffsety() const
{ return gui_GetNameOffsety(); }




// SUBSCRIPT offsets

int mcFunctionHelpers::gui_GetSubOffsetx() const
{ return gui_GetExpOffsetx(); }

int mcFunctionHelpers::gui_GetSubOffsety() const
{ return gui_GetNameOffsety()+gui_GetSizeOfName().GetHeight(); }



#define HANDLE_EXPSUB()           \
 switch (r) {            \
  case mcMCR_SETFOCUS_NEXT:        \
   mgui_nCursorPos = mcFUNCTION_INSIDEARG;    \
   data_GetArgObj().gui_SetCursorPos(mcCP_BEGIN);  \
   gui_BaseMoveCursor(mcMCF_RIGHT, modifiers);   \
   break;            \
               \
  case mcMCR_SETFOCUS_PREVIOUS:      \
   gui_EditBaseAndSetPos(mcCP_END);    \
   break;           \
               \
  case mcMCR_SETFOCUS_BELOW:       \
   gui_EditBase();         \
   break;           \
               \
  case mcMCR_SETFOCUS_ABOVE:       \
   return mcMCR_SETFOCUS_ABOVE;     \
 }

mcMoveCursorRes mcFunctionHelpers::gui_ExpMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 if (mgui_nCursorPos == mcECL_INSIDEEXPONENT) {

  // inside this branch we can always assume the exponent visible:
  // the cursor is inside it !!!
  int r = data_GetExp().gui_MoveCursor(flag, modifiers);

  HANDLE_EXPSUB();

 } else {

  // 
  mcASSERT(0, wxT("In a mcFunction, the cursor can be only placed on the base ")
   wxT("or _inside_ the exponent; never at the begin/end of the exp/sub"));
 }

 return mcMCR_OKAY;
}


void mcFunctionHelpers::gui_CheckSub()
{
 mcPolynomial p = data_GetSub();
 if (p.data_isArrayEmpty())
  p.gui_AddNewEmptyMonomial();
}

mcMoveCursorRes mcFunctionHelpers::gui_SubMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 if (mgui_nCursorPos == mcECL_INSIDESUBSCRIPT) {

  // inside this branch we can always assume the exponent visible:
  // the cursor is inside it !!!
  int r = data_GetSub().gui_MoveCursor(flag, modifiers);

  HANDLE_EXPSUB();

 } else {
  
  mcASSERT(0, wxT("In a mcFunction, the cursor can be only placed on the base ")
   wxT("or _inside_ the subscript; never at the begin/end of the exp/sub"));
 }

 return mcMCR_OKAY;
}





// ----------------------------------------
// mcFUNCTIONIO
// ----------------------------------------

bool mcFunctionHelpers::io_isBeginChar(const wxString &str) const
{
 // just use the STATIC version
 return io_isFunctionBeginChar(str);
}

bool mcFunctionHelpers::io_isFunctionBeginChar(const wxString &str)
{
 int n = mcFunction::data_GetFunctionType(str);
 if (n != -1) {
  
  // the name of the function matches; now check if the 
  // bracket begin char is okay
#ifdef mcUSE_WXSCRIPT
  int len = mcFunction::arrFunctions.GetName(n).Len();
#else
  int len = 0;
#endif

  wxString br = str.Right(str.Len()-len);
  for (int i=0; i < (int)br.Len(); i++)
   if (mcBracketHelpers::io_isBracketBeginChar(br.GetChar(i)))
    return TRUE;
  return FALSE;
 }
 
 return FALSE;
}

wxXml2Node mcFunctionHelpers::io_GetBaseMathML(bool bGetPresentation) const
{
 // mcExpElement::io_GetMathML will add the exponent & subscript
 // to this node, using it as the base....
 wxXml2Node n = data_GetNameObj().io_GetMathML(bGetPresentation);

 // use the <MI> tag for the function name
 n.SetName(wxT("mi"));
 return n;
}

wxXml2Node mcFunctionHelpers::io_GetMathML(bool bGetPresentation) const
{
 wxXml2Node maintag(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("mrow"));
 wxXml2Node op(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mo"), wxT("&ApplyFunction;"));
 wxXml2Node exptag(mcExpElementHelpers::io_GetMathML(bGetPresentation));
 wxXml2Node arg(data_GetArgObj().io_GetMathML(bGetPresentation));
 
 // create the function name with, eventually, the subscript and
 // the exponent attached
 maintag.AddChild(exptag);

 // then, add the ApplyFunction operator
 maintag.AddChild(op);

 // and finally, the argument of the function...
 maintag.AddChild(arg);
 
 return maintag;
}
/*
wxString mcFunctionHelpers::io_GetInlinedExpr() const
{
 wxString str;

 // merge base (function name) and exponent only: subscript is
 // exported inside the base as a function argument.

 // to be sure that mcExpElement::io_GetInlinedExpr() const won't export
 // the exponent, we hide it...
 bool old = data_hasProperty(mcEP_HASEXPONENT);
 ().data_RemoveProperty(mcEP_HASEXPONENT);

 str = mcExpElement::io_GetInlinedExpr() const const;

 // ...and then restore it again
 if (old) ().data_AddProperty(mcEP_HASEXPONENT);
 
 return str;
}*/

wxString mcFunctionHelpers::io_GetBaseInlinedExpr() const
{
 // as base, export the function name + the bracket
 wxString str = data_GetNameObj().io_GetInlinedExpr();
 str += data_GetArgObj().io_GetInlinedExpr();

 // and eventually, add as second argument the subscript
 if (data_hasProperty(mcEP_HASSUBSCRIPT)) {

  str.RemoveLast();
  str += wxT(", ") + data_GetSub().io_GetInlinedExpr();
 }

 // the exponent will be added at the end of "str":
 // if we bracketize it, then the exponent will be
 // referred to the entire function and not to the
 // argument only:
 // 
 //    sin^2x(ax)    would be confusing; better export to
 //    (sin(ax))^2x
 // 
 if (data_hasProperty(mcEP_HASEXPONENT)) {

  str.Prepend(wxT("("));
  str.Append(wxT(")"));
 }

 return str;
}

bool mcFunctionHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr)
{
 mcASSERT(0, wxT(""));
 return TRUE;
}

void mcFunctionHelpers::io_GetExpSubInlinedToken(wxString &subexp)
{
 // in these cases:
 //     fnc^2(arg)   or    fnc^2x(arg)
 // we must not import the first monomial we find, 
 // as mcExpElement::io_GetExpSubInlinedToken does:
 // we must import everything until we found the
 // left parenthesis which delimits the argument contents...
 subexp = subexp.BeforeFirst(wxT('+'));
 subexp = subexp.BeforeFirst(wxT('-'));
 subexp = subexp.BeforeFirst(wxT('('));
 return;
}

wxArrayString mcFunctionHelpers::io_ImportArgument(const wxString &arg, int *count, wxString &pErr)
{
 wxArrayString argarr;

 // extract the argument
 if (!mcBracketHelpers::gui_isLeftParenthesis(arg.GetChar(0))) {

  // oooooops...
  pErr = wxT("a left parenthesis should be placed here");
  return argarr;
 }

 int i, nestlevel=0, begin=1; 
 for (i=0; i < (int)arg.Len(); i++) {

  // modify nestlevel
  if (mcBracketHelpers::gui_isLeftParenthesis(arg.GetChar(i))) nestlevel++;
  if (mcBracketHelpers::gui_isRightParenthesis(arg.GetChar(i))) nestlevel--;

  if (arg.GetChar(i) == wxT(',')) {
   
   argarr.Add(arg.Mid(begin, i-begin)); 
   begin = i+1;
  }

  if (nestlevel == 0) { i++; break; }
 }

 // remove the useless part of the argument
 argarr.Add(arg.Mid(begin, i-1-begin));
 *count = i;

 return argarr;
}

bool mcFunctionHelpers::io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 // find which function is this
 data_SetFncType(mcFunction::data_GetFunctionType(str));
 int n = data_GetFncType();
 mcASSERT(n != -1, wxT("Error in mcFunctionHelpers::io_isBeginChar"));

 // remove subscript/exponent from wxT("arg") and store it in "subexp" 
 wxString arg = str.Right(str.Len()-data_GetName().Len());
 wxString subexp(arg);
 io_GetExpSubInlinedToken(subexp);
 arg.Remove(0, subexp.Len());

 // get the arg string(s)
 wxArrayString args = io_ImportArgument(arg, count, pErr);
 if (args.IsEmpty()) return FALSE;

 // FIXME: how to make a generic multiple-arg function ?
 arg = args[0];
 arg = wxT("(") + arg + wxT(")"); // so it's okay for mcBracket

 // set all the characters we have or we must import
 *count = data_GetName().Len()+subexp.Len()+arg.Len();

 // now, import the argument of the function 
 if (!data_GetArgObj().io_ImportInlinedExpr(arg, &n, pErr))
  return FALSE;
 mcASSERT((int)arg.Len() == n, 
  wxT("The argument has not been completely imported..."));

 // and then, the subscript/exponent
 bool bexp = (subexp.GetChar(0) == wxT('^'));
 bool bsub = (subexp.GetChar(0) == wxT('_'));
 wxString toimport(subexp);
 toimport.Remove(0, 1);  // remove the wxT("^") or "_" symbol
 n = 0;

 // import the EXPONENT
 if (bexp) {

  // this call erases previous exponent (if present) and (if not
  // already present) creates it...
  data_CreateExpSub(TRUE);

  if (!data_GetExp().io_ImportInlinedExpr(toimport, &n, pErr))
   return FALSE;
 }

 // import the SUBSCRIPT
 if (bsub) {

  // this call erases previous sub (if present) and (if not
  // already present) creates it...
  data_CreateExpSub(FALSE);

  if (!data_GetSub().io_ImportInlinedExpr(toimport, &n, pErr))
   return FALSE;
 }

 mcASSERT((int)toimport.Len() == n, 
  wxT("Exp/sub has not been completely imported..."));

 // extra-work required ?
 io_PostProcessChildren();

 // ok, everything was okay
 mcIOLOG(wxT("mcFunctionHelpers::io_ImportInlinedExpr [%s]"), mcTXTTHIS);
 return TRUE;
}




// ----------------------------------------
// mcFUNCTIONMATH
// ----------------------------------------

mcRealValue mcFunctionHelpers::math_EvaluateBase() const
{
 mcRealValue arg = data_GetArgObj().math_Evaluate();

 // it's better not to apply the function on an invalid value...
 if (!arg.isValid())
  return *mcRealValue::pNAN;

#ifdef mcUSE_WXSCRIPT
 wxScriptVar returnvalue, argument;
 argument.Set(wxSTG_DOUBLE, arg.GetDouble());
 if (!data_GetScript()->Exec(returnvalue, &argument))
  return *mcRealValue::pNAN;

 return returnvalue.GetContentDouble();

#else

 return *mcRealValue::pNAN;

#endif
}

mcExpSimRes mcFunctionHelpers::math_SimplifyBase(long flags, mcElement *pnew)
{
 mcExpSimRes r = data_GetArgObj().math_Simplify(flags, pnew);
 if (r != mcESR_DONE) return r;

 // if our argument is constant, then we should be able
 // to replace this element with something else...
 if (data_GetArgObj().math_isConstant()) {

  // just replace this
  mcRealValue val = math_Evaluate();
  if (val == *mcRealValue::pNAN)
   return mcESR_DONE;  // for some reason we cannot...

  mcNumber replacement(val);
  (*pnew) = replacement;
  return mcESR_REPLACE_THIS;
 }

 return mcESR_DONE;
}

mcExpSimRes mcFunctionHelpers::math_ExpandBase(long flags, mcElement *pnew)
{
 // we can just try to expand our argument
 return data_GetArgObj().math_Expand(flags, pnew);
 //return mcESR_DONE;
}

mcMathType mcFunctionHelpers::math_GetBaseMathType() const
{
 // if we contain unknowns or parameters, we cannot be evaluated
 // and things get much, much more complex.
 mcMathType res = data_GetArgObj().math_GetMathType();;

 // FIXME: how do we check the type of the function we are ?
 return res;
}

---

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

[ Top ]