Main page

---

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

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

#ifndef mcPRECOMP
 #include "mc/MathHelpers.h"
 #include "mc/MathCore.h"
 #include "mc/Element.h"
 #include "mc/Symbol.h"
 #include "mc/Range.h"
#endif




// init statics
mcRange *mcRange::pN = NULL;
mcRange *mcRange::pZ = NULL;
mcRange *mcRange::pR = NULL;
mcRange *mcRange::pC = NULL;
mcRange *mcRange::pEmpty = NULL;

mcExtRange *mcExtRange::pN = NULL;
mcExtRange *mcExtRange::pZ = NULL;
mcExtRange *mcExtRange::pR = NULL;
mcExtRange *mcExtRange::pC = NULL;
mcExtRange *mcExtRange::pEmpty = NULL;





// ----------------------------------------
// mcABSTRACTARRAY
// ----------------------------------------

void mcAbstractArray::data_Add(mcAbstractItem *pointer)
{
 m_arr.Add(pointer);
 data_OnArrayChange();
}

void mcAbstractArray::data_Insert(mcAbstractItem *pointer, int pos)
{
 // just ask the wxArrayPtrVoid to make space for a
 // new pointer and store it.
 m_arr.Insert(pointer, pos);
 data_OnArrayChange();
}

void mcAbstractArray::data_SetItem(mcAbstractItem *pointer, int n)
{
 data_Insert(pointer, n); // OnArrayChange is called here
 data_RemoveAt(n+1, 1); // OnArrayChange is called here
}

void mcAbstractArray::data_RemoveAt(int n, int count)
{
 // check start & end indexes
 if (n < 0 || n >= data_GetCount())
  return;
 if (n+count > data_GetCount())
  count = data_GetCount()-n;

 // delete the object(s)
 for (int i=n; i < n+count; i++)
  data_Delete(i);

 // and detach it from the array
 m_arr.RemoveAt(n, count);
 data_OnArrayChange();
}

void mcAbstractArray::data_Remove(const mcAbstractItem *p)
{
 int idx = data_Find(p);
 if (idx == -1) return;

 data_RemoveAt(idx);
}

mcAbstractItem *mcAbstractArray::data_Detach(int idx)
{
 mcAbstractItem *toret = data_GetItem(idx);

 // use wxArrayPtrVoid::RemoveAt which just removes the _pointer_
 // from the array and does not delete it...
 m_arr.RemoveAt(idx, 1);

 return toret;
}

void mcAbstractArray::data_Clear()
{
 data_RemoveAt(0, data_GetCount()); // OnArrayChange is called here

 // the array should already be empty: free its memory
 m_arr.Clear();
}
 
int mcAbstractArray::data_Find(const mcAbstractItem *pointer) const
{
 for (int i=0; i < data_GetCount(); i++)
  if (data_GetItem(i) == pointer)
   return i;
 return -1;
}

void mcAbstractArray::data_DeepCopy(const mcAbstractArray &arr)
{
 data_Clear();
 for (int i=0, max=arr.data_GetCount(); i<max; i++)
  data_Add(arr.data_GetCopyOf(i));  // OnArrayChange is called here
}

#ifdef __MCDEBUG__
void mcAbstractArray::data_Check() const
{
 mcASSERT(data_GetCount() >= 0, wxT("Invalid count index"));

 // slow but *very* important check
 for (int i=0; i < data_GetCount(); i++)
  for (int j=0; j < data_GetCount(); j++)
   mcASSERT(data_GetItem(i) != data_GetItem(j) || i == j, 
     wxT("The i-th pointer is stored twice (as i and as j) !!!"));
    
}
#endif




// ----------------------------------------
// mcTEXTSETTINGS
// ----------------------------------------

void mcTextSettings::Decode(const wxString &fnt)
{
 long style, weight, pointsize, family;
 wxString todecode(fnt);  // create a modifiable copy of t
 wxString facename;
 
 // extract the font style
 todecode.AfterLast(wxT('-')).ToLong(&style, 0); 
 if (style <= 0) style = wxNORMAL;
 
 // extract the weight of this font
 todecode = todecode.BeforeLast(wxT('-'));
 todecode.AfterLast(wxT('-')).ToLong(&weight, 0);
 if (weight == 0) weight = wxNORMAL;
 
 // extract point size
 todecode = todecode.BeforeLast(wxT('-'));
 todecode.AfterLast(wxT('-')).ToLong(&pointsize, 0); 
 if (pointsize <= 0) pointsize = 16;
 
 // extract face name
 todecode = todecode.BeforeLast(wxT('-'));
 facename = todecode.AfterLast(wxT('-'));
 
 // extract font family
 todecode = todecode.BeforeLast(wxT('-'));
 todecode.AfterLast(wxT('-')).ToLong(&family, 0); 
 if (family <= 0) family = wxSWISS;
 
 // build the font
 m_hFont.SetPointSize(pointsize);
 m_hFont.SetWeight(weight);
 m_hFont.SetStyle(style);
 m_hFont.SetFamily(family);
 if (!facename.IsEmpty()) 
  m_hFont.SetFaceName(facename);
}




// ----------------------------------------
// mcSTYLE
// ----------------------------------------

bool mcStyle::Ok() 
{
 bool res = TRUE;

 // scan the array checking each entry
 for (int i=0; i < mcSTYLE_TEXTSETTINGS_NUM; i++)
  res &= m_pTextSettings[i].Ok();

 return res;
}

int mcStyle::GetIndexFor(mcElementType t) const
{
 switch (t) {

 // for mcET_OPERATOR, mcET_EMPTYBOX and all the remaining...
 default:
  return 0;

 case mcET_NUMBER:
  return 1;

 case mcET_FUNCTION:
  return 2;
  
 case mcET_TEXT:
 case mcET_MATHANDSYSTEM:
 case mcET_MATHORSYSTEM:
 case mcET_MATHMNG:
  return 3;

 case mcET_SYMBOL:
  return 4;
 }
}

int mcStyle::GetIndexFor(const mcElement &e) const
{
 // a little exception for mcSymbols
 if (e.data_GetType() == mcET_SYMBOL) {
  mcSymbol p(e);
  if (p.hlp()->data_isGreekSymbol())
   return mcSTYLE_SPECIAL_SETTINGS;
 }

 return GetIndexFor(e.data_GetType());
}




// ----------------------------------------
// mcSTYLEARRAY
// ----------------------------------------

mcStyleArray::~mcStyleArray()
{
 if (m_pStyles)
  delete [] m_pStyles;
 m_pStyles = NULL;
}

void mcStyleArray::CreateArray()
{
 if (m_pStyles == NULL)
  m_pStyles = new mcStyle[mcELEMENTMATH_MAX_EXPDEPTH];
}

void mcStyleArray::DeepCopy(const mcStyleArray *p)
{
 // copy the array
 for (int i=0; i < mcELEMENTMATH_MAX_EXPDEPTH; i++)
  m_pStyles[i].DeepCopy(&p->m_pStyles[i]);
}

void mcStyleArray::Set(const mcStyle *arr)
{
 // copy the given styles
 for (int i=0; i < mcELEMENTMATH_MAX_EXPDEPTH; i++)
  m_pStyles[i].DeepCopy(&arr[i]);
}

int mcStyleArray::GetCount()
{
 // this function cannot be placed as inline function in the declaration
 // of mcStyleArray because mcELEMENTMATH_MAX_EXPDEPTH is a #define which
 // is placed in wxT("Element.h"), which in turn includes "MathHelpers.h"...
 return mcELEMENTMATH_MAX_EXPDEPTH;
}

int mcStyleArray::gui_GetStyleIndexFor(const mcElement &p) const
{
 // style index coincides with exponent depth...
 /*if (p.data_GetExpDepth() > 0) {
  int u=432;
  u=3;
 }*/
 return p.gui_GetExpDepth();
}

void mcStyleArray::ScaleSize(float f)
{
 for (int i=0; i < mcELEMENTMATH_MAX_EXPDEPTH; i++)
  m_pStyles[i].ScaleSize(f);
}




// ---------------
// mcMATHTYPE
// ---------------

wxString mcMathType::io_GetDescString() const
{
 wxString res;

 switch (m_tMath1) {
 case mcMTL1_POLYNOMIAL:
  res += wxT("polynomial "); break;
 case mcMTL1_RATIONAL:
  res += wxT("rational "); break;
 case mcMTL1_NOT_RECOGNIZED:
  res += wxT("[not-recognized] "); break;
 }

 switch (m_tMath2) {
 case mcMTL2_ALGEBRAIC:
  res += wxT("algebraic "); break;
 case mcMTL2_TRANSCENDENT:
  res += wxT("transcendental "); break;
 case mcMTL2_NOT_RECOGNIZED:
  res += wxT("[not-recognized] "); break;
 }

 switch (m_tMath3) {
 case mcMTL3_CONSTANT:
  res += wxT("constant"); break;
 case mcMTL3_UNKNOWN:
  res += wxT("unknown"); break;
 case mcMTL3_PARAMETRIC:
  res += wxT("parametric"); break;
 case mcMTL3_NOT_RECOGNIZED:
  res += wxT("[not-recognized]"); break;
 }

 // do not check for the mcMTL4_NOTRECOGNIZED flag
 if (m_tMath4 & mcMTL4_LOGARITHMIC)
  res += wxT("logarithmic");
 if (m_tMath4 & mcMTL4_EXPONENTIAL)
  res += wxT("exponential");
 if (m_tMath4 & mcMTL4_TRIGONOMETRIC)
  res += wxT("trigonometric");

 // last check
 if (res.IsEmpty())
  res = wxT("[invalid data]");

 return res;
}

mcMathType mcMathType::math_MultiplyBy(const mcMathType &t)
{
 // the result is exactly the same...
 return math_Add(t);
}

mcMathType mcMathType::math_DivideBy(const mcMathType &t)
{
 math_MultiplyBy(t);

 // TOTEST
 if (t.m_tMath3 != mcMTL3_CONSTANT)
  m_tMath1 = mcMTL1_RATIONAL;
 
 return *this;
}

mcMathType mcMathType::math_Add(const mcMathType &t)
{
 m_tMath1 = mcMIN(m_tMath1, t.m_tMath1);
 m_tMath2 = mcMIN(m_tMath2, t.m_tMath2);
 m_tMath3 = mcMIN(m_tMath3, t.m_tMath3);

 m_tMath4 = m_tMath4 | t.m_tMath4;

/* if (m_tMath1 == mcMTL1_POLYNOMIAL && t.m_tMath1 == mcMTL1_POLYNOMIAL)
  m_tMath1 = mcMTL1_POLYNOMIAL;
 else
  m_tMath1 = mcMTL1_RATIONAL;

 if (m_tMath2 == mcMTL2_ALGEBRAIC && t.m_tMath2 == mcMTL2_ALGEBRAIC)
  m_tMath2 = mcMTL2_ALGEBRAIC;
 else
  m_tMath2 = mcMTL2_TRANSCENDENT;

 if (m_tMath3 == mcMTL3_PARAMETRIC || 
  t.m_tMath3 == mcMTL3_PARAMETRIC)
  m_tMath3 = mcMTL3_PARAMETRIC;
 else if (m_tMath3 == mcMTL3_UNKNOWN || 
   t.m_tMath3 == mcMTL3_UNKNOWN)
  m_tMath3 = mcMTL3_UNKNOWN;
 else
  m_tMath3 = mcMTL3_CONSTANT;*/
  
 return *this;
}

mcMathType mcMathType::math_RaiseTo(const mcMathType &t)
{
 math_MultiplyBy(t);

 // TOTEST: it is trascendent only if 't' is not constant
 if (t.m_tMath3 != mcMTL3_CONSTANT) {
  m_tMath2 = mcMTL2_TRANSCENDENT;
  m_tMath4 = mcMTL4_EXPONENTIAL;
 }
 
 return *this;
}

mcMathType mcMathType::math_ApplyOp(mcElementType optype, const mcMathType &t)
{
 if (optype == mcET_ADDOP || optype == mcET_SUBOP)
  math_Add(t);
 else if (optype == mcET_MULTOP)
  math_MultiplyBy(t);
 else if (optype == mcET_DIVOP)
  math_DivideBy(t);
  
 return *this;
}



// ----------------------------------------
// mcMATHSYSTEMTYPE
// ----------------------------------------

wxString mcMathSystemType::io_GetDescString(int nequ) const
{
 wxString type;

 switch (m_tMath1) {
 case mcMSTL1_NOT_RECOGNIZED:
  type = wxT("not recognized"); break;
 case mcMSTL1_EQUATIONS:
  type = wxString::Format(wxT(" %d-equations system"), nequ); break;
 case mcMSTL1_INEQUALITIES:
  type = wxString::Format(wxT(" %d-inequalities system"), nequ); break;
 case mcMSTL1_EXPRESSION:
  type += wxT(" expression"); break;
 case mcMSTL1_MIXED:
  type = wxT(" mixed system"); break;
 }

 return type;
}

mcMathSystemType mcMathSystemType::math_CombineWith(const mcMathSystemType &t)
{
 // if one of the two is unrecognized, then
 // also the global system is unrecognized...
 if (m_tMath1 == mcMSTL1_NOT_RECOGNIZED ||
  t.m_tMath1 == mcMSTL1_NOT_RECOGNIZED) {

  m_tMath1 = mcMSTL1_NOT_RECOGNIZED;
  return *this;
 }

 if (m_tMath1 != t.m_tMath1)
  m_tMath1 = mcMSTL1_MIXED;

 return *this;
}




// ----------------------------------------
// mcRANGE
// ----------------------------------------

mcRange::~mcRange()  // cannot be placed in the header
{
}

void mcRange::math_Set(const mcRealValue &l, const mcRealValue &u)
{
 if (!u.isNAN()) { 
  //mcSAFE_DELETE(m_pUpper);
  //m_pUpper = mcNewPolynomial(); 
  //m_pUpper.math_
  m_pUpper.math_WrapNumber(u);
 }
 if (!l.isNAN()) { 
  //mcSAFE_DELETE(m_pLower); 
  //m_pLower = mcNewPolynomial(); 
  m_pLower.math_WrapNumber(l);
 }
}

void mcRange::math_Set(const mcPolynomial &l, const mcPolynomial &u)
{
 if (u != mcEmptyElement) m_pUpper = u;
 if (l != mcEmptyElement) m_pLower = l;
}

bool mcRange::math_isFinite() const
{ 
 return m_pUpper.math_isFinite() & 
   m_pLower.math_isFinite(); 
}

mcRealValue mcRange::math_GetLowerLimitValue() const
{ return m_pLower.math_Evaluate(); }

mcRealValue mcRange::math_GetUpperLimitValue() const
{ return m_pUpper.math_Evaluate(); }



#define mcBM_INCLUDE_LCHAR  wxT("[")
#define mcBM_INCLUDE_RCHAR  wxT("]")

#define mcBM_EXCLUDE_LCHAR  wxT("(")
#define mcBM_EXCLUDE_RCHAR  wxT(")")


wxString mcRange::io_GetInlinedExpr() const
{
 wxString middle = m_pLower.io_GetInlinedExpr() + wxT(";") +
      m_pUpper.io_GetInlinedExpr();

 switch (m_nBounds) {
 case mcBM_INCLUDE_BOTH:
  return mcBM_INCLUDE_LCHAR + middle + mcBM_INCLUDE_RCHAR;
 case mcBM_INCLUDE_LEFT:
  return mcBM_INCLUDE_LCHAR + middle + mcBM_EXCLUDE_RCHAR;
 case mcBM_INCLUDE_RIGHT:
  return mcBM_EXCLUDE_LCHAR + middle + mcBM_INCLUDE_RCHAR;
 case mcBM_INCLUDE_NONE:
  return mcBM_EXCLUDE_LCHAR + middle + mcBM_EXCLUDE_RCHAR;
 }

 // just to avoid warnings
 return wxEmptyString;
}




// ----------------------------------------
// mcEXTRANGE
// ----------------------------------------

bool mcExtRange::math_isFinite() const
{
 bool finite = TRUE;
 for (int i=0; i < data_GetCount(); i++)
  finite &= data_GetRange(i)->math_isFinite();
 return finite;
}




// ----------------------------------------
// mcSYMBOLPROPERTIES
// ----------------------------------------

mcSymbolProperties::mcSymbolProperties(int symtype,
            const wxString &name,
            wxFontEncoding encoding,
            const mcRealValue &value,
            const wxString &inlinedsym,
            const wxString &subscript,
            mcExtRange *domain,
            bool evaluating)
{
 m_nSymbolType = symtype;
 m_fEncoding = encoding;
 
 m_fValue = value;
 m_pDomain = NULL;

 // FIXME:
 //if (domain) 
  //m_pDomain = domain->data_Clone();
 
 m_strSubscript = subscript;
 m_strInlinedSymbol = inlinedsym;
 m_strSymbol = name;

 m_bEvaluating = evaluating;

 // create at least a mcSymbol class linked with us.
 mcSymbolHelpers *safe = new mcSymbolHelpers;
 safe->data_LinkWith(this);
}

mcSymbolProperties::~mcSymbolProperties()
{
 // this symbol is being deleted; if we have instances of
 // mcSymbolData which are linked with us, then we must
 // unlink them...
 for (int i=0,max=(int)m_arrLinkedSymbol.GetCount(); i < max; i++) {
  
  mcSymbolHelpers *p = (mcSymbolHelpers *)m_arrLinkedSymbol.Item(0);

  // mcSymbol will automatically call our Unlink() function
  //if (p) 
  mcASSERT(p != NULL, wxT("We are linked with a NULL symbol ??"));
  p->data_Unlink();

  if (i == 0) {

   // the first symbol linked with us is a special symbol
   // created during mcSymbolProperties construction and
   // we are the owner of it, so we must take care of its
   // deletion
   delete p;
  }
 }
}

bool mcSymbolProperties::data_isSameAs(const mcSymbolProperties &s) const
{
 // case #1: the two symbols have the same name & encoding & subscript
 if (s.m_strSymbol == m_strSymbol && 
   s.m_fEncoding == m_fEncoding &&
     s.m_strSubscript == m_strSubscript)
  return TRUE;
  
 // case #2: the two symbols have the same inlined expression & subscript
 if (s.io_GetInlinedSym() == io_GetInlinedSym() &&
  s.m_strSubscript == m_strSubscript)
  return TRUE;

 // if the two symbols are different, then these check should be harmless
 
 return FALSE;
}

int mcSymbolProperties::math_FindDuplicate(const mcSymbolArray *arr, int occ) const
{
 int occurrence = 0;
 int n = arr->data_FindSymbol(mcSYMFIND_MATCH_NAME, *this, occurrence);
 
 while (n != mcSYM_NOTFOUND) {
  
  const mcSymbolProperties *found = arr->data_GetSymbol(n);
  
  // ok; we have found a symbol with the same name of *this;
  // now check if it satisfies the isSameAs function...
  if (this != found && this->data_isSameAs(*found)) {

   // ok, this is the occurrence of the duplicate symbol we were
   // searching for the array
   if (occ == 0)
    return n;
   occ--;  // wait for the next one...
  }
   
  // this symbol has our same name but it's not a duplicate...
  occurrence++;  // search next
  n = arr->data_FindSymbol(mcSYMFIND_MATCH_NAME, *this, occurrence);
 }
 
 return mcSYM_NOTFOUND;
}




// ----------------------------------------
// mcSYMBOLARRAY
// ----------------------------------------

int mcSymbolArray::data_FindSymbol(long flags, const wxString &name,
         wxFontEncoding enc, const mcRealValue &value,
         const wxString &subscript, const wxString &inlined,
         int occurrence) const
{
 // this should always be synchronized perfectly with mcSymbolProperties
 // constructor
 mcSymbolProperties tmp(mcSYM_NOTSET, name, enc, value, inlined, subscript);

 return data_FindSymbol(flags, tmp, occurrence);
}

int mcSymbolArray::data_FindSymbol(long flags, const mcSymbolProperties &sym, int occ) const
{
 // search in this array
 for (int i=0; i < data_GetCount(); i++) {

  bool match = TRUE;

  // if all required conditions are met...
  if (flags & mcSYMFIND_MATCH_NAME) match &= (data_GetSymbolName(i) == sym.m_strSymbol);
  if (flags & mcSYMFIND_MATCH_ENCODING) match &= (data_GetEncoding(i) == sym.m_fEncoding);
  if (flags & mcSYMFIND_MATCH_VALUE) match &= (math_GetValue(i) == sym.m_fValue);
  if (flags & mcSYMFIND_MATCH_INLINED) match &= (io_GetInlinedSymbol(i) == sym.io_GetInlinedSym());
  if (flags & mcSYMFIND_MATCH_SUBSCRIPT) match &= (data_GetSubscript(i) == sym.m_strSubscript);

  if (match) {
   if (occ == 0)
    return i;   // ...then, return what we found

   // this is not the occurrence we're searching...
   occ--;
  }
 }

 // we didn't find it
 return mcSYM_NOTFOUND;
}

mcSymbolProperties *mcSymbolArray::data_AddSymbol(bool bRemovePrevious, 
            const wxString &name, 
            wxFontEncoding enc, 
            const mcRealValue &value, 
            const wxString &inlinedsym,
            const wxString &sub,
            mcExtRange *domain)
{
 mcSymbolProperties sym(m_nSymbolArray, name, enc, value, inlinedsym, sub, domain);

 // if we cannot add this symbol return NULL
 if (!data_AddSymbol(sym, bRemovePrevious))
  return NULL;

 // the new symbol is always appended in the last position...
 return data_GetSymbol(data_GetCount()-1);
}

bool mcSymbolArray::data_AddSymbol(const mcSymbolProperties &newsym, bool bRemovePrevious)
{
 bool bpresent = FALSE;
 int i, n;

 // FIXME: the newsym.Clone() operation *must* be done before the 
 // math_FindDuplicate function is called, because in this case that
 // function would miss to intercept itself (since it considers
 // a duplicate what is different from itself) as duplicate,
 // even if registered in another array (it cannot know it's
 // going to be added in *this).
 //
 // FIXME: data_MoveSymbols is forced to make a clone copy to work...

 // before adding the given object, check if another symbol
 // with the same name is already present...
 for (i=0; i < mcMAX_SYMBOL_ARRAY_NUM; i++) {
  if (m_pArr[i] == NULL) continue;

  n = newsym.math_FindDuplicate(m_pArr[i], 0);
  if (n != mcSYM_NOTFOUND) bpresent = TRUE;
 }

 if (bpresent && !bRemovePrevious)
  return FALSE;  // we cannot proceed

 // add the symbol even if we know there is a duplicate of this one
 // somewhere in the linked arrays...
 mcSymbolProperties *added = newsym.data_Clone();
 added->m_nSymbolType = m_nSymbolArray;
 mcAbstractArray::data_Add(added);

 // 'added' is now hold by m_arrSym (who did not make a copy for internal
 // storage (and this is very important for the following code): 
 //
 //               GetSymbol(GetCount()-1) == added

 // if no duplicates are present, we have finished...
 if (!bpresent) {

  // don't forget to call the callback
  if (m_pAddSymbolCallback)
   (*m_pAddSymbolCallback)();
  return TRUE;
 }

 // ok; we have created a duplicate of the symbol; we must remove
 // the old one (redirecting all mcSymbols using that mcSymbolProperties
 // on the just added symbol).
 for (i=0; i < mcMAX_SYMBOL_ARRAY_NUM; i++) {
  if (m_pArr[i] == NULL) continue;

  // search the first duplicate (but we hope only one duplicate is present !)
  n = newsym.math_FindDuplicate(m_pArr[i], 0);

  // this is a valid link...
  if (n != mcSYM_NOTFOUND) {

   mcSymbolProperties *torem = (mcSymbolProperties *)m_pArr[i]->data_GetSymbol(n);
   if (torem == added) {
    n = newsym.math_FindDuplicate(m_pArr[i], 1);
    if (n == mcSYM_NOTFOUND) continue;
   }

   mcASSERT(torem != added, wxT("math_FindDuplicate is broken"));
   
   // this mcSymbolProperties class must be deleted;
   // change the pointers of all mcSymbolHelpers classes
   // that are using that symbol...

   // in this FOR loop it's important to get always the
   // 1st linked symbol because each Unlink() call will
   // remove the symbol wxT('toupdate') from 'torem.m_arrLinkedSymbol'

   // another note: we start from the 1st unlinked symbol
   // and not from the 0th unlinked symbol because the first
   // mcSymbolHelpers linked with the mcSymbolProperties to remove,
   // is its safe symbol class (for more info see mcSymbolProperties)
   int j, max;
   for (j=1,max=torem->data_GetLinkedSymCount(); j < max; j++) {

    // unlink the symbol from the old mcSymbolProperties
    // object (which is going to be removed)
    mcSymbolHelpers *toupdate = torem->data_GetLinkedSym(1);
    toupdate->data_Unlink();

    // and link it with the new one
    // (we cannot use torem.GetLinkedSym() because we
    // just unlinked the wxT('toupdate') symbol from 'torem' !!!)
    toupdate->data_LinkWith(added);
   }

   mcASSERT(max >= 1, wxT("The symbol to remove did not have a safe instance ")
        wxT("of a mcSymbolHelpers class ?"));
   
   // ok; we can now delete the old mcSymbolProperties.
   m_pArr[i]->data_RemoveAt(n);
  }
 }

 // array integrity should have been preserved
 if (m_pAddSymbolCallback) (*m_pAddSymbolCallback)();
 return TRUE;
}

mcSymbolProperties *mcSymbolArray::data_MoveSymbols(int i, mcSymbolArray *parr)
{
 // VERY IMPORTANT: here we *must* clone the symbol to move: we cannot
 //                 use it directly because ?!? FIXME
 mcSymbolProperties *p = data_GetSymbol(i)->data_Clone();
 bool okay = parr->data_AddSymbol(*p, TRUE);
 mcSAFE_DELETE(p); // don't leak memory   
 
 // using math_AddSymbol, the just moved symbol is the last one of the array
 if (!okay) return NULL;
 return parr->data_GetSymbol(parr->data_GetCount()-1);
}







// ----------------------------------------
// mcCURSORPOS
// ----------------------------------------

void mcCursorPos::gui_Pop()
{
 for (int i=0; i<m_nUsed-1; i++)
  m_nPos[i] = m_nPos[i+1];
 if (!isSpecial(m_nPos[m_nUsed-1])) {
  m_nPos[m_nUsed-1] = m_nPos[m_nUsed];
  m_nUsed--;
 }
}

void mcCursorPos::gui_Push(const mcCursorPos &c)
{
/*for (int i=m_nUsed; i>0; i--)
m_nPos[i+c.m_nUsed] = m_nPos[i];
for (int j=0; j<c.m_nUsed; j++)
m_nPos[j] = c.m_nPos[j];
 m_nUsed+=c.m_nUsed;*/
}

---

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

[ Top ]