Main page

---

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

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

#ifndef mcPRECOMP
 #include "mc/MathUtils.h"
 #include "mc/ElementArray.h"
 #include "mc/Polynomial.h"
 #include "mc/Monomial.h"
 #include "mc/EmptyBox.h"  // for mcElementArrayHelpers::gui_math_AddNewEmptyBox
 #include "mc/Number.h"
 #include "mc/Bracket.h"
 #include "mc/Fraction.h"
 #include "mc/Symbol.h"
 #include "mc/Radical.h"
#endif


mcIMPLEMENT_ABSTRACT_CLASS(mcElementArray, mcElement);


#ifdef mcELEMENTARRAY_DRAW_DECORATIONS

 // MathCore resources (files which are merged with the program)
 #include "BeginTri.xpm"
 #include "EndTri.xpm"

 // setup customizable variables
 wxBitmap *mcElementArrayHelpers::gui_pBeginTriBmp = NULL;//LoadMaskForXPM(BeginTri_xpm, wxColour(255, 255, 255));
 wxBitmap *mcElementArrayHelpers::gui_pEndTriBmp = NULL;//LoadMaskForXPM(EndTri_xpm, wxColour(255, 255, 255));

#endif



// setup customizable variables
wxPen *mcElementArrayHelpers::sgui_pSelectionPen = NULL;
bool mcElementArrayHelpers::sgui_bDrawSelectionInverting = TRUE;


// global objects
mcArrayEntry mcEmptyArrayEntry(NULL, -1);




// ---------------------------------------------------
// mcARRAYENTRY
// ---------------------------------------------------

mcElement &mcArrayEntry::data_GetRef() const
{ return ((mcElementArrayHelpers *)mdata_arr)->data_GetRefFromEntry(this); }

int mcArrayEntry::data_GetIdx() const
{ return mdata_arr->data_GetIdxFromEntry(this); }

int mcArrayEntry::math_GetIdx() const
{ return mdata_arr->math_DataToMathIdx(data_GetIdx()); }





// ---------------------------------------------------
// mcFILTER
// ---------------------------------------------------

mcFilter::mcFilter(mcFilterType type, mcElementType t1, int count1) 
{
 // init arrays
 for (int i=0; i < mcNUM_ELEMENT_TYPES; i++) {
  //m_bTypeAllowed[i] = FALSE;
  m_nMaxInstances[i] = 0;
 }
 
 // init filter type
 m_nType = type;

 // init first allowed element type
 SetMaxInstancesFor(t1, count1);
}

void mcFilter::SetMaxInstancesFor(mcElementType t, int count)
{
 //m_bTypeAllowed[t] = TRUE;
 m_nMaxInstances[t] = count;
}

bool mcFilter::isElementTypeAllowed(mcElementType t, int num)
{
 if (m_nMaxInstances[t] == mcFILTER_NO_INSTANCES_LIMIT || 
  m_nMaxInstances[t] > num)
  return TRUE;
 return FALSE;
}





// ---------------------------------------------------
// mcELEMENTARRAYDATA
// ---------------------------------------------------

#ifdef __MCDEBUG__

wxString mcElementArrayHelpers::data_Debug(long flags) const
{
 wxString f = wxT(" ");
 if (mcMathCore::Get()->isGUIEnabled() && data_isUsingFilter())
   f = wxT(" (using filter) ");
 wxString tmp = data_GetDebugName() + f + wxT("[\n");
 
 // for each element/empty box, add informations
 int step = mcMathCore::Get()->m_nIndentationStep, max = 1;
 for (int i=0; i < data_GetCount(); i++) {

  // get debug info for the i-th element of the array
  f = data_Get(i).data_GetDebug(step, flags);

  max = mcMAX(((int)f.Len()), max);
  tmp += f;
 }
 
 // add trailer info
 max = mcMIN(40, max);
 tmp += /*wxString(wxT('-'), max) +*/ data_GetDebugName() + wxT(" ]\n");
 
 return tmp;
}

void mcElementArrayHelpers::data_Check() const
{
 // most basic checks
 mcElementHelpers::data_Check();

 // scan all the array searching checking them
 for (int i=0; i < data_GetCount(); i++) {

  // check the relations with this array
  /*mcASSERT(data_Get(i).GetParent() == hlp(), wxT("Wrong parent pointer found"));*/

  // check that this array doesn't contain an array of this same type:
  // NESTING IS NOT ALLOWED !!!!!!!!
  mcASSERT((data_Get(i).data_GetType() != data_GetType()), wxT("Nested array found"));
 }
}

#endif  // __MCDEBUG__

bool mcElementArrayHelpers::data_isSameAs(const mcElementHelpers *p) const
{
 if (!mcElementHelpers::data_isSameAs(p))
  return FALSE;

 const mcElementArrayHelpers *e = (const mcElementArrayHelpers *)p;
 if (mdata_nElements != e->mdata_nElements) 
  return FALSE;

 // children have been already compared by mcElementHelpers::sata_isSameAs
/* bool same = TRUE;
 for (int i=0; i < mdata_nElements; i++)
  same &= (mdata_pElemArray[i] == e->mdata_pElemArray[i]);*/
 //return same;
 return TRUE;
}

bool mcElementArrayHelpers::data_isWrappingOnly(mcElementType t) const
{
 // check that we contains only an element of the given type:
 // math_isWrappingOnly does the same but checking *only* monomials...
 if (data_GetCount() > 1)
  return FALSE;
 if (data_Get(0).data_GetType() == t)
  return TRUE;
 return FALSE;
}

const mcElement &mcElementArrayHelpers::data_GetWrapped(mcElementType t) const
{
 if (!data_isWrappingOnly(t))
  return mcEmptyElement;
 return data_Get(0);
}

void mcElementArrayHelpers::data_AddNewEmptyBox(int pos)
{
 mcEmptyBox pnew;
 pnew.data_AddProperty(mcEP_INITIALIZED);
 data_AddElements(&pnew, 1, pos, TRUE);
}

void mcElementArrayHelpers::data_Delete(int entry)
{
 data_CheckIndex(entry);
 
 // the element currently placed at "entry" will be unreferenced
 // and, maybe, deleted...
 data_SetAsEmptyEntry(entry);
}

bool mcElementArrayHelpers::data_Delete(const mcElement &elem)
{
 int idx = data_GetIndexOf(elem);
 if (idx == -1) return FALSE;

 data_Delete(idx);
 data_MoveElemLeft(idx);
 return TRUE;
}

void mcElementArrayHelpers::data_DeleteLast(int num)
{
 int count = data_GetCount();
 for (int i=0; i < num; i++)
  data_Delete(count-1-i);
 mdata_nElements -= num;
}

void mcElementArrayHelpers::data_DeleteFirst(int num)
{
 for (int i=0; i < num; i++) {
  data_Delete(0);
  data_MoveElemLeft(0);
 }
}

void mcElementArrayHelpers::data_DeleteAllElemType(mcElementType t)
{
 for (int i=0, max=data_GetNumOfElemType(t); i < max; i++) {

  // always ask the index of the first element of the given type
  // because we are removing them...
  int idx = data_GetElemIndexOfType(0, t);
  data_Delete(idx);
  data_MoveElemLeft(idx);
 }
}

mcElement mcElementArrayHelpers::data_Detach(int entry)
{
 data_CheckIndex(entry);

 // remove from us as children settings its parent to NULL
// if (isValidElem(entry) && data_Get(entry)->GetParent() == hlp())
//  data_Get(entry)->SetParent(NULL);
 mcElement p = data_Get(entry);

 // this leaves an hole in the array
 data_SetAsEmptyEntry(entry);

 return p;
}

mcElement mcElementArrayHelpers::data_DetachLastElem(int num)
{
 int count = data_GetCount();
 mcElement p = mcEmptyElement;

 for (int i=0; i < num; i++)
  p = data_Detach(count-1-i);

 // update the counter
 mdata_nElements -= num;

 return p;
}

bool mcElementArrayHelpers::data_ScanArray(bool (*func)(const mcElement &), bool odd) const
{
 bool flag = TRUE;

 for (int i=(int)!odd; i < data_GetCount(); i++)
  flag &= (*func)(data_Get(i));
 return flag;
}

void mcElementArrayHelpers::data_CheckArrayLimit()
{
 // check if array is large enough
 if (data_GetCount()+1 >= mdata_nUpperBound) {

  // enlarge mdata_pElemArray array
  mcEXTEND_ARRAY(mcElement, mdata_pElemArray, mdata_nUpperBound,
   mdata_nUpperBound+mcELEMENTARRAY_DEFAULT_ROOM);

  mdata_nUpperBound += mcELEMENTARRAY_DEFAULT_ROOM;

  // set as empty the new entries; don't use the SetAsEmptyEntry
  // function because the contents of the entries are dirty;
  // SetAsEmptyEntry function could think they are valid pointers
//  for (int i=0; i < mcELEMENTARRAY_DEFAULT_ROOM; i++)
//   mdata_pElemArray[mdata_nUpperBound-mcELEMENTARRAY_DEFAULT_ROOM+i] = mcELEMENTARRAY_EMPTYENTRY;
 }
}

void mcElementArrayHelpers::data_DeleteAll()
{
 // check array is allocated
 if (mdata_pElemArray == NULL)
  return;

 // iterate in the array deallocating elements
 for (int i=0; i < mdata_nUpperBound; i++)
  data_Delete(i);  // Delete() will check if this is not an empty entry

 // reset variables
 mdata_nElements = 0;
}

mcElement mcElementArrayHelpers::data_DetachAll()
{
 // check array is allocated
 if (mdata_pElemArray == NULL)
  return mcEmptyElement;

 // iterate in the array detaching elements
 mcElement p = mcEmptyElement;
 for (int i=0; i < mdata_nUpperBound; i++)
  p = data_Detach(i);

 // reset variables
 mdata_nElements = 0;

 return p;
}

void mcElementArrayHelpers::data_MoveElemRight(int start)
{
 // mdata_pElemArray[start] will be shifted right with all the following elements
 data_CheckArrayLimit();  // we are adding a new element...
 for (int n=mdata_nElements; n > start; n--)
  mdata_pElemArray[n] = mdata_pElemArray[n-1];

 // one element has been added
 mdata_nElements++;

 // the first shifted entry is dirty....
 data_SetAsEmptyEntry(start);
}

void mcElementArrayHelpers::data_MoveElemLeft(int start)
{
 // mdata_pElemArray[start] will be replaced by the element on his right and so on
 for (; start < data_GetCount()-1; start++)
  mdata_pElemArray[start] = mdata_pElemArray[start+1];

 // one element has gone
 mdata_nElements--;

 // last element position is dirty...
 data_SetAsEmptyEntry(data_GetCount());
}

int mcElementArrayHelpers::data_GetIndexOf(const mcElement &p) const
{
 // scan all the array searching the given pointer
 for (int i=0; i < data_GetCount(); i++)
  if (data_Get(i) == p)
   return i; // found it

  // it's not an element stored in this mcElementArray
  return -1;
}

void mcElementArrayHelpers::data_Swap(int index1, int index2)
{
 data_CheckIndex(index1);
 data_CheckIndex(index2);

 // swap the two elements
 mcElement tmp = data_Get(index1);
 mdata_pElemArray[index1] = data_Get(index2);
 mdata_pElemArray[index2] = tmp;
}

void mcElementArrayHelpers::data_UpdateNeighbor(int n)
{
 // update neighbors of element n if necessary
 if (n >= 1 && data_isValidElem(n-1) && data_Get(n-1).data_hasProperty(mcEP_NOTIFY_NEIGHBOR_CHANGE))
  data_Get(n-1).hlp()->data_OnNeighborChange();
 if (n < data_GetCount()-1 && data_isValidElem(n+1) && data_Get(n+1).data_hasProperty(mcEP_NOTIFY_NEIGHBOR_CHANGE))
  data_Get(n+1).hlp()->data_OnNeighborChange();
}

void mcElementArrayHelpers::data_Merge(const mcElementArray &p, int n, bool bAddToEnd)
{
 // add the elements of the given array at the end of _this_ array
 data_AddElements(p.data_GetArray(n), 
    p.data_GetCount()-n,
    (bAddToEnd ? -1 : 0)); // if we want to add the elements at the
          // end of the array, then we must use -1
}

mcElement &mcElementArrayHelpers::data_AddNewElement(mcElementType t, bool bOverwrite, int pos)
{
 // create the new element using the global factory class....
 mcElement pnew = mcElementHelpers::data_NewElem(t);

 // and add it to this array
 int n = data_AddElements(&pnew, 1, pos, bOverwrite); 
 return data_Get(n);
}

void mcElementArrayHelpers::data_Set(int n, const mcElement &pnew)
{
 data_CheckIndex(n);
 mdata_pElemArray[n] = pnew;
 //mdata_pElemArray[n].data_MakePrivateCopy();

 // now that the element has been stored in the array, we can
 // reset the parent...
 //
 // VERY IMPORTANT: this must be done only AFTER the element
 //                 has been stored in the array because some
 //                 functions, on parent change, immediately
 //                 check the parent and, for mcMonomial they
 //                 start a special routine which works on
 //                 mcMonomial's array which *must* contain them...
// pnew.SetParent(hlp());

 // ...set the parent relations
// pnew.SetAtSameLevelOf(hlp());

 // preserve filters...
 /*      data_UpdateFilterFor(pnew, GetFilter());    */

 // update neighbors if needed
// data_UpdateNeighbor(n);

#ifdef mcEP_NOTIFY_NEIGHBOR_CHANGE
 // update the element itself if needed; it has just been created, so its
 // neighbors are changed (before it was created the neighbors didn't exist...)
 if (pnew.data_hasProperty(mcEP_NOTIFY_NEIGHBOR_CHANGE))
  mdata_pElemArray[n].hlp()->data_OnNeighborChange();
#endif
}

int mcElementArrayHelpers::data_AddElements(const mcElement *p, int num, int pos, 
          bool bOverwrite, bool bForceCopy)
{
 mcElement pnew;
 int firstpos = -1;

 // -1 means: insert elements at the end of the array (please note that
 // it doesn't have sense to overwrite elements at the end of the array...)
 if (pos == -1)
  pos = data_GetCount();

 // for each element we must insert/overwrite
 for (int i=0; i < num; i++) {

  // extract the i-th element from the given array
  pnew = p[i];
  mcASSERT(data_isValidElem(pnew), wxT("Cannot add empty elements"));
  mcASSERT(pnew.data_GetType() != data_GetType(), wxT("Cannot nest arrays"));

  if (bForceCopy) {

   // copy the element if specified: this is not the preferred choice
   // since COW system should be handle sharing/unsharing...
   pnew = p[i].data_Clone();
   mcMATHLOG(wxT("mcElementArrayHelpers::data_AddElements - I was forced to copy [%s]"), mcTXT(pnew));
  }

  if (pos == data_GetCount()) {

   // check if there is enough space
   data_CheckArrayLimit();

   // and add it to the array; in this case the bOverwrite
   // flag is ignored because we are inserting items at the
   // end of the array: there are no elements to overwrite
   data_Set(mdata_nElements, pnew);
   if (firstpos == -1) firstpos = mdata_nElements;
   mdata_nElements++;

  } else {

   // check also if the position is okay
   data_CheckIndex(pos);

   // overwrite the previous elements or insert new elements
   // shifting them right...
   if (bOverwrite) {
    // do not shift the array; delete the element placed
    // in the entry where the new element must be placed
    data_Delete(pos);
   } else {
    // shift the array right to make room for this new element
    data_MoveElemRight(pos);
   }

   // store new element
   data_Set(pos, pnew);
   if (firstpos == -1) firstpos = pos;
  }

  // store next element in the next position
  pos++;
 }

 return firstpos;
}




#define SCAN_ARRAY_COUNTING(do_check)     \
 int n=0;           \
 for (int i=0; i < data_GetCount(); i++)    \
  if (do_check) n++; /* found a valid entry */ \
 return n;

int mcElementArrayHelpers::data_GetNumOfElemType(mcElementType t) const
{
 SCAN_ARRAY_COUNTING(data_Get(i).data_GetType() == t);
}

int mcElementArrayHelpers::data_GetOpCount() const
{
 SCAN_ARRAY_COUNTING(data_isOp(i));
}


#define SCAN_ARRAY_SEARCHING(do_check)      \
 /* PLEASE NOTE THAT WE MUST ALWAYS START FROM -1: */ \
 /* IN THIS WAY THE PARAMETER n MUST BE EXPRESSED */  \
 /* AS ZERO-BASED */          \
 int occurrence=-1;          \
               \
 /* scan the array searching for an element of */  \
 /* type t; then check if it matches what we are */  \
 /* searching.... */          \
 for (int i=0; i < data_GetCount(); i++) {    \
  if (do_check) {          \
   occurrence++;         \
   if (n == occurrence)       \
    return i;         \
  }             \
 }              \
               \
 /* we couldn't find the required occurence */   \
 return -1;


int mcElementArrayHelpers::data_GetElemIndexOfType(int n, mcElementType t) const
{
 SCAN_ARRAY_SEARCHING(data_Get(i).data_GetType() == t);
}

int mcElementArrayHelpers::data_GetNonOpElemIndex(int n) const
{
 SCAN_ARRAY_SEARCHING(!data_isOp(i));
}

int mcElementArrayHelpers::data_GetOpIndex(int n) const
{
 SCAN_ARRAY_SEARCHING(data_isOp(i));
}



#define RETURN_ELEM_FROM_INDEX(idx_func, cast) \
 int i;          \
 if ((i=idx_func) != -1)      \
  return (cast)data_Get(i);    \
            \
 /* no elements of type t found */   \
 return (cast)mcEmptyElement;


mcElement &mcElementArrayHelpers::data_GetElemOfType(int n, mcElementType t) const
{
 RETURN_ELEM_FROM_INDEX(data_GetElemIndexOfType(n, t), mcElement &);
}

mcElement &mcElementArrayHelpers::data_GetNonOpElem(int n) const
{
 RETURN_ELEM_FROM_INDEX(data_GetNonOpElemIndex(n), mcElement &);
}

mcOperator &mcElementArrayHelpers::data_GetOp(int n) const
{
 RETURN_ELEM_FROM_INDEX(data_GetOpIndex(n), mcOperator &);
}


int mcElementArrayHelpers::data_QueueElemType(mcElementType t, int firstpos)
{
 int curpos=firstpos+2;

 // scan the monomial starting at the entry firstpos: all the elements
 // before are assumed to be not of type t
 for (int i=firstpos; i < data_GetCount(); i++) {

  // searching for elements of type t
  if (data_Get(i).data_GetType() == t) {

   // check if the first element after the + or - op is a number
   if (data_Get(firstpos).data_GetType() != t) {

    // use commutative property inside this monomial:
    // a*b*c = c*b*a   (example with firstpos==1)
    // where c is an element of type t and a is not.
    data_Swap(firstpos, i);

    // in this monomial, after this function call, an
    // element of type t will be surely present in firstpos
    //bPresent = TRUE;

   } else if (i != firstpos) {

    // place this element in the firstpos after the last
    // element of type t and subtype subt
    if (i != curpos)
     data_Swap(curpos, i);
   }
  }
 }

 return curpos-firstpos;
}

void mcElementArrayHelpers::data_DeepCopy(const mcElementHelpers *p)
{
 const mcElementArrayHelpers *e = (const mcElementArrayHelpers *)p;
 
 // destroy previous contents if presents...
 data_DeleteAll();
 
 // copy the objects inside the array
 if (e->mdata_pElemArray != NULL)
  data_AddElements(e->data_GetArray(), e->data_GetCount(), 0, TRUE);

 // copy filter pointer
 mdata_pFilter = e->mdata_pFilter;

 // then copy base class's data
 mcElementHelpers::data_DeepCopy(p);
}



void mcElementArrayHelpers::data_SetFilter(const mcFilter *p)
{
 // add the filter property recursively...
 data_ChangeFilter(p);

 mcElement pthis(this);
 data_UpdateFilterFor(pthis, p);
}

void mcElementArrayHelpers::data_ChangeFilter(const mcFilter *p)
{
 mcSAFE_DELETE(mdata_pFilter);
 
 if (p) {
  mdata_pFilter = new mcFilter();
  mdata_pFilter->DeepCopy(p);
 }
}

void mcElementArrayHelpers::data_UpdateFilterFor(mcElement &p, const mcFilter *f)
{
 // mcElementArray-derived classes have a filter associated with them
 p.data_AddRecursiveProperty(mcET_MONOMIAL, mcEP_ELEMENTARRAY_FILTER, (void *)f);
 p.data_AddRecursiveProperty(mcET_POLYNOMIAL, mcEP_ELEMENTARRAY_FILTER, (void *)f); 
}

bool mcElementArrayHelpers::data_isElementAllowed(mcElementType type) const
{
 // before proceeding with the allocation of the new element, check
 // if filter is enabled...
 if (mdata_pFilter) {

  // ...yes; filtering is enabled; now check if this element can
  // be created...
  if (!mdata_pFilter->isElementTypeAllowed(type, data_GetNumOfElemType(type)))
   return FALSE;  // ... no, it isn't
 }

 return TRUE;
}

mcElementType mcElementArrayHelpers::data_GetOpTypeBetween(int n1, int n2) const
{
 data_CheckIndex(n1);
 data_CheckIndex(n2);

 // check arguments
 if (n1 > n2) mcSWAP(int, n1, n2);
 if (n1 == n2) return data_Get(n1).data_GetType();

 // now, check the index we calculated
 mcASSERT((n2 != -1) && (n1 != -1), 
  wxT("Invalid indexes"));
 mcASSERT(n2 > n1, 
  wxT("GetIndex function doesn't work because n2 > n1"));
 mcASSERT(n2-n1 <= 2, 
  wxT("Two non-op elements cannot be separed by more than one element..."));

 // if the two elements are adjacent, then a netral operator is 
 // considered to be present...
 if (n1+1 == n2)
  return math_GetNeutralOpType();

 mcElementType res = data_Get(n1+1).data_GetType();
 mcASSERT(mcOperatorHelpers::data_isOp(res), 
   wxT("Two non-ops are separed by a non-op element ???"));

 return res;
}

mcElementType mcElementArrayHelpers::data_GetOpTypePreceding(int n) const
{
 // no preceding operator ?
 if (n == 0 || (n > 0 && !data_isOp(n-1)))
  return math_GetNeutralOpType();

 mcASSERT(data_isOp(n-1), wxT("Something wrong"));
 return data_Get(n-1).data_GetType();
}

// these two are not implemented in the header because in this way
// we can avoid mcOperator-dependency in mcElementArray.h

bool mcElementArrayHelpers::data_isOp(int entry) const
{
 data_CheckIndex(entry);
 return mcOperatorHelpers::data_isOp(data_Get(entry).data_GetType());
}

void mcElementArrayHelpers::data_AddNewOp(mcElementType type, int pos)
{
 mcElement pnew = mcElementHelpers::data_NewElem(type);
 data_AddElements(&pnew, 1, pos, TRUE);
}

void mcElementArrayHelpers::data_Move(int dn, int dk)
{

 // some checks
 mcASSERT(!data_isOp(dn), wxT("Invalid data index"));
 //if (data_isOp(dk))
 bool bmoveop = FALSE;
 if (dn > 0) bmoveop = data_isOp(dn-1);

 // detach the element to move
 mcElement tomove = data_Detach(dn);
 data_MoveElemLeft(dn);

 // detach also the operator if required
 mcElement optomove = NULL;
 if (bmoveop) {
  optomove = data_Detach(dn-1);
  data_MoveElemLeft(dn-1);
 }

 // then, make space in the new position
 data_MoveElemRight(dk);
 if (bmoveop) data_MoveElemRight(dk);

 // now we have 1 (or 2 if bmoveop == TRUE) holes at dk
 if (bmoveop)
  data_Set(dk++, optomove);
 data_Set(dk, tomove);
}

int mcElementArrayHelpers::data_MoveAllElemType(mcElementType t, mcElementArray &m)
{
 int i,max;

 for (i=0,max=data_GetNumOfElemType(t); i < max; i++) {

  // find the first element of the type t 
  int dataidx = data_GetElemIndexOfType(0, t);  

  // firstly move the element preceding the one
  // we just found, if it is a mcOperator-derived
  if (dataidx > 0 && data_isOp(dataidx-1)) {
   mcElement p = data_Detach(dataidx-1);
   data_MoveElemLeft(dataidx-1);
   m.data_AddElements(&p, 1, -1, TRUE);

   // now the element we found is placed at dataidx-1
   // (since its operator was moved)
   dataidx--;
  }

  // and detach it from us
  mcElement p = data_Detach(dataidx);
  data_MoveElemLeft(dataidx);

  // add to m this element (in the right position) without
  // copying (since we just detached it from *this)
  m.data_AddElements(&p, 1, -1, TRUE);

 }

 // max is the number of element types of type t which we moved
 return max;
}








// ---------------------------------------------------
// mcELEMENTARRAYGUI - helper functions
// ---------------------------------------------------

int mcElementArrayHelpers::gui_GetSpaceBetween() const
{
 // The CMONOMIAL_SPACE_BETWEEN value cannot be used directly
 // because it could be too high for nested exponent... we must
 // use the exponent depth to adjust it...
 return gui_GetSpaceBetweenRatio()/(gui_GetExpDepth()+1);
}

bool mcElementArrayHelpers::gui_isEndKey(const mcKey &ev) const
{
 if (data_GetCount() > 0 && data_Get(mgui_nCursorPos).gui_isEndKey(ev))
  if (gui_isArrEndKey(ev))
   return TRUE;
  return FALSE;
}
/*
void mcElementArrayHelpers::gui_DeepCopy(const mcElementGUI *p)
{
 mcElementArrayGUI *d = (mcElementArrayGUI *)p;

 // don't copy pgui_SelectionPen: it's static !!!

 mgui_nCursorPos = d->mgui_nCursorPos;
 mcElementHelpers::sgui_DeepCopy(p);
}*/

int mcElementArrayHelpers::gui_AddNewElement(mcElementType type, const mcKey &key, int pos)
{
 if (pos == -1) pos = data_GetCount();

 // create a new element of the required type
 mcElement fakearray = mcElementHelpers::data_NewElem(type);

 // exponent depth is in the previous call, so something like
 //           fakearray[0].SetAtSameLevelOf(this);
 // is not required...

 // send it its begin character
 fakearray.gui_Input(key, NULL);

 // add it to the array
 data_AddElements(&fakearray, 1, pos, TRUE);

 // 'pos' is the index of the new element
 return pos;
}

void mcElementArrayHelpers::gui_AddNewEmptyBox(int pos)
{ 
 mcKey fake(mcEmptyBoxHelpers::sgui_pNewEmptyBox->GetEvent(), TRUE);
 gui_AddNewElement(mcET_EMPTYBOX, fake, pos); 
}

void mcElementArrayHelpers::gui_DeleteNextOp()
{
 if (mgui_nCursorPos < data_GetCount()-1 &&
  data_isOp(mgui_nCursorPos+1)) {

  data_Delete(mgui_nCursorPos+1);
  data_MoveElemLeft(mgui_nCursorPos+1);
 }
}

void mcElementArrayHelpers::gui_DeletePreviousOp()
{
 if (mgui_nCursorPos > 0 &&
  data_isOp(mgui_nCursorPos-1)) {
  data_Delete(mgui_nCursorPos-1);
  data_MoveElemLeft(mgui_nCursorPos-1);
  mgui_nCursorPos--;
 }
}

wxPoint mcElementArrayHelpers::gui_GetOriginOfElem(int n, int cl) const
{
 wxPoint p;
 if (cl == -1) cl = gui_GetCenterLine();

 // use previous width to set up the x-coord
 // or recompute it using the gui_GetSize function
 p.x = gui_CalcSizeOfFirst(n, cl).GetWidth();

 // set up element rect
 p.y = cl - data_Get(n).gui_GetYAnchor();

 return p;
}

wxSize mcElementArrayHelpers::gui_CalcSizeOfRange(int begin, int end, int cl) const
{
 wxSize tmp, acc;
 int sb = gui_GetSpaceBetween();
 if (cl == -1) cl = gui_GetCenterLine();

 // Sum the width of the contained elements and operators
 // and find the tallest one
 for (int c=begin; c < end; c++) {

  // retrieve element size
  const mcElement &g = data_Get(c);
  tmp.SetWidth(g.gui_GetWidth());
  tmp.SetHeight(cl - g.gui_GetYAnchor()+ g.gui_GetHeight());

  // if this element is hidden, we must not count the space between;
  // anyway, add its size to the accumulator object
  acc.SetWidth(acc.GetWidth() + tmp.GetWidth() + sb);
  acc.SetHeight(mcMAX(acc.GetHeight(), tmp.GetHeight()));
 }

 // return calculated size
 return acc;
}

wxSize mcElementArrayHelpers::gui_CalcSizeOfFirst(int nElem, int cl) const
{
 // use the CalcSizeOfRange() function: my policy is NEVER COPY-AND-PASTE.
 // it's much better to create a single function with many variables and
 // that reuses the code (without copying and pasting anything). Then,
 // functions with more intuitive names like this, can be defined to make
 // the class more usable.
 if (cl == -1) cl = gui_GetCenterLine();
 return gui_CalcSizeOfRange(0, nElem, cl);
}

wxRect mcElementArrayHelpers::gui_GetSelectionRect(wxDC &, int x, int y, int cl) const
{
 int sb = gui_GetSpaceBetween();
 if (cl == -1) cl = gui_GetCenterLine();

 // find the lowest and the highest y in the selection
 int a=gui_GetSelStart(), b=gui_GetSelEnd();

 // no selected elements ?
 if (a == -1) return wxRect(0, 0, 0, 0);

 // calculate the size of the selected elements
 wxSize tmp = gui_CalcSizeOfRange(a, b, cl);

 // find the value which must be used as y-coord for the selection rectangle:
 // to do this, we must find the highest y anchor inside the selection...
 int miny = 0xFFFF;
 for (int i=a; i < b; i++)
  miny = mcMIN(miny, cl - data_Get(i).gui_GetYAnchor());

 // return a rectangle generated using the previously caculated size and
 // the size of the previous elements.
 wxRect ret(x+gui_CalcSizeOfFirst(a, cl).GetWidth()-sb/2, y+miny+1,
  tmp.GetWidth()+sb, tmp.GetHeight()-miny-1); // add an entire sb because from x coord
             // has been subtracted sb/2 ...
 return ret;
}

int mcElementArrayHelpers::gui_DrawSelectedElements(wxDC &hDC, int x, int y, 
           long flags, const wxPoint &pt, int cl) const
{
 // get start & end of the selection
 int a=gui_GetSelStart(), b=gui_GetSelEnd();

 // draw only the range of the selected element using our extra-flexible
 // gui_Draw() function....
 return gui_ExDraw(hDC, x, y, flags, pt, cl, a, b, TRUE);
}

int mcElementArrayHelpers::gui_DrawSelection(wxDC &hDC, int x, int y, long flags, 
          const wxPoint &pt, int cl) const
{
 wxPoint mypt(pt);
 int myflags = flags;

 int n = mcDRW_NOACTIVEELEM;
 wxBrush *pbrush = wxWHITE_BRUSH;
 bool ret = FALSE;

 // no center line ? compute it
 if (cl == -1) cl = gui_GetCenterLine();

 // calculate selection rectangle
 wxRect rc = gui_GetSelectionRect(hDC, x, y, cl);

 // no selected elements ?
 if (rc.width == 0 || rc.height == 0)
  return n;

 // if only one element is selected, we must check if it is completely
 // selected or not, before continuing
 bool bDrawRect = FALSE;

 // if this array is entirely selected and the parent allows us, then
 // draw the selection rectangle....
 bDrawRect = this->gui_isAllSelected() && (flags & mcDRW_ALLOW_TOTAL_SELECTION);

 // check for other possibilities only if we haven't still the certainty
 // that we have to draw the selection rectangle
 if (!bDrawRect) {

  // if this array contains just one selected element and it is entirely
  // selected, we can draw the selection rectangle....
  int nn = data_GetCount();
  int ns = gui_GetSelElemCount();

  // this is used, for example, when the selection is created inside a
  // mcExpContainer, like mcBracket... or when the selection is created
  // in an non-container element with an exponent...
  bool selectokay = TRUE;
  for (int i=0; i < ns; i++)
   selectokay &= gui_GetSelElem(i).gui_isAllSelected();
  bDrawRect |= (nn > ns && selectokay == TRUE);
 }

 if (bDrawRect) {

  // check if cursor is inside the bb of the entire selection;
  // if the cursor is inside the entire selection...
  if (flags & mcDRW_ALLACTIVE || (flags & mcDRW_USEPOINT && rc.Inside(pt))) {

   // ...draw the selection rect with a different background color
   pbrush = mcElementHelpers::sgui_pSelectionBrush;

   // ...and set up everything as if we are drawing a selection which
   // do not contain any container element...
   // (if the selection contains one or more container element,
   // maybe only a portion of the container element is selected;
   // in this case, we couldn't say here that the selection must
   // be drawn entirely as non-active and that the mouse cursor
   // is placed on selection...)
   mypt = wxDefaultPosition;
   myflags = myflags & ~mcDRW_USEPOINT;

   n = mcDRW_ONSELECTION;
  }

  // draw the rectangle around selected elements (this means that
  // the selection doesn't contain any container element, or that
  // the selected elements are *entirely* selected; that is, if
  // a container element is inside the selection, all its elements
  // are selected)
  if (!sgui_bDrawSelectionInverting) {
   hDC.SetPen(*sgui_pSelectionPen);
   hDC.SetBrush(*pbrush);
   hDC.DrawRectangle(rc);
  }

  // remove from the flags given to the gui_DrawSelectedElements
  // function the mcDRW_ALLOW_TOTAL_SELECTION flag: we already
  // drawn the selection rectangle for all our contained elements
  myflags = myflags & ~mcDRW_ALLOW_TOTAL_SELECTION;

  // the selected elements will be drawn with the mcDRW_NONACTIVE
  // flag, so they would sure return the mcDRW_NOACTIVELEM code;
  // but, we checked before if the cursor is inside the draw
  // rectangle; in this case, in fact, we must return the
  // mcDRW_ONSELECTION code...
  ret = FALSE;

 } else {

  // the selection contains one or more container elements which
  // are not completely selected: this means that they will care
  // about the drawing of their selection rectangles and that
  // the mouse cursor maybe placed out of one of them...
  mypt = pt;

  // ...this, in turn, implies that we must return the ID of the
  // container element which is drawn with the selected elements...
  ret = TRUE;
 }

 // draw selected elements
 int n2 = gui_DrawSelectedElements(hDC, x, y, myflags, mypt, cl);

 // draw the two decorations
#ifdef mcELEMENTARRAY_DRAW_DECORATIONS

 hDC.gui_DrawBitmap(*mcMathCore::Get()->bmpBeginTri, rc.x, rc.y, TRUE);
 hDC.gui_DrawBitmap(*mcMathCore::Get()->bmpEndTri, rc.x+rc.width-
  mcMathCore::Get()->bmpEndTri.gui_GetWidth()-1, rc.y+rc.height-
  mcMathCore::Get()->bmpEndTri.gui_GetHeight()-1, TRUE);

#endif

 // now that we've drawn the selected elements we can draw the selection
 // inverting the colors, if the relative customizable is set so...
 if (bDrawRect && sgui_bDrawSelectionInverting) {

  mcGUILOG(wxT("mcElementArrayHelpers::gui_DrawSelection [%s] - ")
   wxT("drawing the selection rectangle INVERTING"), mcTXTTHIS);

  //hDC.SetBrush(*wxBLACK_BRUSH);
  //hDC.SetPen(*wxBLACK_PEN);//TRANSPARENT_PEN);

  // to invert the colors, we must use the logical function wxINVERT;
  // anyway we *must not* forget to restore old logical function !!
  int old = hDC.GetLogicalFunction();
  hDC.SetLogicalFunction(wxINVERT);
  hDC.DrawRectangle(rc);
  hDC.SetLogicalFunction(old);
 }

 // be sure to return mcDRW_ONSELECTION/mcDRW_NOACTIVEELEM, if the selection
 // does not  contain any container element or, otherwise, to return
 // the code that the container element has returned....
 return (ret == TRUE) ? n2 : n;
}

int mcElementArrayHelpers::gui_GetBB(int n, wxRect *rc, int yCenter, int w) const
{
 mcUNUSED(w);
 
 // do we have to recompute all values ?
 if (yCenter == -1) yCenter = gui_GetCenterLine();

 wxPoint o = gui_GetOriginOfElem(n, yCenter);
 rc->x = o.x;
 rc->y = o.y;
 rc->height = data_Get(n).gui_GetHeight();
 rc->width = data_Get(n).gui_GetWidth();

 // add the space to leave between each pair of elements
 return rc->width + gui_GetSpaceBetween();
}

int mcElementArrayHelpers::gui_GetCenterLine() const
{
 int y=0;

 // use the highest Y anchor value as center line
 for (int i=0; i < data_GetCount(); i++)
  y = mcMAX(y, data_Get(i).gui_GetYAnchor());
 return y;
}

void mcElementArrayHelpers::gui_DeleteSelection()
{
 int i = gui_GetSelStart(), max = gui_GetSelEnd();
 if (max == -1) return;  // no selection...
 
 if (max-i == 1) {  // just one selected element ?
  
  // remove the elements selected inside it...
  mcElement m = gui_GetSelElem(0);

  if (m.gui_isAllSelected()) {

   // remove the element...
   data_Delete(i);
   data_MoveElemLeft(i);

  } else {

   // remove the selected portion of this element
   m.gui_DeleteSelection();
  }
  
 } else {
  
  // extended selection: remove all the selected monomials
  // (they should be entirely selected...)
  int todel = i;
  for (; i < max; i++) {
   mcASSERT(data_Get(todel).gui_isAllSelected(), 
    wxT("extended selection implies elements completely selected..."));
   data_Delete(todel);
   data_MoveElemLeft(todel);
  }
 }
 
 gui_RecalcSize();
}




// ---------------------------------------------------
// mcELEMENTARRAYGUI - mcElementGUI implementations
// ---------------------------------------------------

void mcElementArrayHelpers::gui_DoRecalcSize()
{
 // just use the CalcSizeOfFirst array function with all
 // the elements in the array....
 mgui_sz = gui_CalcSizeOfFirst(data_GetCount(), -1);
}

void mcElementArrayHelpers::gui_UpdateExpDepth()
{
 // ElementArrays must apply changes in exponent level to all
 // the elements they contain....
 for (int i=0; i < data_GetCount(); i++)
  data_Get(i).gui_SetAtSameLevelOf(this);

 // this is NOT REQUIRED since the #gui_SetAtSameLevelOf
 // function automatically calls the #gui_UpdateExpDepth function
 mcElementHelpers::gui_UpdateExpDepth();
}

int mcElementArrayHelpers::gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, 
         int cl, int b, int e, bool bDrawSelected) const
{
 mcGUILOG(wxT("mcElementArrayHelpers::gui_ExDraw [%s]"), mcTXTTHIS);

 int n=mcDRW_NOACTIVEELEM, w=0;
 wxRect rc;

 // find the highest y value for the center line
 if (cl == -1) cl = gui_GetCenterLine();

 // check the upper bound
 if (e == -1) e = data_GetCount();

 if (b > 0) {

  // if required, add the size of the skipped elements
  w = gui_CalcSizeOfFirst(b, cl).GetWidth();
 }

 // decide now the flags to give to all non active elements
 // we are going to draw...
 int nonactiveflags = mcDRW_NONACTIVE;
 if (flags & mcDRW_ALLOW_TOTAL_SELECTION)
  nonactiveflags |= mcDRW_ALLOW_TOTAL_SELECTION;

 // draw all the factors of this monomial
 for (int i=b; i < e; i++) {

  // get the element bounding box for the i-th element
  w += gui_GetBB(i, &rc, cl, w);

  // offset rect to get correct coord.
  rc.Offset(x, y);

  // is it selected ?
  if (data_Get(i).gui_isSelected()) {

   if (!bDrawSelected) {

    // skip this element: selected elements must then be drawn with
    // the gui_DrawSelection() function; this function should be
    // called by the derived class, if it wants. See the
    // differences between mcPolynomial::gui_Draw & mcMonomial::gui_Draw
    continue;
   }
  }

  // draw this element
  if (flags & mcDRW_ALLACTIVE || (flags & mcDRW_USEPOINT && rc.Inside(pt))) {

   // draw the element with the correct flag
   n = data_Get(i).gui_Draw(dc, rc.x, rc.y, flags, pt);
   mcGUILOG(wxT("mcElementArrayHelpers::gui_ExDraw - just drawn as active [%s] at (%d;%d)"), 
      mcTXT(data_Get(i)), rc.x, rc.y);

   // we can stop checking for cursor position; it is inside the
   // current element; the following elements cannot contain it
   if (!(flags & mcDRW_ALLACTIVE)) flags &= ~mcDRW_USEPOINT;

  } else {

   // the cursor is not inside this subelement
   data_Get(i).gui_Draw(dc, rc.x, rc.y, nonactiveflags, wxDefaultPosition);
   mcGUILOG(wxT("mcElementArrayHelpers::gui_ExDraw - just drawn as inactive [%s] at (%d;%d)"), 
      mcTXT(data_Get(i)), rc.x, rc.y);
  }
 }

 // a piece of code useful to debug...
#ifdef mcELEMENTARRAY_DBG_DRAWCENTERLINE
 dc.DrawLine(x, y+cl, x+gui_GetWidth(), y+cl);
#endif

 // return the ID of the active element
 return n;
}

int mcElementArrayHelpers::gui_ExGetRelCursorPos(wxDC &hDC, wxPoint *pt, int cl) const
{
 int n, n2, n3 = ((cl == -1) ? gui_GetCenterLine() : cl);

 // be sure array is not empty and cursor position is okay
 if (data_GetCount() == 0)
  return 0;
 gui_CheckCursorPos();

 // Get relative position of the element where cursor is located
 n = data_Get(mgui_nCursorPos).gui_GetRelCursorPos(hDC, pt);
 n2 = data_Get(mgui_nCursorPos).gui_GetYAnchor();

 // offset the pt coord. to the coord. relative to this element
 // get the size of all the elements that precedes the cursor
 pt->x += gui_CalcSizeOfFirst(mgui_nCursorPos, cl).GetWidth();

 // offset the cursor of the same amount of pixel that was used
 // to offset the current focused element
 pt->y += n3-n2;

 return n;
}

void mcElementArrayHelpers::gui_ExOnSelect(wxDC &dc, wxRect &rc, int cl)
{
 int i, w=0, begin = 0xFFFF, end = -1;
 wxRect bb;

#if 0
 dc.SetPen(*wxBLACK_PEN);
 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 dc.DrawRectangle(rc);
#endif

 // no center line ? compute it
 if (cl == -1) cl = gui_GetCenterLine();

 // a new selection is in progress; delete old one
 gui_DeSelect();

 // we must call the element with the given rect intersecting their bounding boxes
 for (i=0; i < data_GetCount(); i++) {

  // retrieve element's bounding box and offset it to the current position
  w += gui_GetBB(i, &bb, cl, w);

  if (bb.Intersects(rc)) {

   // call the element function; but continue to test for
   // other elements which intersect the selection rectangle
   wxRect tmp(rc);
   tmp.Offset(-bb.x, -bb.y);

   data_Get(i).gui_OnSelect(dc, tmp);
   begin = mcMIN(begin, i);
   end = mcMAX(end, i+1);

  } /*else if (end != -1) {

   // we have already found the piece of the array which intersects
   // the selection rectangle... stop

   // WARNING: this cannot be done because some elements in the
   // middle of the array maybe too small to intersect selection; but
   // this doesn't mean that all the following are are so small, too.
  }*/
 }


 // ADJUST THE SELECTION IF IT IS EXTENDED AMONG VARIOUS ELEMENTS
 // (that is, selection is extended among 2 or more subelements)
 if (end-begin > 1) {

  // select all those elements whose bounding boxes are placed between the
  // begin and the end of the selected elements, but which do not intersect with
  // the selection rectangle because too small...
  for (i=begin; i < end; i++)
   data_Get(i).gui_SelectAll();

  // be sure also the operator placed before the first selected element (if present),
  // is selected, too. This is an important check because math functions
  // require it !!!
  int a = gui_GetSelStart();
  if (a > 0 && data_isOp(a-1)) // -1 means: there are no selected elements
   data_Get(a-1).gui_SelectAll();

  // be also sure that selection does not end with an operator; this is
  // another important prerequisite for math functions !!
  a = gui_GetSelEnd();
  if (a > 0 && data_isOp(a-1)) // a is the index of the first non-selected element
   data_Get(a-1).gui_DeSelect();
 }

 // if this element contains at least one selected element, we must set
 // the selection flag...
 // NOTE: we cannot just check if wxT("end") is different from "-1" because
 //       even if the selection rectangle intersects the bounding box
 //       of some of our childrens, they could have set themselves
 //       as non-selected since the selection rectangle intersects
 //       their _boundingbox_ not their graphical output
 if (gui_GetSelElemCount() > 0)
  this->gui_Select();
}

mcInputRes mcElementArrayHelpers::gui_Input(const mcKey &key, mcElement *pnew)
{
 mcGUILOG(wxT("mcElementArrayHelpers::gui_Input - before processing: [%s]"), mcTXTTHIS);

 mcInputRes res = mcIR_OKAY;
 mcElementType n;
 mcCursorPos pos;

 // if a new element must be allocated...
 if (data_GetCount() == 0 || data_Get(mgui_nCursorPos).gui_isEndKey(key)) {

  // is k the begin char of a mcElement derived class ?
  n = mcElementHelpers::gui_isKeyBeginKey(key);
  if (n == mcET_INVALID) {
   
   // stop here key processing
   mcMathCore::Get()->SyntaxError(wxT("Character not recognized"));
   return mcIR_OKAY;
  }

  // check if the filter allow us to create an instance of this object...
  if (!data_isElementAllowed(n)) {
   
   // creation of this element is not allowed...
   mcMathCore::Get()->SyntaxError(wxT("Element not allowed"));
   return mcIR_OKAY;
  }

  // check where is the cursor at this moment
  if (data_GetCount() == 0)
   pos = mcCP_BEGIN;
  else
   pos = data_Get(mgui_nCursorPos).gui_GetCursorPos();

  /*switch (pos) {
  case mcCP_BEGIN:*/
  if (pos.isBegin()) {

   // we must shift the array to make room for a new
   // element located not at the end of the array
   // (here, we are sure ew are not at the end of the array
   // because we are at the beginning of an element);

   // move everything right to make space for the new element
   data_MoveElemRight(mgui_nCursorPos);

   // add the new element
   mgui_nCursorPos = gui_AddNewElement(n, key, mgui_nCursorPos);   

  } else if (pos.isInside()) {

   // the user has pressed an end char for the focused element
   // while the cursor was *inside* that element: we must then
   // split that element in two parts...
   // Typical examples of elements which can be split are
   // mcNumber and mcMonomial...
   gui_DoSplit(n, key);

  } else if (pos.isEnd()) {

   data_MoveElemRight(mgui_nCursorPos+1);
   //data_mdata_nElements--;
   mgui_nCursorPos = gui_AddNewElement(n, key, mgui_nCursorPos+1);
   //data_mdata_nElements++;

  } else {

   mcASSERT(0, wxT("Unhandled cursor position"));
  }

 } else {

  // deliver this input to the focused monomial
  res = data_Get(mgui_nCursorPos).gui_Input(key, pnew);

  // call the function which must "backprocess" the
  // returned flag (contained in 'n')
  res = gui_BackInput(key, pnew, res);
 }

 // size should have changed
 gui_UpdateExpDepth();  // this calls RecalcSize()
 //gui_DeepRecalcSize();
 gui_RecalcSize();

 // do some checks
 data_Check();
 gui_CheckCursorPos();

 // mcIR_OKAY by default, or something else if something has modified 'res'
 mcGUILOG(wxT("mcElementArrayHelpers::gui_Input - after processing: [%s]"), mcTXTTHIS);
 return res;
}

void mcElementArrayHelpers::gui_MoveCursorLeft()
{
 for (int i=mgui_nCursorPos-1; i >= 0; i--) {
  if (data_Get(i).gui_LetInCursor(mcCP_END)) {
   mgui_nCursorPos = i;
   return;
  }
 }
}

void mcElementArrayHelpers::gui_MoveCursorRight()
{
 for (int i=mgui_nCursorPos+1; i <= data_GetCount(); i++) {
  if (data_Get(i).gui_LetInCursor(mcCP_BEGIN)) {
   mgui_nCursorPos = i;
   return;
  }
 }
}

mcMoveCursorRes mcElementArrayHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 int result=0;

 // check cursor position just to be sure mgui_nCursorPos is okay
 gui_CheckCursorPos();

 // call the move cursor function of the currently focused element
 result = data_Get(mgui_nCursorPos).gui_MoveCursor(flag, modifiers);
 if (data_Get(mgui_nCursorPos).gui_isSelected())
  gui_Select();

 // WARNING: this is experimental !!!
 // this code will be executed when the cursor is at the border
 // of two non-mcOperator elements:
 //
 //       a|x      123ax|(...)       23*56/7a|x
 //
 // This piece of code, in fact, will try to keep the cursor *always*
 // on the left element, in these cases... this is due to the fact
 // that, in this cases:
 // 
 //        123a|          [LEFT]
 //        123|a          [4]
 //
 // something like wxT("123*4a") would be created instead of "1234a" because
 // the cursor would be considered to be on the leftmost position of
 // the mcSymbol "a" instead of the rightmost position of the mcNumber
 // "123"... to avoid this, we need to keep the cursor always on the
 // left element...
 if (result == mcMCR_OKAY && 
  data_Get(mgui_nCursorPos).gui_GetCursorPos().isBegin()) {
  
  // if the cursor is on the lefmost position of an element
  // which is preceded by a non-mcOperator element...
  if (mgui_nCursorPos > 0 && !data_isOp(mgui_nCursorPos-1)) {
   
   // then, move cursor left...
   gui_MoveCursorLeft();
   /*mgui_nCursorPos--;
   data_Get(mgui_nCursorPos)->gui_SetCursorPos(mcCP_END);*/
  }
 }
 

 // check if we have to change focus
 switch (result) {
 case mcMCR_SETFOCUS_PREVIOUS:

  if (mgui_nCursorPos > 0) {

   // if the cursor is placed on the leftmost point of the focused
   // element:
   //              1234ab*123|d     ('d' is the focused element)
   // and there is no operator between the focused element and the
   // previous one, we must then not only set the focus on the previous
   // element but also move the cursor left inside it:
   //              1234ab*12|3d     ('123' is now the focused element)
   bool b = !data_isOp(mgui_nCursorPos) && !data_isOp(mgui_nCursorPos-1);

   gui_MoveCursorLeft();
   if (b) gui_MoveCursor(mcMCF_LEFT, modifiers);

  } else {

   // can't set focus on previous element because it
   // doesn't exist in this polynomial
   return mcMCR_SETFOCUS_PREVIOUS;
  }
  break;

 case mcMCR_SETFOCUS_NEXT:

  if (mgui_nCursorPos < data_GetCount()-1) {

   // like for mcMCR_SETFOCUS_PREVIOUS, also in this case we must check
   // if we have to move cursor right again after the gui_MoveCursorRight()
   // call....
   bool b = !data_isOp(mgui_nCursorPos) && !data_isOp(mgui_nCursorPos+1);

   gui_MoveCursorRight();
   if (b) gui_MoveCursor(mcMCF_RIGHT, modifiers);

  } else {

   // can't set focus on next element because it
   // doesn't exist in this polynomial
   return mcMCR_SETFOCUS_NEXT;
  }
  break;

  // cannot move cursor up or down...
 case mcMCR_SETFOCUS_BELOW:
  return mcMCR_SETFOCUS_BELOW;
 case mcMCR_SETFOCUS_ABOVE:
  return mcMCR_SETFOCUS_ABOVE;
 }

 return mcMCR_OKAY;
}

int mcElementArrayHelpers::gui_ExMoveCursorUsingPoint(wxDC &hDC, const wxPoint &pt, int cl)
{
 // do some checks to avoid useless work
 if (pt.x > gui_GetWidth() || pt.y > gui_GetHeight())
  return mcMCR_CANNOT_SETFOCUS;

 // find the element which contains the given point
 if (cl == -1) cl = gui_GetCenterLine();
 int w=0;
 wxRect rc;

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

  // get element BB
  w += gui_GetBB(i, &rc, cl, w);

  // check if user clicked inside this element
  if (rc.Inside(pt) == TRUE) {

   // our search is finished !!! We have found the clicked element;
   // just update his cursor variables and return...

   // warning: user cannot select an operator
   if (data_isOp(i)) {

    // cannot set focus on an operator... set focus
    // on the previous element...
    mgui_nCursorPos = (i-1 >= 0) ? i-1 : i+1;
    data_Get(mgui_nCursorPos).gui_LetInCursor(mcCP_END);

    // ok, we set the cursor
    return mcMCR_OKAY;
   }

   // update cursor variable
   mgui_nCursorPos = i;
   gui_CheckCursorPos();

   // update also element's variables
   wxPoint p(pt.x-rc.x-gui_GetSpaceBetween(), pt.y-rc.y);
   data_Get(mgui_nCursorPos).gui_MoveCursorUsingPoint(hDC, p);

   // finished processing the message
   return mcMCR_OKAY;
  }
 }

 // given point is not inside an element... sorry
 return mcMCR_CANNOT_SETFOCUS;
}

void mcElementArrayHelpers::gui_GetCursorPos(mcCursorPos &cp) const
{
 // check for begin pos
 if (data_GetCount() == 0) {
  cp.gui_Push(mcCP_BEGINEND); // not a begin nor an end...
  return;
 }

 if (mgui_nCursorPos == 0) {
  mcCursorPos r(data_Get(0).gui_GetCursorPos());

  if (r.isBegin() || r.isBeginEnd()) {
   cp.gui_Push(mcCP_BEGIN);
   return;
  }
 }

 // if the first element of the array is an operator, the cursor cannot
 // reach it: thus, we must consider it placed at the beginning when
 // mgui_nCursorPos == 1
 if (mgui_nCursorPos == 1 && data_isOp(0)) {
  mcCursorPos r(data_Get(1).gui_GetCursorPos());

  if (r.isBegin() || r.isBeginEnd()) {
   cp.gui_Push(mcCP_BEGIN);
   return;
  }
 }

 // check for end pos
 int n = data_GetCount()-1;
 if (mgui_nCursorPos == n) {
  mcCursorPos r(data_Get(n).gui_GetCursorPos());

  if (r.isEnd() || r.isBeginEnd()) {
   cp.gui_Push(mcCP_END);
   return;
  }
 }

 //return mcCP_INSIDE;
 data_Get(mgui_nCursorPos).gui_GetCursorPos(cp);
}

void mcElementArrayHelpers::gui_SetCursorPos(const mcCursorPos &code)
{
 if (data_isArrayEmpty())
  return;   // cannot move cursor anywhere in this case !!!

 // move the cursor at the beginning or the end of the array
 if (code.isBegin()) {

  mgui_nCursorPos = 0;

  // check also that the cursor has not been placed on an operator
  if (data_isOp(mgui_nCursorPos))
   mgui_nCursorPos++;
  data_Get(mgui_nCursorPos).gui_SetCursorPos(mcCP_BEGIN);
  
 } else if (code.isEnd()) {

  mgui_nCursorPos = data_GetCount()-1;

  // check also that the cursor has not been placed on an operator
  if (data_isOp(mgui_nCursorPos))
   mgui_nCursorPos--;
  data_Get(mgui_nCursorPos).gui_SetCursorPos(mcCP_END);
 
 } else {

  mcASSERT(0, wxT("Couldn't accept these flags"));  
 }
}

mcElement mcElementArrayHelpers::gui_GetSelection() const
{
 int n = gui_GetSelElemCount();

 // no selection ?
 if (n == 0)
  return mcEmptyElement;

 if (n == 1) {
  // if just one element is selected, we must then return its
  // selected subelements....
  mcElement tmp(gui_GetSelElem(0).gui_GetSelection());
  mcASSERT(tmp != mcEmptyElement, wxT("Something wrong"));

  // if the selection is already a mcPolynomial or an element of
  // this same type, we do not need to modify it (it's the only
  // element selected)...
  if (tmp.data_GetType() == mcET_POLYNOMIAL || 
   tmp.data_GetType() == data_GetType())
   return tmp;

  // go on encapsulating the result in a mcElementArray of this same type
  // restart from zero...
 }

 // more than one element is selected: we must create another
 // mcElementArray containing only selected elements
 mcElementArray sel(mcElementHelpers::data_NewElem(data_GetType()));

 // scan the selected elements and insert them into the
 // array we will return...
 for (int i=0; i < n; i++) {

  mcElement toinsert(gui_GetSelElem(i).gui_GetSelection());
  mcASSERT(toinsert != mcEmptyElement, wxT("We should have a valid selection !"));

  toinsert.data_MakePrivateCopy();
  sel.data_AddElements(&toinsert, 1, -1, TRUE);
 }

 return sel;
}

int mcElementArrayHelpers::gui_GetActiveElemIndex(int x, int y, const wxPoint &pt, int cl)
{
 wxRect rc;
 int w=0;

 // find the highest y value for the center line
 if (cl == -1) cl = gui_GetCenterLine();

 // draw all the factors of this monomial
 for (int i=0; i < data_GetCount(); i++) {

  // get the element bounding box for the i-th element
  w += gui_GetBB(i, &rc, cl, w);

  // offset rect to get correct coord.
  rc.Offset(x, y);

  // does the rect of this element contain the mouse cursor ?
  if (rc.Inside(pt)) {
   if (data_Get(i).gui_isSelected())
    return mcDRW_ONSELECTION;
   return i;
  }
 }

 // no elements currently active
 return mcDRW_NOACTIVEELEM;
}

void mcElementArrayHelpers::gui_AddNewOp(mcElementType nOpType, int pos)
{
 // this function is different from mcElementArrayHelpers::data_AddNewOp:
 // check to believe... :-)
 mcKey fake(mcOperatorHelpers::data_GetOpSymbol(nOpType).GetChar(0));
 gui_AddNewElement(nOpType, fake, pos);
}



 /*mcCursorPos cp(data_Get(mgui_nCursorPos));

 if (cp.isInside() || cp.isUndefined()) {

  return FALSE;
 }

 // the cursor is placed on the begin/end of an element.
 if (cp.isBegin()) {


 }

 if (cp.isEnd()) {

  data_MoveElemRight(mgui_nCursorPos);
  //data_AddElements(
  if (toinsert.data_GetType() == mcET_POLYNOMIAL)
 }*/




// ----------------------------------------
// mcELEMENTARRAYIO
// ----------------------------------------

wxString mcElementArrayHelpers::io_GetInlinedExpr() const
{
 wxString str;

 // concatenate the inlined expressions which compose the math contents
 for (int i=0; i < data_GetCount(); i++)
  str += data_Get(i).io_GetInlinedExpr();

 return str;
}





// ----------------------------------------
// mcELEMENTARRAYMATH - miscellaneous
// ----------------------------------------

void mcElementArrayHelpers::math_EmbedInBracketAndRaiseTo(const mcRealValue &n)
{ math_EmbedInBracket().data_GetBracket().math_RaiseTo(mcPolynomial(n)); }

void mcElementArrayHelpers::math_EmbedInBracketAndRaiseTo(const mcPolynomial &p)
{ math_EmbedInBracket().data_GetBracket().math_RaiseTo(p); }

void mcElementArrayHelpers::math_EmbedInRadicalAndRaiseTo(const mcPolynomial &p)
{ math_EmbedInRadical().data_GetBracket().math_RaiseTo(p); }

int mcElementArrayHelpers::math_GetIndexOf(int occ, const mcElement &tofind) const
{
 int idx = math_NonRecursiveFindInChildren(occ, tofind);
 if (idx == -1) return -1;

 // VERY IMPORTANT: we cannot just return "idx" since it's in children coord;
 //                 we must first convert it to math coordinates...
 return math_DataToMathIdx(idx);
}

mcArrayEntry mcElementArrayHelpers::math_WrapSymbol(const mcSymbolProperties *sym)
{
 mcSymbol s(sym->data_GetSafeLinkedSym());
 mcASSERT(s.data_isOk(), wxT("Invalid safe symbol ?"));
 return math_WrapSimple(s);
}

mcArrayEntry mcElementArrayHelpers::math_WrapNumber(const mcRealValue &val)
{
 mcNumber n(val);
 return math_WrapSimple(n);
}

const mcSymbolProperties *mcElementArrayHelpers::math_GetWrappedSymbol() const
{
 mcSymbol sym(math_GetWrapped(mcET_SYMBOL));
 if (sym != mcEmptyElement)
  return sym.data_GetProperties();
 return NULL;
}

mcRealValue mcElementArrayHelpers::math_GetWrappedNumber() const
{
 const mcNumber num(math_GetWrapped(mcET_NUMBER));
 if (num != mcEmptyElement)
  return num.data_Get();
 return *mcRealValue::pNAN;
}

void mcElementArrayHelpers::math_ResetToOne()
{
 // reset 
 data_DeleteAll();

 // and add a mcNumber set to 1
 mcASSERT(mcNumberHelpers::smath_pOne, wxT("All statics should be ready..."));
 math_WrapSimple(*mcNumberHelpers::smath_pOne);
}

void mcElementArrayHelpers::math_ResetToZero()
{
 // reset 
 data_DeleteAll();

 // and add a mcNumber set to 0
 mcASSERT(mcNumberHelpers::smath_pZero, wxT("All statics should be ready..."));
 math_WrapSimple(*mcNumberHelpers::smath_pZero);
}

mcArrayEntry mcElementArrayHelpers::math_EmbedInBracket()//int *n, int count)
{
 // allocate a new mcBracket
 mcBracket br;
 mcPolynomial pol(math_GetPolynomialWrapper());
 br.data_SetContent(pol);

 // clear all the old contents
 data_DeleteAll();
 
 // this object will take care of the bracket...
 mcArrayEntry ourb = math_WrapSimple(br); 
 mcASSERT(ourb.data_GetRef().data_GetType() == mcET_BRACKET, wxT("What is this ?!?!?"));

 return ourb;
}

mcArrayEntry mcElementArrayHelpers::math_EmbedInRadical()
{
 // allocate a new mcRadical
 mcRadical rad;
 mcPolynomial pol(math_GetPolynomialWrapper());
 rad.data_SetContent(pol);

 // clear all the old contents
 data_DeleteAll();
 
 // this object will take care of the bracket...
 mcArrayEntry ourb = math_WrapSimple(rad); 
 mcASSERT(ourb.data_GetRef().data_GetType() == mcET_RADICAL, wxT("What is this ?!?!?"));

 return ourb;
}

mcArrayEntry mcElementArrayHelpers::math_EmbedInFraction(bool bAsDenominator)
{
 // create a mcFraction
 mcFraction pelem;
 mcPolynomial pol = math_GetPolynomialWrapper();
 
 if (bAsDenominator) {

  // create a numerator containing only a mcNumber(1) and a denominator
  // containing a copy of this polynomial
  pelem.data_SetDen(pol);
  pelem.data_SetNum(*mcPolynomialHelpers::smath_pOne);

 } else {

  // do viceversa
  pelem.data_SetNum(pol);
  pelem.data_SetDen(*mcPolynomialHelpers::smath_pOne);
 }

 // delete all the elements contained in this array
 data_DeleteAll();
 mcMATHLOG(wxT("mcElementArrayHelpers::math_EmbedInFraction - the fraction is [%s]"), mcTXT(pelem));

 // and add only the fraction we built in a new monomial
 mcArrayEntry ourf = math_WrapSimple(pelem);  // pelem is now contained in this array 
 data_Check();

 // return the result of our work (WHICH HAS BEEN ALREADY ADDED TO THE ARRAY !!!) 
 mcASSERT(ourf.data_GetRef().data_GetType() == mcET_FRACTION, wxT("What is this ?!?!?"));
 return ourf;
}

mcRealValue mcElementArrayHelpers::math_Evaluate() const
{
 mcMATHLOG(wxT("mcElementArrayHelpers::math_Evaluate [%s]"), mcTXTTHIS);

 // check if this function can work correctly...
 if (data_isArrayEmpty())
  return math_GetNeutralValue();

 // we won't check for unknowns/parameters for two reasons:
 // 1) doing something like
 //      if (math_ContainsUnknowns() || math_ContainsParameters())
 //         return *mcRealValue::pNAN;
 //    is slow (recursive search) on big arrays
 // 2) doing so, we would inhibit the "evaluation mode" of mcSymbol
 //    (see mcSymbolProperties::m_bEvaluating for more info)

 // yes; it can... begin algorithm
 mcRealValue acc = math_Get(0).math_Evaluate();
 if (!acc.isValid()) return *mcRealValue::pNAN;

 // init the accumulation variable, checking if the array begins with
 // an operator and, in this case, using the neutral value of this
 // array applied on it...
 if (data_isOp(0))
  acc = mcOperator(data_Get(0)).math_Evaluate(math_GetNeutralValue(), acc);

 for (int i=0, max=math_GetCount()-1; i < max; i++) {

  // accumulate in the "acc" variable the already
  // computed symbols...
  mcRealValue tmp = math_Get(i+1).math_Evaluate();

  // do not proceed if one of the operand is not valid...  
  if (tmp.isNAN() || acc.isNAN())
   return *mcRealValue::pNAN;

  acc = math_GetOpBetween(i, i+1).math_Evaluate(acc, tmp);
 }
 
 return acc;
}

mcBasicOpRes mcElementArrayHelpers::math_MakeReciprocal(mcElement *)
{
 // just embed ourselves in the denominator of a fraction 
 math_EmbedInFraction(TRUE);

 return mcBOR_REMOVE_OPERAND;
}

int mcElementArrayHelpers::math_ReorderElements(mcElement *arr, int nelements, 
          int start, int toskip)
{
 int mov = 0;

 // alphabetically reorder the sequence of mcSymbols using the
 // INSERTION SORT algorithm; for more info on the algorithm please 
 // refer to the good explanation at:
 //   http://www.wikipedia.org/wiki/Insertion_sort
 //
 // I decided to use this algorithm because:
 // 1) it's simple to implement also on our special array
 // 2) it's really efficient for a small number of elements to sort
 //    (which is usually our case)
 // 3) it works in place: that is, this algorithm does not require
 //    any extra memory to run

 // this algorithm will work only if among the entries from
 // symstart to symstart+nsymbols there are no operators
 for (int i=start; i < nelements; i+=toskip) {

  mcElement removedop(mcEmptyElement);
  mcElement removed = arr[i];
  if (i > 0 && mcOperatorHelpers::data_isOp(arr[i-1].data_GetType())) 
   removedop = arr[i-1];

  int insert = i;
  
  // we must put "removed" before all those elements which 
  // are greater than it and after all those elements which
  // are lesser than it:
  //
  // .--------------------------------------------------------------. 
  // | elements     | new position for | elements    | old position |
  // | <= wxT("removed") |    wxT("removed")     | > wxT("removed") | of "removed" |
  // .--------------------------------------------------------------
  // 
  while (insert > start) { 
   
   // get the other comparison element
   mcElement previous = arr[insert-toskip];   
   mcASSERT(!mcOperatorHelpers::data_isOp(previous.data_GetType()),
     wxT("I've found two adiacent operators..."));

   // do we have to continue to shift the array ?
   bool cont = removed.math_isListedBeforeOf(previous);
   if (!cont) break;

   // shift the [insert-1]-th element one place right
   arr[insert] = arr[insert-toskip];
   if (insert-toskip > 0)
    arr[insert-1] = arr[insert-toskip-1];
   insert-=toskip;

   // remember how many movements we did...
   mov++;
  }

  if (removedop != mcEmptyElement) {
   
   // place operator before the ordinary elements
   mcASSERT(insert > 0, wxT("Something wrong"));
   arr[insert-1] = removedop;   
  }

  // new position for the removed element
  arr[insert] = removed;
 }

 return mov;
}

bool mcElementArrayHelpers::math_isWrappingOnly(mcElementType t) const
{
 // check that we contains only an element of the given type:
 // data_isWrappingOnly does the same but checking also for mcOperators
 // that we ignore here...
 if (math_GetCount() > 1)
  return FALSE;
 if (data_Get(0).data_GetType() == t)
  return TRUE;
 return FALSE;
}

const mcElement &mcElementArrayHelpers::math_GetWrapped(mcElementType t) const
{
 if (!math_isWrappingOnly(t))
  return mcEmptyElement;
 return math_Get(0);
}





// ----------------------------------------
// mcELEMENTARRAYMATH - simplification
// ----------------------------------------

mcExpSimRes mcElementArrayHelpers::math_HandleExpSimFlag(mcExpSimRes r, 
               mcElement *pnew, int i)
{
 // we need i to be in DATA coord since we're going to use a lot of data functions
 //i = math_MathToDataIdx(i);
 data_CheckIndex(i);
 
 switch (r) {
 case mcESR_REPLACE_THIS:
  mcASSERT(pnew, wxT("What should I use as replacement ?"));
  if ((*pnew).data_GetType() == data_GetType()) {
   
   // remove the i-th element
   data_Delete(i);
   data_MoveElemLeft(i);
   
   // replace it with all the elements contained in the monomial...
   mcElementArray m(*pnew);
   data_AddElements(m.data_GetArray(), m.data_GetCount(), i);

   // we did not copy the elements; we just attached its element
   // (for better performances) to *this, so we don't want to
   // immediately delete pnew (because this would imply the
   // deletion of all its elements):
   m.data_DetachAll();
   
  } else {
   
   // this should be a simple element
   data_AddElements(pnew, 1, i, TRUE);
  }

  return mcESR_NOTFINISHED;  // still to work...
  
 case mcESR_DELETE_THIS:
  data_Delete(i);
  data_MoveElemLeft(i);
  return mcESR_NOTFINISHED;  // still to work...
  
 case mcESR_NOTFINISHED:
  return mcESR_NOTFINISHED;  // still to work... 
  
 case mcESR_DONE:
  break;

 case mcESR_INVALID_DATA:
 case mcESR_DISTRIBUTE:
  mcASSERT(0, wxT("Cannot handle this return flag..."));

 default:
  mcASSERT(0, wxT("Unhandled return flag"));
 }
 
 // the element is completely simplified/expanded
 return mcESR_DONE;
}

#define mcIMPLEMENT_EXPSIM_FUNCTION(x, y, cond)       \
mcExpSimRes mcElementArrayHelpers::x(long flags, mcElement *pp)   \
{                  \
 bool stilltowork = FALSE;           \
 mcElement pnew;              \
                  \
 mcMATHLOG(wxT("mcElementArrayHelpers::") wxT(#x)     \
          wxT(" [%s]"), mcTXTTHIS);   \
                  \
 /* NOTE: cannot store data_GetCount() in a variable like "max" */ \
 /*       and check wxT("i") against it because the number of elements */ \
 /*       contained can change after first loop.     */ \
 for (int i=0; i < data_GetCount(); i++) {       \
                  \
  /* If "cond" is constant a warning W8066 will be generated by BCC */ \
  if (cond) {              \
   mcMATHLOG(wxT("mcElementArrayHelpers::") wxT(#x)   \
    wxT(" - I won't process [%s]"), mcTXT(data_Get(i))); \
   continue;             \
  }                \
                  \
  mcMATHLOG(wxT("mcElementArrayHelpers::") wxT(#x)    \
   wxT(" - I'm going to process [%s]"), mcTXT(data_Get(i))); \
  mcExpSimRes r = data_Get(i).y(flags, &pnew);     \
                  \
  /* this function will return only three values */    \
  /* (mcESR_DONE, mcESR_NOTFINISHED, mcESR_REPLACE_THIS,  */  \
  /* mcESR_DISTRIBUTE) handling all the remaining ones... */  \
  mcExpSimRes res = math_HandleExpSimFlag(r, &pnew, i);   \
                  \
  /* check if it was not completely simplified */     \
  switch (res) {             \
  case mcESR_NOTFINISHED:           \
   stilltowork = TRUE;           \
   break;              \
  case mcESR_CHANGE_SIGN:           \
   return mcESR_CHANGE_SIGN;         \
  case mcESR_REPLACE_THIS:          \
   mcASSERT(pp, wxT("Need a valid pointer"));     \
   *pp=pnew;             \
   return mcESR_REPLACE_THIS;         \
  case mcESR_DISTRIBUTE:           \
   mcASSERT(pp, wxT("Need a valid pointer"));     \
   *pp=pnew;             \
   return mcESR_DISTRIBUTE;         \
                  \
  default:              \
   /* math_HandleExpSimFlag should have already */    \
   /* handled all other flags...   */     \
   mcASSERT(res == mcESR_DONE,         \
    wxT("Bug in math_HandleExpSimFlag ?"));     \
   break;              \
  }                \
 }                 \
                  \
 /* check that we did no errors */         \
 data_Check();              \
                  \
 /* stop here this simplification step, if our elements must */  \
 /* still be completely simplified/expanded...   */   \
 if (stilltowork)             \
  return mcESR_NOTFINISHED;          \
 return mcESR_DONE;             \
}

mcIMPLEMENT_EXPSIM_FUNCTION(math_SimplifyAll, math_Simplify, 0)
mcIMPLEMENT_EXPSIM_FUNCTION(math_SimplifyExp, math_Expand, 
       !math_SimplifyNeedExp(flags, i))

bool mcElementArrayHelpers::math_SimplifyNeedExp(long flags, int i) const
{
 const mcElement &p = data_Get(i);

 if (flags & mcEXPSIM_KEEP_FACTORIZATION)
  return FALSE;

 // in cases like:
 //
 //      k(x-a)+jx
 //
 // we need to expand (x-a)
 if (p.math_ContainsSymbols())
  return TRUE;
 return FALSE;
}

mcExpSimRes mcElementArrayHelpers::math_SimplifyRemoveNeutrals(long flags)
{
 mcMATHLOG(wxT("mcElementArrayHelpers::math_SimplifyRemoveNeutrals"));
 bool stilltowork = FALSE;

 // the cycle must be started only if there are more than 1 elements
 // in the array: if there is only one, then, even if it is a 
 // neutral element, it cannot be removed because this array would
 // otherwise be empty
 if (data_GetCount() > 1) {

  // remove neutral elements from the array
  for (int i=0; i < data_GetCount(); i++) {
  
   // the following test is obviously not completely
   // exact: it is possible to imagine a very complex
   // element which evaluates in the end to the neutral
   // value but cannot be calculated completely by math_Evaluate().
   if (data_Get(i).math_EvaluatesTo(math_GetNeutralValue())) {
    
    // remove the i-th element and its preceding op
    mcLOG(wxT("mcElementArrayHelpers::math_SimplifyRemoveNeutrals -")
         wxT(" removing the %dth element"), i);
    math_Remove(math_DataToMathIdx(i));
    stilltowork = TRUE;
   }
  }
 }

 if (stilltowork)
  return mcESR_NOTFINISHED;
 return mcESR_DONE;
}

void mcElementArrayHelpers::math_HandleBasicOpRes(mcBasicOpRes res, mcElement replacement, 
             int repidx)
{
 mcMATHLOG(wxT("mcElementArrayHelpers::math_HandleBasicOpRes [%s]"), mcTXTTHIS);
 
 mcElementType newop = mcET_INVALID;
 if (res == mcBOR_REPLACE_OPERAND_AND_SET_MULTOP) newop = mcET_MULTOP;
 if (res == mcBOR_REPLACE_OPERAND_AND_SET_DIVOP) newop = mcET_DIVOP;
 if (res == mcBOR_REPLACE_OPERAND_AND_SET_ADDOP) newop = mcET_ADDOP;
 if (res == mcBOR_REPLACE_OPERAND_AND_SET_SUBOP) newop = mcET_SUBOP;

 switch (res) {
 case mcBOR_INVALID:
 default:
  mcASSERT(0, wxT("Something is wrong... cannot handle this flag"));
  break;
  
 case mcBOR_REPLACE_OPERAND:
 case mcBOR_REPLACE_OPERAND_AND_SET_MULTOP:
 case mcBOR_REPLACE_OPERAND_AND_SET_DIVOP:
 case mcBOR_REPLACE_OPERAND_AND_SET_ADDOP:
 case mcBOR_REPLACE_OPERAND_AND_SET_SUBOP:
  {
   // we are going to need a DATA index and not a MATH index
   // as given by the caller
   int repdataidx = math_MathToDataIdx(repidx);

   // "replacement" should contain the replacement element
   mcASSERT(replacement != mcEmptyElement, wxT("Invalid pointer"));
   data_AddElements(&replacement, 1, repdataidx, TRUE);
   data_Check();
   
   if (newop != mcET_INVALID) {
    
    mcASSERT(repdataidx > 0, wxT("There is no operator we can change..."));
    
    // change also the operator between the element whose basic
    // operation's result flag we're handling and the just replaced operand...
    if (!data_isOp(repdataidx-1))
     data_MoveElemRight(repdataidx-1);
    else
     data_Delete(repdataidx-1);
    
    mcElement pnewop = mcElementHelpers::data_NewElem(newop);
    data_AddElements(&pnewop, 1, repdataidx-1);
   }
  }
  break;
  
 case mcBOR_REMOVE_OPERAND:
  
  // NOTE: in a first approach, here the operator (p)
  //       and the second argument (right) were removed
  //       with 
  //                         Remove(i+1);
  //       but now, nothing is removed: the second operand
  //       is transformed in a neutral element which is then
  //       removed in math_SimplifyRemoveNeutrals

  math_Remove(repidx);
 }
}

mcExpSimRes mcElementArrayHelpers::math_SimplifySolveOp(long flags)
{
 mcMATHLOG(wxT("mcElementArrayHelpers::math_SimplifySolveOp [%s]"), mcTXTTHIS);
 bool stilltowork = FALSE; 

 // cannot store math_GetCount() because elements maybe removed in the loop
 for (int i=0; i < math_GetCount(); i++) {
  
  // get left operand
  mcElement &left = math_Get(i);
  
  for (int j=0; j < math_GetCount(); j++) {

   // get right one
   mcElement &right = math_Get(j);
   if (i == j) continue;
   
   // get the i-th operator of the array
   mcOperator p = math_GetOpPreceding(j);
   if (p == mcEmptyElement) continue;
   mcMATHLOG(wxT("mcElementArrayHelpers::math_SimplifySolveOp - I'm trying to apply ")
    wxT("the op [%s] between the [%s] and [%s] elements"), 
    mcTXT(p), mcTXT(left), mcTXT(right));
   
   // apply the op
   mcElement rep = mcEmptyElement;
   mcBasicOpRes res = p.math_Apply(left, right, &rep);
   if (res == mcBOR_INVALID)
    continue;
   
   // the operator could be applied...
   stilltowork = TRUE;
   mcMATHLOG(wxT("mcElementArrayHelpers::math_SimplifySolveOp - applied ")
    wxT("the op [%s] between the [%s] and [%s] elements"), 
    mcTXT(p), mcTXT(left), mcTXT(right));
   
   // handle res
   math_HandleBasicOpRes(res, rep, j);
  }
 }

 if (stilltowork)
  return mcESR_NOTFINISHED;
 return mcESR_DONE;
}

mcExpSimRes mcElementArrayHelpers::math_Simplify(long flags, mcElement *pnew)
{
 mcExpSimRes ret;

#define SIMCHECK_EXIT  if (ret != mcESR_DONE) { math_EndSimSteps(); return ret; }

 mcMATHLOG(wxT("mcElementArrayHelpers::math_Simplify [%s] start..."), mcTXTTHIS);

 // PREPARATION
 ret = math_BeginSimSteps();
 SIMCHECK_EXIT;

 // STEP #-1: remove neutral elements so that we have less elements to reorder
 ret = math_SimplifyRemoveNeutrals(flags);
 SIMCHECK_EXIT;

 // STEP #0: reorder the array
 ret = math_Reorder();
 SIMCHECK_EXIT;

 // STEP #1: propagate simplification calls to all the elements
 ret = math_SimplifyAll(flags, pnew);
 SIMCHECK_EXIT;

 // STEP #2: remove neutral elements again...
 ret = math_SimplifyRemoveNeutrals(flags);
 SIMCHECK_EXIT;
 
 // STEP #3: find the first operator which can be applied and apply it
 ret = math_SimplifySolveOp(flags);
 SIMCHECK_EXIT;

 // STEP #4: expand those elements non containing unknowns
 ret = math_SimplifyExp(flags, pnew);
 SIMCHECK_EXIT;

 // FINAL ADJUSTEMENT
 ret = math_FinalSimSteps();
 SIMCHECK_EXIT;
 
 // do some checks
 data_Check();
 data_Repair();

 // simplification finished
 mcMATHLOG(wxT("mcElementArrayHelpers::math_Simplify - ended..."));
 return mcESR_DONE;
}






// ----------------------------------------
// mcELEMENTARRAYMATH - expansion
// ----------------------------------------

mcIMPLEMENT_EXPSIM_FUNCTION(math_ExpandAll, math_Expand, 0)

mcExpSimRes mcElementArrayHelpers::math_Expand(long flags, mcElement *pnew)
{
 mcExpSimRes ret;
#define EXPCHECK_EXIT  if (ret != mcESR_DONE) { math_EndExpSteps(); return ret; }

 mcMATHLOG(wxT("mcElementArrayHelpers::math_Expand [%s] start..."), mcTXTTHIS);

 // PREPARATION 
 ret = math_ExpandAll(flags, pnew);
 EXPCHECK_EXIT
 
 // do some checks
 data_Check();

 // simplification finished
 return mcESR_DONE;
}






// ----------------------------------------
// mcELEMENTARRAYMATH - basic operations
// ----------------------------------------

bool mcElementArrayHelpers::math_CanBeAddedWith(const mcElement &p) const
{
 // just check the given element has the same type of this element:
 // mcElementArrays are general containers of elements, thus they
 // can be divided, added, multiplied without problems...
 if (p.data_GetType() == data_GetType())
  return TRUE;
 return FALSE;
}

bool mcElementArrayHelpers::math_CanBeDivBy(const mcElement &p) const
{ return math_CanBeAddedWith(p); }

bool mcElementArrayHelpers::math_CanBeMultWith(const mcElement &p) const
{ return math_CanBeAddedWith(p); }

mcElementArray mcElementArrayHelpers::math_CreateWrapperFor(const mcElement &toembed) const
{
 // be sure not to create nested arrays
 if (toembed.data_GetType() == data_GetType())
  return mcElementArray(toembed);  // toembed is already of the same type of *this

 // create a temporary container of this same type and then embed the
 // given element inside it
 mcElementArray tmp = mcElementHelpers::data_NewElem(data_GetType());
 tmp.data_AddElements(&toembed, 1);

 // caller must delete this
 return tmp;
}

void mcElementArrayHelpers::math_SimpleMultiplyBy(const mcElement &p)
{
 mcElementArray tmp = math_CreateWrapperFor(p);
 mcElementHelpers::math_SimpleMultiplyBy(tmp); 
}

void mcElementArrayHelpers::math_SimpleDivideBy(const mcElement &p)
{
 mcElementArray tmp = math_CreateWrapperFor(p);
 mcElementHelpers::math_SimpleDivideBy(tmp); 
}

void mcElementArrayHelpers::math_SimpleAdd(const mcElement &p, bool add)
{
 //mcASSERT(!p.IsKindOf(CLASSINFO(mcElementArray)), "Cannot nest arrays");
 mcElementArray tmp = math_CreateWrapperFor(p);
 mcElementHelpers::math_SimpleAdd(tmp, add);
}






// ------------------------------------------
// mcELEMENTARRAYMATH - remove/add elements
// ------------------------------------------

bool mcElementArrayHelpers::math_Remove(int idx, bool bAddZero)
{
 int n = math_MathToDataIdx(idx);
 mcASSERT(n != -1, wxT("Invalid index !"));

 // remove the n-th element and shift everything following left
 data_Delete(n);
 data_MoveElemLeft(n);

 // remove also the eventually present operator which PRECEDES
 // the just removed element (that is, its sign +/- or its
 // relation with the previous element */:)...
 if (n > 0 && data_isOp(n-1)) {

  data_Delete(n-1);
  data_MoveElemLeft(n-1);

 } else {

  // if there is no previous operator, then we must check if the
  // element we just removed was the first element of the array: 
  // if it was, then we must remove the operator which was (and still is)
  // FOLLOWING it...
  if (n == 0 && !data_isArrayEmpty() && data_isOp(n) && 
   data_Get(n).data_GetType() == math_GetNeutralOpType()) {

   // remove this op
   data_Delete(n);
   data_MoveElemLeft(n);
  }
  
  // if we left as first element a mcDivOp, then we must re-insert a
  // simple "1" before; if we remove it, then we would get a
  // mathematically incorrect result. Eg:
  //  
  // BEFORE:           x/b*c*d*e
  //                   ^---------- we call math_Remove(0)
  //
  // AFTER (wrong):    b*c*d*e
  // 
  // AFTER (right):    1/b*c*d*e

  if (n == 0 && !data_isArrayEmpty() && 
   data_Get(n).data_GetType() == mcET_DIVOP) {

   mcASSERT(data_GetType() == mcET_MONOMIAL, wxT("A mcDivOp inside a mcPolynomial ?"));
   data_MoveElemRight(0);
   data_Set(0, *mcNumberHelpers::smath_pOne);
  }
 }

 // if the array remains empty, don't let that CheckArray adds an empty box;
 // create a mcNumber initialized with zero
 if (data_isArrayEmpty()) {

  // cannot use math functions like math_Addmath_Simple() because
  // they would use this function... we must use Data() interface  
  if (bAddZero)
   math_WrapSimple(*mcNumberHelpers::smath_pZero);
  else
   math_WrapSimple(*mcNumberHelpers::smath_pOne);

  // we removed the n-th element and yes, we added a new mcNumber...
  return TRUE;
 }

 // we removed the n-th element but we didn't add anything
 return FALSE;
}

bool mcElementArrayHelpers::math_Delete(int n, const mcElement &elem, bool bmath_AddToZero)
{
 // find the index of the element to delete
 int idx = math_NonRecursiveFindInChildren(n, elem.hlp());
 if (idx == -1)
  return FALSE;  // couldn't find the n-th occurrence of such an element

 math_Remove(idx, bmath_AddToZero);
 return TRUE;
}

void mcElementArrayHelpers::math_ApplyOpSimple(mcElementType optype, mcElement res, 
           const mcElement &factor)
{
 mcOperator tmp = mcElementHelpers::data_NewElem(optype); 
 mcLOG(wxT("mcElementArrayHelpers::math_ApplyOpmath_Simple - applying the %s op"), mcTXT(tmp));
 
 tmp.math_ApplySimple(res, factor);
}

void mcElementArrayHelpers::math_ApplyOp(mcElementType optype, mcElement res, 
           const mcElement &factor, mcElement *rep)
{
 mcOperator tmp = mcElementHelpers::data_NewElem(optype); 
 mcLOG(wxT("mcElementArrayHelpers::math_ApplyOp - applying the %s op"), mcTXT(tmp));
 
   tmp.math_Apply(res, factor, rep);
}

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

 if (data_isArrayEmpty())
  return res;

 // scan the elements contained and then returns the 
 res = data_Get(0).math_GetMathType();
 for (int i=0, max=math_GetCount()-1; i < max; i++) {

  mcMathType next = data_Get(i+1).math_GetMathType();

  // a monomial must always consider only the pressing condition...  
  mcElementType op = math_GetOpTypeBetween(i, i+1);
  res.math_ApplyOp(op, next);
 }

 return res;
}

mcOperator &mcElementArrayHelpers::math_GetOpBetween(int n1, int n2) const
{
 mcElement *p = mcElementHelpers::data_GetInstanceOf(math_GetOpTypeBetween(n1, n2));
 mcASSERT(mcOperatorHelpers::data_isOp(p->data_GetType()), 
   wxT("math_GetOpTypeBetween() not returning an operator type ?"));
 return (mcOperator &)*p;
}

mcOperator &mcElementArrayHelpers::math_GetOpPreceding(int n) const
{
 mcElement *p = mcElementHelpers::data_GetInstanceOf(math_GetOpTypePreceding(n));
 mcASSERT(mcOperatorHelpers::data_isOp(p->data_GetType()), 
   wxT("math_GetOpPreceding() not returning an operator type ?"));
 return (mcOperator &)*p;
}

void mcElementArrayHelpers::math_PrepareForMathOperations(mcElementArray &) const
{
 // here should be placed the preparative for math operations...
}








// ----------------------------------------
// mcELEMENTARRAYMATH - comparison
// ----------------------------------------

void mcElementArrayHelpers::math_PrepareForComparison(mcElementArray &) const
{
 // the given pointer should point to a work copy !!!

 // first of all, simplify to the maximum level the array:
 // this will make all the following operations easier to perform
 // for the math engine...

 // FIXME: this doesn't work yet...
 //p.math_MaxSimplify();
}

bool mcElementArrayHelpers::math_Compare(const mcElement &m, long flags) const
{
 mcMATHLOG(wxT("mcElementArrayHelpers::math_Compare [%s] - comparing with [%s]"),
    mcTXTTHIS, mcTXT(m));
 int i;
 
 // must be of the same type of this element...
 if (m.data_GetType() != data_GetType())
  return FALSE;

 // create backup copies
 mcElementArray m1(this);
 mcElementArray m2(m);

 // prepare our work copies to the comparison only if the
 // comparison is "strict": in this case, different orders in *this and *m
 // force the two arrays to be considered different.
 if (flags & mcFIND_STRICT) {
  math_PrepareForComparison(m1);
  math_PrepareForComparison(m2);
 }

 // these will be used very often
 int m1count = m1.data_GetCount();
 int m2count = m2.data_GetCount();

 // m1 must be the largest array.!!!
 if (m1count < m2count) {

  // swap the two array pointers
  mcSWAP(mcElementArray, m1, m2);
  mcSWAP(int, m2count, m1count);
 }

 // this array of BOOLs will be used to keep memory of those
 // elements of m2 which have already been recognized to be
 // present & with the same contents in m1.
 // 
 // for example, if the initial conditions are:
 //
 // m1:       123*sqrt(2)*a*b       (i = 0)
 //            ^
 // m2:       a*sqrt(2)*123*b
 // b2:       0    0     0  0
 //
 // then, when "123" of m1 is recognized to be in m2,
 // 
 // m1:       123*sqrt(2)*a*b       (i = 1)
 //                  ^
 // m2:       a*sqrt(2)*123*b
 // b2:       0    0     1  0
 // 
 bool *b2 = new bool[m2count];
 for (i=0; i < m2count; i++)
  b2[i] = FALSE;

 // check if each element has an element with the same content
 // in the given array
 for (i=0; i < m1count; i++) {

  if (m1.data_isOp(i))
   continue;  // skip operators...

  mcElementType t = m1.data_Get(i).data_GetType();
  mcElementType opt = m1.data_GetOpTypePreceding(i);
  bool matched = FALSE;

  // search an element in the other array of the same type
  for (int c=0, max=m2.data_GetNumOfElemType(t); c < max; c++) {
  
   // get the index of the c-th element of the m2 array
   int j = m2.data_GetElemIndexOfType(c, t);

   // be sure we haven't set a corrispondence with this element yet
   if (b2[j] == TRUE)
    continue; // skip this element...

   // check also that the operator which precedes the j-th element in m2
   // is of the same type of the operator which precedes the i-th element in m1
   mcElementType opt2 = m2.data_GetOpTypePreceding(j);
   if (opt != opt2)
    continue; // skip this element...

   // now, check if it has the same content of the i-th element of m1
   bool same = FALSE;
   same = m1.data_Get(i).math_Compare(m2.data_Get(j), flags);

   if (same) {

    // yes, those two elements have the same content....
    matched = TRUE;
    b2[j] = TRUE;
    break;  // exit from the inner loop
   }
  }

  // check if we could find an element which has the same content
  // of data_Get(i)...
  if (!matched)
   break;  // if we couldn't, then stop: the two arrays are different
 }

 // clean up everything
 //delete m1;
 //delete m2;
 delete [] b2;

 // now, the two arrays contain globally the same elements only
 // if all the elements of the first array have been successfully
 // found to be present in the second array
 return (i == m1count);
}

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

 // now we are sure that p is a mcElementArray-derived class
 //return data_GetCount() == ((mcElementArray*)p).data_GetCount(); 
 return TRUE;
}
/*
mcElement mcElementArrayHelpers::math_GetLCM(const mcElement &p) const
{
 return math_Get(0).math_GetLCM(p);


 mcMonomial arr(p);
 mcMonomial res;

 res.math_ResetToOne();
 for (int i=0; i < math_GetCount(); i++) {
  for (int j=0; j < arr.math_GetCount(); j++) {
   
   // we need to get the lowest common multiple between all the
   // same element types stored in *this and in the given monomial...
   if (math_Get(i).math_CompareThisOnly(arr.math_Get(j), FALSE)) {

    res.math_SimpleMultiplyBy(math_Get(i).math_GetLCM(math_Get(j)));
   }
  }
 }

 return res;
}

mcElement mcElementArrayHelpers::math_GetGCD(const mcElement &p) const
{
 mcMonomial arr(p);
 mcMonomial res;

 res.math_ResetToOne();
 for (int i=0; i < math_GetCount(); i++) {
  for (int j=0; j < arr.math_GetCount(); j++) {
   
   // we need to get the lowest common multiple between all the
   // same element types stored in *this and in the given monomial...
   if (math_Get(i).math_CompareThisOnly(arr.math_Get(j), FALSE)) {

    res.math_SimpleMultiplyBy(math_Get(i).math_GetLCM(math_Get(j)));
   }
  }
 }

 return res;
}*/

mcMonomial mcElementArrayHelpers::math_GetFactors() const
{
 mcMonomial res;

 res.math_ResetToOne();
 for (int i=0,max=math_GetCount(); i<max; i++) {
  mcMonomial factor = math_Get(i).math_GetFactors();

  mcMATHLOG(wxT("mcElementArrayHelpers::math_FactoreOut - I've factored out [%s]"), mcTXT(factor));
  res.math_GetGCD(factor);
  mcMATHLOG(wxT("mcElementArrayHelpers::math_FactoreOut - result currently is [%s]"), mcTXT(res));
 }

 return res;
}

---

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

[ Top ]