Main page

---

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

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

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



mcIMPLEMENT_MAIN_CLASS(mcSymbol, mcExpElement);


// init customizable variables
wxColour mcSymbolHelpers::sgui_clrUndefSymbols = wxColour(255, 0, 0);

mcSymbolArray mcSymbol::arrParameters(mcSYM_PARAMETER);
mcSymbolArray mcSymbol::arrConstants(mcSYM_CONSTANT);
mcSymbolArray mcSymbol::arrUnknowns(mcSYM_UNKNOWN);
mcSymbolArray mcSymbol::arrUnregistered(mcSYM_UNREGISTERED);

// the default symbol order is: CONSTANTS-PARAMETERS-UNKNOWNS
int mcSymbolHelpers::smath_nConstantOrderPos = 1;
int mcSymbolHelpers::smath_nParameterOrderPos = 2;
int mcSymbolHelpers::smath_nUnknownOrderPos = 3;




// ----------------------------------------
// mcSYMBOL
// ----------------------------------------

// a little macro used to avoid repetition of specialized code in 
// mcSymbol::math_FindSymbol() function
#define SEARCH_IN_ARRAY(x)             \
 n = x.data_FindSymbol(flags, name, enc, value, subscript, inlined, occ);  \
 if (n != mcSYM_NOTFOUND) {            \
  if (entry != NULL) *entry = n;          \
  return &x;               \
 }

mcSymbolArray *mcSymbol::math_FindSymbol(long flags,
     const wxString &name, 
     wxFontEncoding enc,
     const mcRealValue &value, 
     const wxString &subscript, 
     const wxString &inlined,
     int occ,
     int *entry, 
     int skipArr)
{
 int n;

 // search among the three arrays
 if (skipArr != mcSYM_UNKNOWN) { SEARCH_IN_ARRAY(arrUnknowns); }
 if (skipArr != mcSYM_PARAMETER) { SEARCH_IN_ARRAY(arrParameters); }
 if (skipArr != mcSYM_CONSTANT) { SEARCH_IN_ARRAY(arrConstants); }
 if (skipArr != mcSYM_UNREGISTERED) { SEARCH_IN_ARRAY(arrUnregistered); }

 // we didn't find any symbol with that label
 return NULL;
}


#define SEARCH_IN_ARRAY2(x)        \
 n = x.data_FindSymbol(flags, sym, occ);     \
 if (n != mcSYM_NOTFOUND) {       \
  if (entry != NULL) *entry = n;     \
  return &x;          \
 }

mcSymbolArray *mcSymbol::math_FindSymbol(long flags, const mcSymbolProperties &sym, 
         int occ, int *entry, int skipArr)
{
 int n;

 // search among the three arrays
 if (skipArr != mcSYM_UNKNOWN) { SEARCH_IN_ARRAY2(arrUnknowns); }
 if (skipArr != mcSYM_PARAMETER) { SEARCH_IN_ARRAY2(arrParameters); }
 if (skipArr != mcSYM_CONSTANT) { SEARCH_IN_ARRAY2(arrConstants); }
 if (skipArr != mcSYM_UNREGISTERED) { SEARCH_IN_ARRAY2(arrUnregistered); }

 // we didn't find any symbol with that label
 return NULL;
}

#define SEARCH_DUPLICATE_IN(arr)        \
 n = x->data_GetSymbol(i)->math_FindDuplicate(arr, 0);  \
   if (n != mcSYM_NOTFOUND) m = arr;

void mcSymbol::CheckArray(mcSymbolArray *x)
{
 int i, n;

 // VERY SLOW !!!
 for (i=0; i < x->data_GetCount(); i++) {

  // begin to check the i-th symbol
  x->data_GetSymbol(i)->data_Check();
  
  // search for duplicates
  mcSymbolArray *m = NULL;
  SEARCH_DUPLICATE_IN(&arrParameters);
  SEARCH_DUPLICATE_IN(&arrUnknowns);
  SEARCH_DUPLICATE_IN(&arrConstants);
  SEARCH_DUPLICATE_IN(&arrUnregistered);

  // remove this error...
  if (m != NULL) m->data_RemoveAt(n); 
 }
}

void mcSymbol::CheckSymbols()
{

 // scan each array, checking for symbols with the same name in all the three
 // arrays, skipping the character we are analyzing; if two homonyms are found,
 // delete the last one and repeat the check at the end
 CheckArray(&arrParameters);
 CheckArray(&arrConstants);
 CheckArray(&arrUnknowns);
 CheckArray(&arrUnregistered);
}

void mcSymbol::InitSymbols()
{
 // link the array all together: each array is linked to itself,
 // so, when trying to add new symbols, each array checks not
 // only all other arrays; it checks also itself...
 arrParameters.data_LinkWithArray(&arrParameters);
 arrParameters.data_LinkWithArray(&arrConstants);
 arrParameters.data_LinkWithArray(&arrUnknowns);
 arrParameters.data_LinkWithArray(&arrUnregistered);

 arrConstants.data_LinkWithArray(&arrConstants);
 arrConstants.data_LinkWithArray(&arrParameters);
 arrConstants.data_LinkWithArray(&arrUnknowns);
 arrConstants.data_LinkWithArray(&arrUnregistered);

 arrUnknowns.data_LinkWithArray(&arrUnknowns); 
 arrUnknowns.data_LinkWithArray(&arrParameters);
 arrUnknowns.data_LinkWithArray(&arrConstants);
 arrUnknowns.data_LinkWithArray(&arrUnregistered);

 arrUnregistered.data_LinkWithArray(&arrParameters);
 arrUnregistered.data_LinkWithArray(&arrConstants);
 arrUnregistered.data_LinkWithArray(&arrUnknowns);
 arrUnregistered.data_LinkWithArray(&arrUnregistered);
}

void mcSymbol::CleanupSymbols()
{
 arrParameters.data_Clear();
 arrUnknowns.data_Clear();
 arrConstants.data_Clear();
 arrUnregistered.data_Clear();
}

bool mcSymbol::LoadSymbols(const wxXml2Node &root, bool rem)
{
 bool ret = TRUE;

 // just load all the nodes in the given XML tree
 wxXml2Node next = root.GetFirstChild();
 while (next != wxXml2EmptyNode) {

  // skip if not valid...
  if (next.GetType() == wxXML_ELEMENT_NODE) {

   // load its properties, or default values if they are
   // not present...
   wxString name = next.GetPropVal(wxT("name"), wxT("INVALID"));
   wxString encodingstr = next.GetPropVal(wxT("encoding"), wxString::Format(wxT("%d"), wxFONTENCODING_DEFAULT));
   wxString subscript = next.GetPropVal(wxT("subscript"), wxT(""));
   wxString inlined = next.GetPropVal(wxT("inlinedoutput"), wxT(""));
   wxString value = next.GetPropVal(wxT("value"), wxT("0.0"));

   long tmp;
   encodingstr.ToLong(&tmp);
   wxFontEncoding encoding = (wxFontEncoding)tmp;

   // check if there is an error
   if (name == wxT("INVALID")) {

    // skip this node...
    next = next.GetNext();
    ret = FALSE;  // set error flag
   } 

   // check if a param/unknown/constant and then add it
   // overwriting eventually present old symbols with the same name
   if (next.GetName().IsSameAs(wxT("param"), FALSE)) {

    // ...and add it
    arrParameters.data_AddSymbol(rem, name, encoding, value, inlined, subscript);

   } else if (next.GetName().IsSameAs(wxT("unknown"), FALSE)) {

    // ...and add it
    arrUnknowns.data_AddSymbol(rem, name, encoding, value, inlined, subscript);

   } else if (next.GetName().IsSameAs(wxT("constant"), FALSE)) {

    // ...and add it
    arrConstants.data_AddSymbol(rem, name, encoding, value, inlined, subscript);
   }
  }

  next = next.GetNext();
 }

 return ret;
}

void mcSymbol::LoadDefaultSymbols(bool rem)
{
 // load default constants
 arrConstants.data_AddSymbol(rem, wxT("p"), wxFONTENCODING_ISO8859_7, 
  3.1415926535897932384626433832795, wxT("PI"));
 arrConstants.data_AddSymbol(rem, wxT("e"), wxFONTENCODING_DEFAULT, 
  2.7182818284590452353602874, wxT("E"));
 arrConstants.data_AddSymbol(rem, wxT("g"), wxFONTENCODING_ISO8859_7, 
  0.5772156649015328606065120900824024310421593359399, wxT("G"));

 // load default parameters
 arrParameters.data_AddSymbol(rem, wxString(wxT("a")));
 arrParameters.data_AddSymbol(rem, wxString(wxT("b")));
 arrParameters.data_AddSymbol(rem, wxString(wxT("c")));

 // load default unknowns
 arrUnknowns.data_AddSymbol(rem, wxString(wxT("x")));
 arrUnknowns.data_AddSymbol(rem, wxString(wxT("y")));
 arrUnknowns.data_AddSymbol(rem, wxString(wxT("z")));

 // now, check for repetitions...
 CheckSymbols();
}




// ----------------------------------------
// mcSYMBOLDATA
// ----------------------------------------

#ifdef __MCDEBUG__

wxString mcSymbolHelpers::data_BaseDebug(long flags) const
{
 wxString str = wxT("mcSymbol     ") + data_GetInlinedSymbol();

 if (data_isParameter())
  str += wxT("     PARAMETER");
 if (data_isConstant())
  str += wxT("     CONSTANT");
 if (data_isUnknown())
  str += wxT("     UNKNOWN");
 if (!data_isRegistered())
  str += wxT("     UNREGISTERED");

 if (data_isGreekSymbol())
  str += wxT(" (greek symbol)");
 str += wxT("\n");
 return str;
}

#endif

void mcSymbolHelpers::data_SetSymbol(const wxString &name)
{
 int n; 

 // get a pointer to our array
 mcSymbolArray *arr = mcSymbol::math_FindSymbol(mcSYMFIND_MATCH_NAME, name, 
       wxFONTENCODING_DEFAULT, 0.0, wxEmptyString, 
       wxEmptyString, 0, &n);

 if (arr == NULL) {

  // this symbol is new: add it to the unregistered symbols array
  data_LinkWith(mcSymbol::arrUnregistered.data_AddSymbol(TRUE, name));

 } else {

  // this symbol is already registered in one of mcSymbol arrays
  // (which can be even mcSymbol::arrUnregistered).
  data_LinkWith(arr->data_GetSymbol(n));
 }
}

void mcSymbolHelpers::data_SetSubscript(const wxString &str)
{
 // change mcSymbolProperties subscript
 data_GetProperties()->m_strSubscript = str;

 // and then sync it with mcExpElement's subscript
 if (str.IsEmpty()) {
  data_DestroyExpSub(FALSE);
  return;
 }
 
 // we must set the subscript...
 if (data_GetSub() == mcEmptyElement)
  data_CreateExpSub(FALSE);
 mcText txt(data_GetSub());
 txt.data_SetText(str);
}

void mcSymbolHelpers::data_Update()
{ 
 int n; 

 // this symbol should be placed in at least one of mcSymbol
 // arrays (also mcSymbol::arrUnregistered is okay)...
 mcSymbolArray *arr = 
  mcSymbol::math_FindSymbol(mcSYMFIND_MATCH_ALL, *data_GetProperties(), 0, &n);

 mcASSERT(arr != NULL, wxT("This symbol should be always listed in at least one of ")
      wxT("the three arrays (maybe arrUnregistered) !!!"));

 if (arr != NULL && !data_isRegistered() && 
  arr->data_GetArrayId() != data_GetProperties()->m_nSymbolType) {

  // we are linked to a mcSymbolProperties contained in the
  // mcSymbol::arrUnregistered, but a symbol identic to the
  // symbol we are linked to is contained also in another
  // array and arrUnregistered has the lowest possible 
  // priority
  data_GetProperties()->data_Unlink(this);
  if (data_GetProperties()->data_isUnlinked())
   mcSymbol::arrUnregistered.data_Remove(data_GetProperties());

  data_LinkWith(arr->data_GetSymbol(n));
 }
}




// ----------------------------------------
// mcSYMBOLGUI
// ----------------------------------------

bool mcSymbolHelpers::gui_isBeginKey(const mcKey &ke) const
{
 // just check c is in the right range; user can insert symbols not
 // registered, but they will appear with different color
 // (mcMathCore::Get()->sgui_clrUndefSymbols) and MathCore won't be able to
 // process data until they became registered symbols
 if (wxIsalpha(ke.GetKeyCode()) && ke.GetModifiers() == 0) {
  /*mcSymbolArray *arr = mcSymbolHelpers::isSymbolReg(ke.GetKeyCode(), wxT(""));

  // if the symbol is registered, there are no problems
  if (arr != NULL) {
   // cannot set here m_nSymType because hlp() is a const
   // function; and hlp() is a const function because it
   // cannot modify object's data; and it cannot modify
   // object data because hlp() function is called by
   // MathCore on a special instance of the class, not
   // on the class that will represent the symbol
   return TRUE;
  }

  // if the symbol is undefined, let the user type it, but draw
  // it with different color
  if (arr == NULL)*/
   return TRUE;
 }

 // not a valid char
 return FALSE;
}

bool mcSymbolHelpers::gui_isBaseEndKey(const mcKey &key) const
{
 // if user pressed one of the following keys:
 // EDITEXP, EDITSUBSCRIPT, DELETE, CANCEL
 // then, process it...
 if (mcMathCore::Get()->MatchEditKeys(key))
  return FALSE;

 return TRUE;
}

void mcSymbolHelpers::gui_DoRecalcBaseSize()
{
 mgui_szBase.Set(0, 0);
 if (!data_isLinked())
  return;

 // using correct font, retrieve the size of the symbol
 wxScreenDC dc;
 gui_SelectStyle(dc);
 mgui_szBase = gui_GetSizeOf(&dc, data_GetSymbol());
}

int mcSymbolHelpers::gui_DrawBase(wxDC &hDC, int x, int y, long flags, const wxPoint &pt) const
{
 mcGUILOG(wxT("mcSymbolHelpers::gui_DrawBase"));

 // if the given pointer is not == mcDRW_NONACTIVE, it must
 // be a valid pointer; thus, the cursor is inside the base and
 // we must draw all the element as active (included the
 // eventually present subscript)...
 if (!(flags & mcDRW_NONACTIVE)) {

  // set the background color
  mcGUILOG(wxT("mcSymbolHelpers::gui_DrawBase [%s] - drawing me as active"), mcTXTTHIS);
  hDC.SetBrush(*mcElementHelpers::sgui_pActivationBrush);
  hDC.SetPen(*wxBLACK_PEN);
  hDC.DrawRectangle(x-sgui_nAdditionalActivationSpaceLeftRight, y, 
   gui_GetBaseAndSubSize().GetWidth()+sgui_nAdditionalActivationSpaceLeftRight*2,
   gui_GetBaseAndSubSize().GetHeight());
 }

 // print the symbol using correct font and color
 gui_SelectStyle(hDC);

 // if the symbol is an undefined symbol, draw it
 // with a different color
 //data_Update();
 if (!data_isRegistered())
  hDC.SetTextForeground(sgui_clrUndefSymbols);

 // draw the symbol
 hDC.SetBackgroundMode(wxTRANSPARENT);
 hDC.DrawText(data_GetSymbol(), x, y);

 return data_GetID();
}

void mcSymbolHelpers::gui_EditBase()
{
 // cursor is now editing the base
 mgui_nCursorPos = mcSYMBOL_RIGHTMOST;
 mgui_nCursorLoc = mcECL_INSIDEBASE;
}

mcInputRes mcSymbolHelpers::gui_BaseInput(const mcKey &key, mcElement *pnew)
{
 // Special case for the first time this function is called
 if (!data_hasProperty(mcEP_INITIALIZED)) {

  data_SetSymbol((wxChar)key.GetKeyCode());

  if (key.isSpecialKey())
   data_SetAsGreek(TRUE);

  data_AddProperty(mcEP_INITIALIZED);
  gui_RecalcSize();

  return mcIR_OKAY;
 }

 // handle the EDITEXP and EDITSUBSCRIPT keypresses
 if (gui_HandleSubExpEditKeys(key) == mcIR_OKAY)
  return mcIR_OKAY;

 // handle other keypresses basing on cursor position
 switch (mgui_nCursorPos) {
 case mcSYMBOL_LEFTMOST:

  // the user wants to delete this symbol using CANC...
  if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
   return mcIR_DELETE_THIS;

  // the user wants to delete previous things
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
   return mcIR_DELETE_PREVIOUS;

  mcMathCore::Get()->SyntaxError(wxT("Cannot type here"));
  break;

 case mcSYMBOL_RIGHTMOST:

  // handle delete requests
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
   return mcIR_DELETE_THIS;
  if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
   return mcIR_DELETE_NEXT;

  mcMathCore::Get()->SyntaxError(wxT("Cannot type here"));
  break;
 }

 // everything's okay
 return mcIR_OKAY;
}

mcInputRes mcSymbolHelpers::gui_SubInput(const mcKey &ev, mcElement *pnew)
{
 // do default processing
 mcInputRes r = mcExpElementHelpers::gui_ExpSubInput(FALSE, ev, pnew);

 // sync mcExpElement subscript with mcSymbolProperties subscript 
 if (data_GetSub() != mcEmptyElement)  
  data_GetProperties()->m_strSubscript = mcText(data_GetSub()).data_GetText();

 return r;
}

mcInsertRes mcSymbolHelpers::gui_BaseInsert(const mcElement &toinsert, mcElement *newelem)
{
 (*newelem) = mcElement(this);
 return mcINSR_REPLACE_THIS;
}

void mcSymbolHelpers::gui_SetBaseCursorPos(const mcCursorPos &flag)
{
 if (flag.isBegin())
  mgui_nCursorPos = mcSYMBOL_LEFTMOST;
 if (flag.isEnd())
  mgui_nCursorPos = mcSYMBOL_RIGHTMOST;
}

void mcSymbolHelpers::gui_GetBaseCursorPos(mcCursorPos &cp) const
{
 if (mgui_nCursorPos == mcSYMBOL_LEFTMOST)
  cp.gui_Push(mcCP_BEGIN);
 else if (mgui_nCursorPos == mcSYMBOL_RIGHTMOST)
  cp.gui_Push(mcCP_END);
 else
  cp.gui_Push(mgui_nCursorPos);
}

mcMoveCursorRes mcSymbolHelpers::gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 // up/down movements (don't care about actual cursor position)
 if (flag == mcMCF_UP)
  return mcMCR_SETFOCUS_ABOVE;
 if (flag == mcMCF_DOWN)
  return mcMCR_SETFOCUS_BELOW;

 // handle cursor movements
 switch (mgui_nCursorPos) {
 case mcSYMBOL_LEFTMOST:

  // left/right movements
  if (flag == mcMCF_LEFT)
   return mcMCR_SETFOCUS_PREVIOUS;
  if (flag == mcMCF_RIGHT) {
   mgui_nCursorPos = mcSYMBOL_RIGHTMOST;

   if (modifiers & mcMCF_EXTEND_SELECTION)
    gui_Select();
  }
  break;

 case mcSYMBOL_RIGHTMOST:

  // left/right movements
  if (flag == mcMCF_LEFT)
   mgui_nCursorPos = mcSYMBOL_LEFTMOST;
  if (flag == mcMCF_RIGHT)
   return mcMCR_SETFOCUS_NEXT; // mcExpElement will care of the exponent...
  break;
 }

 // everything's okay
 return mcMCR_OKAY;
}

int mcSymbolHelpers::gui_BaseMoveCursorUsingPoint(wxDC &dc, const wxPoint &pt)
{
 // check if the point where user clicked was on the left or on
 // the right of the symbol...
 if (pt.x < gui_GetBaseSize().GetWidth()/2)
  mgui_nCursorPos = mcSYMBOL_LEFTMOST;
 else
  mgui_nCursorPos = mcSYMBOL_RIGHTMOST;
 return mcMCR_OKAY;
}

int mcSymbolHelpers::gui_GetBaseRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 // cursor is located at the top-left point of the base bounding box
 pt->x = 0;

 // if the exponent is present, the gui_GetBaseOffsety() function
 // will return a positive value: the cursor must start from
 // the highest point
#ifdef mcGUI_CURSOR_LONG_AS_POSSIBLE
 pt->y = -gui_GetBaseOffsety();
#else
 pt->y = 0;
#endif

 // if cursor is at the right of the symbol, adjust left coord.
 if (mgui_nCursorPos == mcSYMBOL_RIGHTMOST)
  pt->x = gui_GetBaseSize().GetWidth();

#ifdef mcGUI_CURSOR_LONG_AS_POSSIBLE
 return gui_GetHeight();
#else
 return gui_GetBaseSize().GetHeight();
#endif
}





// ----------------------------------------
// mcSYMBOLIO
// ----------------------------------------

wxXml2Node mcSymbolHelpers::io_GetBaseMathML(bool bGetPresentation) const
{
 if (bGetPresentation) {

  // create an <mi> tag
  return wxXml2Node(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mi"), data_GetSymbol());
 } else {

  // create a <ci> tag
  return wxXml2Node(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("ci"), data_GetSymbol());
 }
}

wxString mcSymbolHelpers::io_GetBaseInlinedExpr() const
{
 // too easy...
 if (data_GetInlinedSymbol().IsEmpty())
  return data_GetSymbol();
 return data_GetInlinedSymbol();
}

bool mcSymbolHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr)
{
 mcASSERT(tag.GetName() == wxT("mi"), wxT("Error in mcSymbolHelpers::io_isBeginTag()"));

 if (tag.GetChildren().GetType() != wxXML_TEXT_NODE) {

  // ooooooops
  pErr = wxT("The MathML to import is not valid MathML 2.0\n")
    wxT("or there was an error while parsing it.");
  return FALSE;
 }

 // extract data & check it
 data_GetSymbol() = tag.GetChildren().GetContent();
 if (data_GetSymbol().Len() != 1) {

  pErr = wxT("Found an invalid <MI> tag. Empty <MI> tags or indentifiers\n")
    wxT("longer than one character are not supported");
  return FALSE;
 }

 data_AddProperty(mcEP_INITIALIZED);
 return TRUE;
}

bool mcSymbolHelpers::io_ImportBaseInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 // check how many letters are placed at the beginning of the array
 int max = 0;
 for (int j=0; j < (int)str.Len(); j++) {
  if (wxIsalpha(str.GetChar(j)))
   max++;
  else
   break;
 }

 // at least one letter should be present...
 mcASSERT(max > 0, wxT("Error in mcSymbolHelpers::io_isBeginChar"));

 // check if the given string should be interpreted as a specific
 // symbol (for example, PI should be interpreted as one symbol only
 // if #LoadDefaultSymbols() has been called...)
 int n;
 for (int i=1; i <= max; i++) {

  wxString sym = str.Left(i);
  mcSymbolArray *p = mcSymbol::math_FindSymbol(mcSYMFIND_MATCH_INLINED, 
   wxEmptyString, wxFONTENCODING_DEFAULT, 0, wxEmptyString, sym, 0, &n);

  // did we find a symbol that, exported as inlined expression,
  // is encoded as "sym" ?
  if (p) {

   // yes !!!
   data_LinkWith(p->data_GetSymbol(n));
   data_AddProperty(mcEP_INITIALIZED);
   *count = sym.Len();
   return TRUE;
  }
 }

 // extract data
 data_SetSymbol(str.GetChar(0));
 data_AddProperty(mcEP_INITIALIZED);

 // mcSymbol is always one char long, when expressed as inline expr...
 *count = 1;

 return TRUE;
}




// ----------------------------------------
// mcSYMBOLMATH
// ----------------------------------------

mcExpSimRes mcSymbolHelpers::math_SimplifyBase(long flags, mcElement *pnew)
{
 // base cannot be simplified...
 return mcESR_DONE;
}

mcExpSimRes mcSymbolHelpers::math_ExpandBase(long flags, mcElement *pnew)
{
 // base cannot be expanded ...
 return mcESR_DONE;
}

mcExpSimRes mcSymbolHelpers::math_SimplifyBaseExp(long flags, mcElement *pnew)
{
 // base cannot be simplified with the exponent...
 // we cannot do nothing because a^2 cannot be
 // expressed in other ways.
 return mcESR_DONE;
}

mcMathType mcSymbolHelpers::math_GetBaseMathType() const
{
 mcMathType res(mcMTL1_POLYNOMIAL, mcMTL2_ALGEBRAIC, mcMTL3_CONSTANT);

 // by now, return PARAMETRIC even if this symbol is unregistered...
 // in future, an assert will be thrown because unregistered symbols
 // should not be present while working with math functions...
 if (!data_isRegistered() || data_isParameter())
  res.m_tMath3 = mcMTL3_PARAMETRIC;
 else if (data_isUnknown())
  res.m_tMath3 = mcMTL3_UNKNOWN;
 else
  mcASSERT(math_isConstant(), wxT("Something wrong"));

 return res;
}

bool mcSymbolHelpers::math_CompareThisOnly(const mcElement &p, long flags) const
{ 
 if (!mcElementHelpers::math_CompareThisOnly(p, flags))
  return FALSE;

 // here we are sure that p is a mcSymbol
 mcSymbol sym(p);
 if (data_GetConstProperties()->data_isSameAs(*sym.data_GetConstProperties()))
  return TRUE;
 return FALSE;
}

mcRealValue mcSymbolHelpers::math_EvaluateBase() const
{
 // this is a very important routine: it will
 // block the evaluation process if this symbol
 // is not a constant (and the special evaluation
 // system, see mcSymbolProperties::m_bEvaluating 
 // for more info, is not being used)...
 if (!data_isConstant() && !data_GetConstProperties()->math_isBeingEvaluated())
  return *mcRealValue::pNAN; // ... returning to the caller a NAN

 return data_GetValue();
}

bool mcSymbolHelpers::math_isListedBeforeOf(const mcElement &e) const
{
 if (e.data_GetType() != mcET_SYMBOL)
  return mcElementHelpers::math_isListedBeforeOf(e);

 mcSymbol s(e);

 // first of all take in count the symboltype
 if (s.math_GetOrderPos() == this->math_GetOrderPos()) {

  // then, take in count the symbolname
  return s.data_GetSymbol() > data_GetSymbol();  
 }
 
 // the two types of the symbols are different; put before
 // the one that has the lowest order position
 return(s.math_GetOrderPos() - this->math_GetOrderPos() > 0);
}
/*
mcPolynomial &mcSymbolHelpers::math_&math_GetFactors() const
{
 mcPolynomial &pol = mcNewPolynomial();
 pol.math_WrapSimple(Clone());

 return pol;
}


*/

---

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

[ Top ]