Main page

---

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

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

#ifndef mcPRECOMP
 #include "mc/MathUtils.h"
 #include "mc/Monomial.h"
 #include "mc/Number.h"
 #include "mc/Fraction.h"
 #include "mc/Bracket.h"
 #include "mc/Text.h"
 #include "mc/Symbol.h"
 #include "mc/AddSubOp.h" 
 #include "mc/MultDivOp.h" 
 #include "mc/Function.h"
 #include "mc/Radical.h"
#endif


mcIMPLEMENT_MAIN_CLASS(mcMonomial, mcElementArray);



// setup customizable variables
int mcMonomialHelpers::sgui_nSpaceBetween = 1;

mcMonomial *mcMonomialHelpers::smath_pOne = NULL;
mcMonomial *mcMonomialHelpers::smath_pZero = NULL;

bool mcMonomialHelpers::sgui_bEmptyBoxReplacing = TRUE;
bool mcMonomialHelpers::sgui_bFunctionScanEnabled = TRUE;
bool mcMonomialHelpers::sgui_bTransformDivInFractions = TRUE;
bool mcMonomialHelpers::sio_bAutoConvertDivOpToFractions = TRUE;


// global objects
mcMonomial mcEmptyMonomial(NULL);




// ----------------------------------------
// mcMONOMIAL
// ----------------------------------------

bool isMonomialOkay(const mcElement &p)
{
 if (p.data_GetType() == mcET_POLYNOMIAL)
  return FALSE;
 return TRUE;
}

mcMonomial::mcMonomial(const mcFraction &towrap)
{ data_SetRefData(new mcMonomialHelpers); data_AddElements(&towrap, 1); }
mcMonomial::mcMonomial(const mcSymbol &towrap)
{ data_SetRefData(new mcMonomialHelpers); data_AddElements(&towrap, 1); }
mcMonomial::mcMonomial(const mcNumber &towrap)
{ data_SetRefData(new mcMonomialHelpers); data_AddElements(&towrap, 1); }
mcMonomial::mcMonomial(const mcBracket &towrap)
{ data_SetRefData(new mcMonomialHelpers); data_AddElements(&towrap, 1); }
mcMonomial::mcMonomial(const mcRadical &towrap)
{ data_SetRefData(new mcMonomialHelpers); data_AddElements(&towrap, 1); }




// ----------------------------------------
// mcMONOMIALDATA
// ----------------------------------------

#ifdef __MCDEBUG__

void mcMonomialHelpers::data_Check() const
{
 // this MUST be true... it's an important prerequisite of math functions
 mcASSERT(data_GetCount() == 0 || (!data_isOp(0) && !data_isOp(data_GetCount()-1)), 
  wxT("The expression must always start and end with a non-operator element"));

 // be also sure that this array doesn't contain mcPolynomials as subelements
 mcASSERT(data_ScanArray(isMonomialOkay, TRUE), 
  wxT("Found a mcPolynomial nested in a mcMonomial"));

 // do basic checks
 mcElementArrayHelpers::data_Check();
}

#endif  // __MCDEBUG__

void mcMonomialHelpers::data_Repair()
{
 if (data_isArrayEmpty())
  return;

 // data_Delete the operators placed immediately at the beginning...
 if (data_isOp(0)) {
  data_Delete(0);
  data_MoveElemLeft(0);
 }

 // ...or at the end
 if (data_isOp(data_GetCount()-1))
  data_DeleteLast(1);

 // add/remove mcMultOp when required
 for (int i=0; i < data_GetCount(); i++) {

  if (i < data_GetCount()-1 && 
   !data_Get(i).data_isAllowedBefore(data_Get(i+1).data_GetType())) {

   if (data_isOp(i)) {

    // two operators are adiacent:   432**43
    // data_Delete the first one
    data_Delete(i);
    data_MoveElemLeft(i);

    // and recheck this entry
    i--;
    
   } else {
    
    // two elements which cannot coexist in adiacent positions
    // must be divided:  123 456   must become 123*456
    // separate these two elements adding a mcMultOp
    data_MoveElemRight(i+1);
    data_AddNewOp(mcET_MULTOP, i+1);
   }
  }

  if (i > 0 &&
   !data_Get(i).data_isAllowedAfter(data_Get(i-1).data_GetType())) {

   // two elements which cannot be one after the other:
   // (...)123 should become (...)*123
   // this kind of reparation is usually unnecessary
   // if Reorder() is executed before.
   data_MoveElemRight(i);
   data_AddNewOp(mcET_MULTOP, i);
  }
 }

 // now, check if we made a good work...
 data_Check();
}

void mcMonomialHelpers::data_TransformDivOp()
{
 mcLOG(wxT("mcMonomialHelpers::data_TransformDivOp [%s]"), mcTXTTHIS);

 // begin the array scan
 int begin = -1;
 for (int i=0; i < data_GetCount(); i++) {

  if (!data_isOp(i) && begin == -1)
   begin = i;
  if (data_Get(i).data_GetType() != mcET_DIVOP)
   continue;

  // we've found a mcDivOp
  mcFraction f;
  mcPolynomial &num = f.data_GetNum();
  mcPolynomial &den = f.data_GetDen();

  // all the elements preceding it have been placed in "num"
  num.data_AddNewMonomialContaining(data_GetArray(begin), i-begin, -1, TRUE);

  // if we have a sequence like:
  //                                              abc
  //     abc/d/e/f/g/h     it should become:    -------
  //                                             defgh
  // 
  // so, just count how many mcDivOp are immediately 
  // following the i-th one
  int end = i+1;
  int j = i+1;
  while (j < data_GetCount()) {

   if (data_Get(j).data_GetType() == mcET_MULTOP) {

    // we have reached a point like
    //       i    j
    //   abcd/d/e*f
    //           ^---------- this
    end = j-1;
    break;

   } else if (data_Get(j).data_GetType() != mcET_DIVOP) {

    if (!data_isOp(j-1)) {
     end = j-1;
     break;
    }   
   }

   // go on scanning
   j++;
  }

  // create tmp objects
  mcMonomial tmp; 

  // ok, now create the "den" polynomial
  for (j=i+1; j <= end; j++) {

   // in the monomial which will be used as denominator,
   // don't copy the mcDivOps !!!
   if (!data_isOp(j)) 
    tmp.data_AddElements(data_GetArray(j), 1);
  }

  den.data_AddNewMonomial(tmp, -1, TRUE);

  // finally, we can complete our process replacing all the
  // elements embedded in wxT("f") with "f" itself
  for (j=begin; j < end; j++) {
   data_Delete(begin);
   data_MoveElemLeft(begin);
  }
  
  data_AddElements((mcElement *)(&f), 1, begin, TRUE);

  // prepare everything for a new cycle
  i = begin++;
  begin = -1;
  tmp.data_DeleteAll();

  mcLOG(wxT("mcMonomialHelpers::data_TransformDivOp [%s]"), mcTXTTHIS);
 }
}




// ----------------------------------------
// mcMONOMIALGUI
// ----------------------------------------

int mcMonomialHelpers::gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl) const
{
 mcGUILOG(wxT("mcMonomialHelpers::gui_Draw"));

 // if a selection is present in the monomial....
 if (this->gui_isSelected()) {

  // ... and the selection is limited to this
  // monomial (that is, it's not extended to other monomials, it's just
  // inside this one and thus our parent gave us the mcDRW_ALLOW_TOTAL_SELECTION)
  // flag), then draw everything + selection rectangle
  int w, n;
  if (flags & mcDRW_ALLOW_TOTAL_SELECTION) {

   // draw everything except selected elements
   n = mcElementArrayHelpers::gui_ExDraw(dc, x, y, flags, pt, cl);

   // the parent is a mcPolynomial and this is the only selected monomial
   // contained inside it... we can draw selection ourself
   if ((w=gui_DrawSelection(dc, x, y, flags, pt, cl)) != mcDRW_NOACTIVEELEM)
    n = w;

   return n;
  }
 } 

 // ... maybe that:
 // 1) selection is not present and thus everything must be drawn
 // 2) an "extended" selection (a selection among two or more monomials) is
 //    present and, anyway, everything must be drawn (also selected elements):
 //    parent will care about selection rectangle...
 return mcElementArrayHelpers::gui_ExDraw(dc, x, y, flags, pt, cl, 0, -1, TRUE);
}

void mcMonomialHelpers::gui_CheckCursorPos() const
{
 if (data_GetCount() > 0) {

  // if the array exists, the cursor cannot be placed over an operator
  mcASSERT(!data_isOp(mgui_nCursorPos), wxT("Cursor cannot be placed on an operator"));
 }
}

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

 // add the requested element
 int idx = mcElementArrayHelpers::gui_AddNewElement(type, key, pos);

 // check if we must also add a new empty box
 if (mcOperatorHelpers::data_isOp(type)) {
  if (pos == data_GetCount()-1 || data_isOp(pos+1)) {

   // ok, we are at the end of the array and an operator was
   // added (or an operator was added immediately before another 
   // operator): we must add an empty box
   data_MoveElemRight(pos+1);
   mcElementArrayHelpers::gui_AddNewEmptyBox(pos+1);

  } else if (pos > 0 && data_isOp(pos-1)) {

   // an operator was added immediately after another operator:
   // insert an empty box between them
   data_MoveElemRight(pos);
   mcElementArrayHelpers::gui_AddNewEmptyBox(pos);
  }
  pos++;
 }

 // now that the array is okay, do a special check for mcDivOps...
 if (sgui_bTransformDivInFractions && type == mcET_DIVOP) {

  // we must create a mcFraction containing
  // the factors placed on the left of this op as numerator,
  // the factors on the right as denominator...
  mcFraction p;

  // this is the index of this operator inside the monomial 
  // which owns this element...
  //int idx = pos;//data_GetIndex(hlp()->data_GetID());

  // copy in the numerator elements from zero to this op...
  mcMonomial num(this);
  num.data_DeleteLast(num.data_GetCount()-idx);
  p.data_AddElements(TRUE, &num, 1, -1, TRUE);
  p.data_GetNum().data_Check();

  // copy in the denominator elements from this op to the end...  
  mcMonomial den(this);
  den.data_DeleteFirst(idx+1);
  p.data_AddElements(FALSE, &den, 1, -1, TRUE);
  p.gui_SetCursorOnDen();
  p.data_GetDen().data_Check();

  // now, remove everything from this array and replace all with this fraction...
  data_DeleteAll();
  data_AddElements(&p, 1, -1, TRUE);
  data_Check();

  pos = 0;
 }

 // size should have changed !!!
 gui_RecalcSize();
 return pos;
}

mcInputRes mcMonomialHelpers::gui_BackInput(const mcKey &key, mcElement *pnewelem, int n)
{
 int rightidx;
 bool b1, b2;

 // the focused element asked us to data_Delete itself
 switch (n) {
 case mcIR_OKAY:
  break;

 case mcIR_DIRECT_DELETE:

  // an empty box asked us to data_Delete it... is it the only element
  // in the array ???
  if (data_GetCount() == 1) {

   // we don't need to check the bEmptyBoxReplacing value
   // (see the mcIR_DELETE_THIS handler): we must data_Delete
   // this array in any case.
   return mcIR_DELETE_THIS;
  }

  // the empty box is not the last element of the array: proceed
  // as it is a normal element: DON'T BREAK HERE

 case mcIR_DELETE_THIS:
  
  // data_Delete the focused element
  data_Delete(mgui_nCursorPos);
  
  // if the array is now empty, the mdata_nElements variable is set
  // to one: we have data_Deleted the focused element but we don't
  // have shifted left the array yet !!!
  // And it MUST be so, because the following piece of code
  // needs the array not shifted yet.
  if (data_GetCount() == 1) {

   if (sgui_bEmptyBoxReplacing) {

    // the element that we data_Deleted surely was not a mcEmptyBox
    // (they return mcIR_DIRECT_DELETE as data_Delete flag): it must
    // be another element type; if the EMPTY BOX REPLACING
    // feature is active, we must replace it with an empty box.
    data_AddNewEmptyBox(0);
    return mcIR_OKAY;

   } else {

    // the element that we data_Deleted was not an mcEmptyBox, but
    // we must ask to data_Delete us in any case....
    return mcIR_DELETE_THIS;
   }
  }

  // if bEmptyBoxReplacing is set, then try to replace 
  // the old element with an empty box
  if (sgui_bEmptyBoxReplacing && n != mcIR_DIRECT_DELETE) {
   
   // if the element is following/preceding an operator...
   b1 = (mgui_nCursorPos > 0 && data_isOp(mgui_nCursorPos-1));
   b2 = (mgui_nCursorPos < data_GetCount()-1 && 
    data_isOp(mgui_nCursorPos+1));
   
   // ... or it is at the end/begin of the array...
   b1 |= (mgui_nCursorPos == 0);
   b2 |= (mgui_nCursorPos == data_GetCount()-1);
   
   if (b1 && b2) {

    // ...then, create a replacement empty box
    data_AddNewEmptyBox(mgui_nCursorPos);
    return mcIR_OKAY;
   }
  }

  // to avoid to leave operators scattered, we must perform different
  // checks for different keypresses:
  if (mcMathCore::Get()->m_pCancelKey->MatchKey(key)) {
   
   // handle the following case:
   //       |a*bc                  user presses CANCEL
   //
   // in this case we need to data_Delete also 
   // the FOLLOWING operator (if present) !!!
   gui_DeleteNextOp();
   
   // handle the following case:
   //       ab*|c                  user presses CANCEL
   //
   // in this case we need to data_Delete also 
   // the PREVIOUS operator (if present) !!!
   gui_DeletePreviousOp();

  } else if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key)) {
   
   // handle the following case:
   //       a|*b                  user presses BACKSPACE
   //
   // in this case we need to data_Delete also 
   // the FOLLOWING operator (if present) !!!
   gui_DeleteNextOp();

   // handle the following case:      
   //       a*b|c                 user presses BACKSPACE
   //
   // in this case we need to data_Delete also 
   // the PREVIOUS operator (if present) !!!
   gui_DeletePreviousOp();
  }

  // this shift must be done AFTER the previous operations
  // (which addresses the array)...
  data_MoveElemLeft(mgui_nCursorPos);

  // there must be still some element present in the monomial (we checked
  // for empty array before) and, in this case, we must be aware that
  // when the cursor is placed on the first element, it must remain
  // placed on it.
  if (mgui_nCursorPos > 0) {

   mgui_nCursorPos--;
   if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
    data_Get(mgui_nCursorPos).gui_SetCursorPos(mcCP_BEGIN);
   else if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
    data_Get(mgui_nCursorPos).gui_SetCursorPos(mcCP_END);

  } else {

   // this is required if the user, for example, types:
   //     [A][B][C][D]   -.   abcd|
   //     [HOME]         -.   |abcd
   //     [CANC]         -.   |bcd
   // if this is not done, then last line becomes: 
   //     [CANC]         -.   b|cd
   gui_SetCursorPos(mcCP_BEGIN);
  }

  // maybe we need to merge the two elements that are now adiacent ?
  rightidx = mgui_nCursorPos+1;  // both for BACKSPACE & CANCEL

  // a typical example of this case is:
  //
  //           123a|456      user presses the BACKSPACE
  // or
  //           123|a456      user presses the CANCEL
  //
  if (rightidx > 0 && rightidx < data_GetCount()) {

   // the left element's index is assumed to be rightidx-1
   bool b = FALSE;
   if (!data_Get(rightidx-1).data_isAllowedBefore(
    data_Get(rightidx).data_GetType())) {

    // the two elements cannot be adiacent: merge them !!!!
    b = data_Get(rightidx-1).gui_MergeWith(data_Get(rightidx));
    if (b) {

     // the two elements was merged successfully: data_Delete
     // the second half....
     data_MoveElemLeft(rightidx);

     // cursor position should be already in the right position...
    }
   }

   // if the two elements cannot be merged, add a mcMultOp
   // between them....
   if (!b) {

    data_Repair(); // hope this will solve everything
   }
  }

  // we have finished (finally)...
  break;
  

 case mcIR_DELETE_PREVIOUS:
  
  // the focused element asked us to data_Delete the previous one
  if (mgui_nCursorPos == 0) {
   
   // user is trying to data_Delete the previous operator of this monomial...
   // we must merge this monomial with the previous one.
   mcASSERT(data_GetCount() > 0, wxT("If we received an mcIR_data_Delete_PREVIOUS code, ")
    wxT("there must still be some element which sent it !!!"));
   
   // the parent element (normally a mcPolynomial) will care about
   // the fusion of the two monomials
   return mcIR_DELETE_PREVIOUS;
   
  } else {
   
   if (!data_isOp(mgui_nCursorPos-1)) {
    
    // this trick should work
    gui_MoveCursorLeft();
    mcKey tmp = mcMathCore::Get()->m_pDeleteKey->GetEvent();
    gui_Input(tmp, NULL);
    
   } else {

    if (mgui_nCursorPos > 1 && 
     !data_Get(mgui_nCursorPos-2).data_isAllowedBefore(
       data_Get(mgui_nCursorPos).data_GetType())) {

     // oooooooooops
     mcMathCore::Get()->SyntaxError(wxT("Cannot data_Delete this operator..."));
     break;
    }
    
    // the previous element is a mcMultOp or a mcDivOp... data_Delete it
    data_Delete(mgui_nCursorPos-1);
    data_MoveElemLeft(mgui_nCursorPos-1);
    
    // try to move the cursor 
    if (mgui_nCursorPos > 1)
     mgui_nCursorPos -= 2;
    else
     mgui_nCursorPos--;

    // this will add mcMultOp that we could accidentally have data_Deleted
    data_Repair();
   }
  }
  break;


 case mcIR_DELETE_NEXT:

  // the focused element asked us to data_Delete the next one
  if (mgui_nCursorPos == data_GetCount()-1) {
   
   // user is trying to data_Delete the previous operator of this monomial...
   // we must merge this monomial with the previous one.
   mcASSERT(data_GetCount() > 0, wxT("If we received an mcIR_data_Delete_NEXT code, ")
    wxT("there must still be some element which sent it !!!"));
   
   // the parent element (normally a mcPolynomial) will care about
   // the fusion of the two monomials
   return mcIR_DELETE_NEXT;
   
  } else {
   
   if (!data_isOp(mgui_nCursorPos+1)) {
    
    gui_MoveCursorRight();
    mcKey tmp = mcMathCore::Get()->m_pCancelKey->GetEvent();
    gui_Input(tmp, NULL);

    // we don't want to move cursor
    gui_MoveCursorLeft();
    
   } else {

    if (mgui_nCursorPos < data_GetCount()-2 && 
     !data_Get(mgui_nCursorPos).data_isAllowedBefore(
      data_Get(mgui_nCursorPos+2).data_GetType())) {

     // oooooooooops
     mcMathCore::Get()->SyntaxError(wxT("Cannot data_Delete this operator..."));
     break;
    }

    // the next element is a mcMultOp or a mcDivOp... data_Delete it
    data_Delete(mgui_nCursorPos+1);
    data_MoveElemLeft(mgui_nCursorPos+1);

    // this will add mcMultOp that we could accidentally have data_Deleted
    data_Repair();
    
    // we don't need to move cursor
   }
  }
  break;
  
  
 case mcIR_REPLACE_THIS:
  gui_Replace(pnewelem);
  break;

 case mcIR_DISTRIBUTE:

  // we cannot handle this flag but mcPolynomial can...
  return mcIR_DISTRIBUTE;  
  
 default:
  mcASSERT(0, wxT("Unhandled return flag"));
 }
 
 // just hope that everything has gone well...
 return mcIR_OKAY;
}

void mcMonomialHelpers::gui_DoSplit(mcElementType type, const mcKey &key)
{
 mcElement ptmp = mcEmptyElement;
 mcKey splitkey(key);

 // split the element in two parts; by now, this function
 // can be used only by mcNumbers & mcMonomials...
 // thus, this function has been tested only with mcNumber;
 // that is, in such situations:
 //
 //    aaaaaaaaa   |   543|210    |    bbbbbbbbb      user creates an operator 
 // mgui_nCursorPos-1 | mgui_nCursorPos | mgui_nCursorPos+1    or something else...
 // 
 // which is transformed in:
 //
 //    aaaaaaaaa   |      543     |   new element  |       210      |   bbbbbbbbb    
 // mgui_nCursorPos-1 | mgui_nCursorPos | mgui_nCursorPos+1 | mgui_nCursorPos+2 | mgui_nCursorPos+3
 // 
 mcASSERT(!data_Get(mgui_nCursorPos).gui_Split(&ptmp), 
  wxT("Such case (the first half asked to data_Delete itself) is not handled yet"));
 
 // go on only if the element to split support that function
 mcASSERT(ptmp != mcEmptyElement, wxT("Tried to split an element which does not support splitting"));
 
 // create an hole in the array
 data_MoveElemRight(mgui_nCursorPos+1);
 data_Set(mgui_nCursorPos+1, ptmp);
 
 // create another hole
 data_MoveElemRight(mgui_nCursorPos+1);
 
 // and fill it with the splitting element: the element wich has been
 // created inside the element which is now split...
 mgui_nCursorPos = gui_AddNewElement(type, key, mgui_nCursorPos+1);
}

bool mcMonomialHelpers::gui_Split(mcElement *p)
{
 // the user pressed an end char while the cursor is still inside
 // the digits... this element must be split in two parts divided
 // by the operator or the element typed in. The first one will be
 // stored here, in this number, the second half, instead, must be
 // returned as a pointer to a new element
 mcMonomial pnew;

 // try to split the focused element
 mcElement ptmp;
 bool b = data_Get(mgui_nCursorPos).gui_Split(&ptmp);

 // if the element request us to data_Delete it, do it...
 if (b) {
  data_Delete(mgui_nCursorPos);
  data_MoveElemLeft(mgui_nCursorPos);
 }
 
 // copy the elements placed after the cursor in the new monomial
 if (ptmp != mcEmptyElement) 
  pnew.data_AddElements(&ptmp, 1);

 if (mgui_nCursorPos < data_GetCount()-1) {

  // insert them in the new monomial
  pnew.data_AddElements(data_GetArray(mgui_nCursorPos+1),
        data_GetCount()-mgui_nCursorPos-1);  

  // detach them from this one
  data_DetachLastElem(data_GetCount()-mgui_nCursorPos-1);
 }

 // add & remove eventually required/not needed operators
 data_Repair();
 pnew.data_Repair();

 // adjust cursor position
 this->mgui_nCursorPos = data_GetCount()-1;
 data_Get(mgui_nCursorPos).gui_SetCursorPos(mcCP_END);

 pnew.hlp()->mgui_nCursorPos = 0;
 pnew.data_Get(pnew.hlp()->mgui_nCursorPos).gui_SetCursorPos(mcCP_BEGIN);

 // size should have changed
 gui_RecalcSize();
 *p = pnew;

 return TRUE;
}

bool mcMonomialHelpers::gui_MergeWith(const mcElement &p)
{
 if (p.data_GetType() != mcET_MONOMIAL)
  return FALSE;

 mcMonomial m(p);

 // check if the end & begin elements support splitting/merging
 if (data_GetLast().gui_isSplittable() &&
  m.data_Get(0).gui_isSplittable() &&
  data_GetLast().data_isAllowedBefore(
  m.data_GetLast().data_GetType())) {

  // then, we must merge the two elements
  bool okay = data_GetLast().gui_MergeWith(m.data_Get(0));

  if (okay) {

   // and data_Delete the second half from the given element
   m.data_Delete(0);
   m.data_MoveElemLeft(0);
   if (!m.data_isArrayEmpty() && m.data_isOp(0)) {
    m.data_Delete(0);
    m.data_MoveElemLeft(0);
   }
  }
 }

 // now, merge with the given element & check if all the operators
 // required for array consistency are present
 data_Merge(m);
 data_Repair();

 // size should have changed
 gui_RecalcSize();

 // merge was okay...
 return TRUE;
}

mcInputRes mcMonomialHelpers::gui_Input(const mcKey &ev, mcElement *newelem)
{
 mcInputRes n = mcElementArrayHelpers::gui_Input(ev, newelem);

 // if the 'function scan' feature is active, try to recognize
 // registered functions inside the current mcSymbol sequences...
 if (sgui_bFunctionScanEnabled)
  gui_ScanArrayForFunctions();

 return n;
}

void mcMonomialHelpers::gui_ScanArrayForFunctions()
{
 // SPECIAL CODE FOR CFUNCTION
 // check if in the array is present a sequence of mcSymbols which hides a function...
 int f, i;
 for (int n=0; n < data_GetCount(); n++) {
  if (data_Get(n).data_GetType() == mcET_SYMBOL) {
   
   // check how long is the sequence of mcSymbols...
   for (i=n; i < data_GetCount(); i++)
    if (data_Get(i).data_GetType() != mcET_SYMBOL)
     break;
    
   // if the aray of mcSymbols compose the name of a registered
   // function, then replace those mcSymbols with a mcFunction...
   f=mcFunction::data_GetFunctionType(data_GetArray(n), i-n);
   if (f != mcFUNCTION_TYPE_NOTFOUND)
    gui_ReplaceSymbolsWithFunction(n, f);
  }
 }
}

void mcMonomialHelpers::gui_ReplaceSymbolsWithFunction(int idx, int fnc)
{
 // found a function inside this list of mcSymbols; 
 // replace the symbols with the function...
 mcFunction pnew;
 data_AddElements((mcElement *)(&pnew), 1, idx, TRUE);
 
 // special initialization is required...
 pnew.gui_Setup(fnc);
 mgui_nCursorPos = idx++;
    
 // delete the other mcSymbols
 int max = (int)(pnew.data_GetName().Len()-1);
 for (int i=0; i < max; i++) {
  data_Delete(idx);
  data_MoveElemLeft(idx);
 }
 
 gui_RecalcSize();
}

void mcMonomialHelpers::gui_Replace(mcElement *pnewelem)
{ 
 // the focused element asked us to replace itself with 'pnewelem'
 // a quick check
 mcASSERT(pnewelem != NULL && data_isValidElem(*pnewelem), 
  wxT("Cannot replace the focused element with an invalid pointer"));
 
 // check filter permissions
 if (!data_isElementAllowed((*pnewelem).data_GetType())) {
  
  // sorry...
  mcMathCore::Get()->SyntaxError(wxT("Cannot create such an element !!!"));
  //break;
 }
 
 // these cannot be created even if the filter allow us !!!
 if ((*pnewelem).data_GetType() == mcET_ADDOP || 
  (*pnewelem).data_GetType() == mcET_SUBOP) {
  
  mcASSERT(0, wxT("A monomial cannot contain a mcAddOp or a mcSubOp"));
 }
 
 // for operators, we need special checks !!!
 if ((*pnewelem).data_GetType() == mcET_MULTOP || 
  (*pnewelem).data_GetType() == mcET_DIVOP) {
  
  // tested only if the element wh
  data_AddNewEmptyBox(mgui_nCursorPos);  
  data_AddElements(pnewelem, 1, mgui_nCursorPos+1, TRUE);
  data_AddNewEmptyBox(mgui_nCursorPos+2);
  mgui_nCursorPos += 2;
  
 } else {
  
  // insert the given element, without copying it, overwriting the previous one
  data_AddElements(pnewelem, 1, mgui_nCursorPos, TRUE);
  (*pnewelem) = NULL;
 }
}

mcInsertRes mcMonomialHelpers::gui_Insert(const mcElement &toinsert, mcElement *)
{
 mcCursorPos cp(data_Get(mgui_nCursorPos).gui_GetCursorPos());
 mcElement replacement;

// if (cp.isInside()) {
  
  mcInsertRes r = data_Get(mgui_nCursorPos).gui_Insert(toinsert, &replacement);

  switch (r) {
  case mcINSR_OKAY:
   return mcINSR_OKAY;

  case mcINSR_REPLACE_THIS:
   gui_Replace(&replacement);
   break;
  }
// }

 return mcINSR_OKAY;
/* switch (toinsert.data_GetType()) {
 case mcET_POLYNOMIAL:
 case mcET_MATHMNG:
 case mcET_MATHANDSYSTEM:
 case mcET_MATHORSYSTEM:
  return FALSE;

 case mcET_MONOMIAL:
  return gui_Insert((const mcMonomial &)toinsert);

 default:
  {
   mcMonomial mon;
   mon.data_AddElements(&toinsert, 1);
   return gui_Insert((const mcMonomial &)mon);
  }
 }*/
}

mcInsertRes mcMonomialHelpers::gui_Insert(const mcElement *arr, int n)
{
/* mcCursorPos cp(data_Get(mgui_nCursorPos).gui_GetCursorPos());

 if (cp.isBegin() || cp.isEnd()) {

  data_AddElements(toinsert.data_GetArray(), 
      toinsert.data_GetCount(), 
      mgui_nCursorPos, FALSE);
  data_Repair();

  return TRUE;
 }

 if (cp.isInside()) {

  return data_Get(mgui_nCursorPos).gui_Insert(toinsert);
 }
*/
 return mcINSR_OKAY;
}






// ----------------------------------------
// mcMONOMIALIO
// ----------------------------------------

wxXml2Node mcMonomialHelpers::io_GetMathML(bool bGetPresentation) const
{
 if (data_GetCount() == 1) {// && data_Get(0)->data_hasProperty(mcEP_HIDDEN)) {
  // just return the presentation MathML associated with the first children
  return data_Get(0).io_GetMathML(bGetPresentation);
 }

 // begin another mrow section
 wxXml2Node maintag(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("mrow")); 

 // skip first op: it should have been exported by the mcPolynomial
 for (int i=0, max=data_GetCount(); i < max; i++) {

  // adds the i-th element's MathML to the main container
  wxXml2Node tmp(data_Get(i).io_GetMathML(bGetPresentation));
  maintag.AddChild(tmp);
  
  // if there is no operator following this element, then we must
  // add a mcMultOp (which is the operator used by default in a monomial)
  if (i < max-1 && !data_isOp(i) && !data_isOp(i+1)) {

   wxXml2Node mult(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mo"), wxT("&InvisibleTimes;"));
   maintag.AddChild(mult);
  }
 }

 return maintag;
}

bool mcMonomialHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &err)
{
 mcASSERT(tag.GetName() == wxT("mrow") ||
   tag.GetName() == wxT("mo"), wxT("Error in mcMonomialHelpers::io_isBeginTag"));
 
 wxXml2Node p = tag.GetChildren();
 mcElementType n;

 // BE SURE TO data_Delete EVERYTHING BEFORE IMPORTING !!!!
 data_DeleteAll();

 // check if the given node is an MROW containing as first child an MO
 // (which must be a + or -) or if this is directly an MO (a + or -) sent
 // to this monomial as "initialization" node by a mcPolynomial.
 if (tag.GetName() == wxT("mo") || (tag.GetName() == wxT("mrow") && p.GetName() == wxT("mo"))) {

  // check data
  wxXml2Node mo = (tag.GetName() == wxT("mo")) ? tag : p;
  n = mcElementHelpers::io_isTagBeginTag(mo);
  mcASSERT(n == mcET_ADDOP || n == mcET_SUBOP,
   wxT("The given node should be, or contain (as first child), a + or -"));

  // init this monomial with this operator
  data_DeleteAll();
  mcElement pnew = mcElementHelpers::data_NewElem(n);
  if (!pnew.io_ImportPresentationMathML(mo, err))
   return FALSE;
  data_AddElements(&pnew, 1);

  // skip this operator if it is the first of the given MROW;
  // if tag is just an MO, then tag will be NULL & the function will return
  // waiting for the next real node to parse.
  p = p.GetNext();
 }

 if (tag.GetName() == wxT("mrow")) {

  // by now, p couldn't be the first child of pTag; maybe p is pointing to
  // the sencond; we must always use p
  /*wxXml2Node optag;
  mcAddSubOp addop(hlp(), mcOperator::io_);
  mcSubOp subop(this);
  
  // check that the operators contained in the given node are okay
  optag = addop.io_GetMathML(TRUE);
  mcASSERT(!tag->math_Contains(optag), wxT("A monomial cannot contain + or - !!!"));
  optag = subop.io_GetMathML(TRUE);
  mcASSERT(!tag->math_Contains(optag), wxT("A monomial cannot contain + or - !!!"));
*/
  // check if this monomial already has a first operator
  if (data_GetCount() != 1 ||
   (data_Get(0).data_GetType() != mcET_ADDOP && 
   data_Get(0).data_GetType() != mcET_SUBOP)) {

   data_DeleteAll();  // clean this object

   // do not use math_AddNewOp() because it would also add an empty box
   mcEmptyBox first;
   data_AddElements(&first, 1);
  }

  // now, import data
  while (p != wxXml2EmptyNode) {

   // is k the begin char of a mcElement derived class ?
   n = mcElementHelpers::io_isTagBeginTag(p);
   if (n != FALSE) {

    mcElement pnew = mcElementHelpers::data_NewElem(n);
    if (!pnew.io_ImportPresentationMathML(p, err))
     return FALSE;
    data_AddElements(&pnew, 1);
   }

   p = p.GetNext();
  }
 }

 // extra-work required ?
 io_PostProcessChildren();

 return TRUE;
}

bool mcMonomialHelpers::io_ImportInlinedExpr(const wxString &todecode, int *c, wxString &pErr)
{
 wxString token(todecode);
 mcElementType n;
 int count;

 // BE SURE TO data_Delete EVERYTHING BEFORE IMPORTING !!!!
 data_DeleteAll();

 while (!token.IsEmpty()) {
  
  // as in mcMonomialHelpers::gui_Input(), we have to do a special check
  // here for mcFunction recognition...
  n = mcFunctionHelpers::io_isFunctionBeginChar(token) ? mcET_FUNCTION : mcET_INVALID;
  
  // ... also mcRadical have a mcFunction-like inlined expression...
  if (n == mcET_INVALID)
   n = mcRadicalHelpers::io_isRadicalBeginChar(token) ? mcET_RADICAL : mcET_INVALID;

  // is the token's first letter a begin char of some element ?
  if (n == mcET_INVALID)
   n = mcElementHelpers::io_isCharBeginChar(token.GetChar(0));
  
  // does this monomial end here ?
  if (n == mcET_ADDOP || n == mcET_SUBOP)
   break;  // yes

  if (n != mcET_INVALID) {
   
   mcElement pnew = mcElementHelpers::data_NewElem(n);   
   //mcElement pnew = *mcElement::data_GetInstanceOf(n);
   
   // import this element
   if (!pnew.io_ImportInlinedExpr(token, &count, pErr))
    return FALSE;
   
   // add it to this monomial  
   data_AddElements(&pnew, 1);
   //delete pnew;

   // update the token string
   token = token.Right(token.Len()-count);
   
  } else {
   
   pErr = wxT("Could not recognize the first element ")
    wxT("encoded in this token: ") + token;
   return FALSE;
  }
 }
 
 // we should have imported the entire token... except when we find
 // a mcAddOp or mcSubOp...
 if (c) *c = todecode.Len()-token.Len();

 // be sure to add operators between those elements that
 // require them to be present (e.g. two mcNumbers adiacents...)
 data_Repair();

 // extra-work required ?
 io_PostProcessChildren();

 mcIOLOG(wxT("mcMonomialHelpers::io_ImportInlinedExpr - we've imported [%s]"), mcTXTTHIS);

 return TRUE;
}

void mcMonomialHelpers::io_PostProcess()
{
 // this cannot be done in mcMonomialHelpers::io_ImportInlinedExpr and
 // mcMonomialHelpers::io_ImportPresentationMathML since mcPolynomial
 // must remove all mcParenthesis, first... consider:
 // 
 //                    2ax(E/2)
 // if we convert divop to fractions before the conversion,
 // performed by mcPolynomial::io_ImportInlinedExpr, of mcParenthesis
 // to mcBrackets, we would get a mcFraction with
 //
 //  the numerator set to wxT("2ax(E") and the denominator set to "2)"
 //
 if (mcMonomialHelpers::sio_bAutoConvertDivOpToFractions)
  data_TransformDivOp();
}
/*
wxString mcMonomialHelpers::io_GetContentMathML(int indent)
{
 wxString dest;
 
 
 // if this monomial is composed of only one element, we don't need
 // to create a nested APPLY section; just remember that element 0
 // is the add (or sub) op.
 if (data_GetCount() == 2)
  return data_Get(1).GetContentMathML(indent);
 
 // begin APPLY section and the TIMES chain
 dest += wxString(wxT(' '), indent) + wxT("<apply>\n") + wxString(wxT(' '), indent+mcMathCore::Get()->m_nIndentationStep) + wxT("<times/>\n");
 
 // insert the content mathML for each factor
 for (int i=1; i < data_GetCount(); i+=2) {
  dest += data_Get(i).GetContentMathML(indent+mcMathCore::Get()->m_nIndentationStep);
 }
 
 // close APPLY section
 dest += wxString(wxT(' '), indent) + wxT("</apply>\n");
 
 // return our work
 return dest;
}*/










// ----------------------------------------
// mcMONOMIALMATH
// ----------------------------------------

int mcMonomialHelpers::math_MathToDataIdx(int mathindex) const
{ 
 if (mathindex < 0 || mathindex >= math_GetCount()) {

  mcMATHLOG(wxT("mcMonomialHelpers::math_MathToDataIdx [%s] - ")
   wxT("invalid conversion required"), mcTXTTHIS);
  return -1;  // no conversion is possible
 }
 
 return data_GetNonOpElemIndex(mathindex); 
}
 
int mcMonomialHelpers::math_DataToMathIdx(int dataindex) const
{
 data_CheckIndex(dataindex);

 int elements=0;
 for (int n=0; n < dataindex; n++)
  if (!data_isOp(n))
   elements++;

 return elements;
}

mcBasicOpRes mcMonomialHelpers::math_RaiseTo(const mcPolynomial &p)
{
 mcMATHLOG(wxT("mcMonomialHelpers::math_RaiseTo [%s] - raising %d elements to [%s]"),
        mcTXTTHIS, math_GetCount(), mcTXT(p));

 // math_Get() returns a mcExpElement and thus makes easier our task
 for (int i=0,max=math_GetCount(); i < max; i++) {

  mcBasicOpRes r = math_Get(i).math_RaiseTo(p);

  switch (r) {
  case mcBOR_REMOVE_OPERAND:
   continue;

  case mcBOR_INVALID:
  default:
   mcASSERT(0, wxT("invalid raise !"));
  }
 }

 return mcBOR_REMOVE_OPERAND;
}

mcExpSimRes mcMonomialHelpers::math_HandleExpSimFlag(mcExpSimRes r, mcElement *newelem, int i)
{
 // we must check for a special case that mcElementArrayMath
 // cannot handle itself: when the just simplified element
 // returns mcESR_REPLACE_THIS with a "newelem" of type
 // mcET_POLYNOMIAL:
 if (r == mcESR_REPLACE_THIS && 
  (*newelem).data_GetType() == mcET_POLYNOMIAL) {

  // if we don't have a mcPolynomial as parent, then 
  //if (hlp()->GetParent().data_GetType() != mcET_POLYNOMIAL)
  // return mcESR_DONE;

  // FIXME: what if this monomial does not contain only the i-th
  // element ??? Where do we put all those elements if we replace
  // ourselves with the given newelem ?  

  // this mcMonomial must be replaced with the polynomial
  // given by the the math_Simplify(long flags) function of the i-th element of the array...
  return mcESR_REPLACE_THIS;
 }

 // mcMonomialHelpers cannot handle this flag; return it to mcPolynomial
 if (r == mcESR_DISTRIBUTE)
  return mcESR_DISTRIBUTE;
 if (r == mcESR_CHANGE_SIGN)
  return mcESR_CHANGE_SIGN;

 return mcElementArrayHelpers::math_HandleExpSimFlag(r, newelem, i);
}

void mcMonomialHelpers::math_Abs()
{
 // replace first op with a mcAddOp
 //math_ReplaceElement(mcET_OPERATOR, mcET_ADDOP, wxT('+'), '+', 0);
 mcNumber oldcoeff(math_GetCoeff());
 oldcoeff.math_Abs();

 math_SetCoeff(oldcoeff);
}

mcExpSimRes mcMonomialHelpers::math_Reorder()
{ 
 // be sure there are no mcDivOp
 mcASSERT(data_GetNumOfElemType(mcET_DIVOP) == 0, 
  wxT("This function cannot work with mcDivOp scattered in the array"));
 
 // now remove also all other operators
 math_RemoveAllOp();

 // reorder elements
 int n = math_ReorderElements(data_GetArray(), data_GetCount());

 // re-add those required mcMultOps
 data_Repair();
 
 return (n == 0 ? mcESR_DONE : mcESR_NOTFINISHED);
}

int mcMonomialHelpers::math_GetOrderPos() const
{
 mcMATHLOG(wxT("mcMonomialHelpers::math_GetOrderPos - retrieving order position for [%s]"), mcTXTTHIS);

 mcIntegerValue unk = math_GetMaxDegreeForSymbolArray(&mcSymbol::arrUnknowns);
 if (unk != *mcIntegerValue::pNAN)
  return -(int)(unk.GetInt()*10000);  // unknown-ordering have absolute precedence

 // if there are no unknowns in this monomial, then take in consideration
 // the parameters & the constants
 mcIntegerValue par = math_GetMaxDegreeForSymbolArray(&mcSymbol::arrParameters);
 if (par == *mcIntegerValue::pNAN) par = 0;
 mcIntegerValue con = math_GetMaxDegreeForSymbolArray(&mcSymbol::arrConstants);
 if (con == *mcIntegerValue::pNAN) con = 0;

 // give different importance to the various type of symbols 
 par *= 1;
 con /= 2;

 // the cast and GetInt() are used to avoid warnings
 return -(int)(par.GetInt()+con.GetInt());
}

mcIntegerValue mcMonomialHelpers::math_GetMaxDegreeFor(const mcSymbolProperties *p) const
{ 
 mcMATHLOG(wxT("mcMonomialHelpers::math_GetMaxDegreeFor [%s]"), mcTXTTHIS);
 mcSymbol s(p->data_GetSafeLinkedSym());
 mcIntegerValue res = 0;

 // scan this monomial searching for symbols of the given type
 for (int i=0,max=math_GetCountOf(s); i < max; i++) {
  
  mcSymbol sym(math_Find(i, s));
  mcASSERT(sym.data_isLinkedWith(p), wxT("The math_Find() function did not work"));
  
  // get its exponent
  const mcPolynomial exp = sym.math_GetConstExp();
  mcMATHLOG(wxT("mcMonomialHelpers::math_GetMaxDegreeFor - symbol [%s] have [%s] as exp"), 
     mcTXT(sym), mcTXT(exp));
  mcIntegerValue tmp = 0;
  
  // and if it exist, unwrap the number it contains
  if (exp != mcEmptyElement) 
   tmp = mcIntegerValue(exp.math_GetWrappedNumber());
  
  // the exponent exists but it does not contain a single number ?
  if (!tmp.isValid())
   return tmp;
  
  res = res.GetMax(tmp);
  mcMATHLOG(wxT("mcMonomialHelpers::math_GetMaxDegreeFor - currently it's [%s]"), 
   res.GetStr().c_str());
 }
 
 // if we did not find anything, we must return zero
 return res;
}

mcIntegerValue mcMonomialHelpers::math_GetMaxDegreeForSymbolArray(const mcSymbolArray *p) const
{
 mcIntegerValue res = 0;
 for (int i=0; i < p->data_GetCount(); i++) {

  // get the max degree for the i-th symbol
  mcIntegerValue tmp = math_GetMaxDegreeFor(p->data_GetSymbol(i));
  if (tmp == *mcIntegerValue::pNAN)
   return *mcIntegerValue::pNAN;

  // proceed
  res += tmp;
 }

 return res;
}



// -----------------------------------------------------
// mcMONOMIALMATH - overridden mcElementMath functions
// -----------------------------------------------------

mcPolynomial mcMonomialHelpers::math_GetPolynomialWrapper() const
{
 // create a polynomial...
 mcPolynomial res;
 mcElement copy(this);
 copy.data_MakePrivateCopy();

 // wrap ourselves into it...
 res.data_AddElements(&copy, 1);

 // and return it
 return res;
}

mcArrayEntry mcMonomialHelpers::math_WrapMonomial(const mcMonomial &mon)
{
 mcASSERT(0, wxT("bad use of this function !"));

 // just copy the given monomial into this one...
 data_DeepCopy(mon.hlp());

 // cannot return a pointer to the mcMonomial which holds us !
 return mcArrayEntry(this, -1);
}

mcArrayEntry mcMonomialHelpers::math_WrapSimple(const mcElement &p)
{
 mcASSERT(p.data_GetType() != mcET_MONOMIAL &&
   p.data_GetType() != mcET_POLYNOMIAL, wxT("cannot nest arrays !!"));

 int idx = data_AddElements(&p, 1);
 return mcArrayEntry(this, idx);
}

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

 // first of all, simplify to the maximum level the monomial:
 // this will make all the following operations easier to perform
 // for the math engine...
 p.math_MaxSimplify(mcEXPSIM_NOFLAGS);

 // ...then, for a mcMonomial, we must remove all the mcDivOp
 // (and also useless mcMultOp) to avoid problems.
 if (p.data_GetType() == mcET_MONOMIAL)
  mcMonomial(p).math_RemoveAllOp();
}

mcExpSimRes mcMonomialHelpers::math_BeginSimSteps()
{
 // be sure arrays is repaired
 data_Repair();

 // transform all the div ops in mult ops
 math_TransformDivOp();

 // those first steps usually do little or nothing
 return mcESR_DONE;
}

void mcMonomialHelpers::math_EndSimSteps()
{
 // we *always* need to repair the array
 data_Repair();
}




// ------------------------------------
// mcMONOMIALMATH - basic operations
// ------------------------------------

bool mcMonomialHelpers::math_CanBeAddedWith(const mcElement &p) const
{
 const mcMonomial &m = (mcMonomial &)p;

 // better allow additions/subtractions between monomials
 // only if they are similar...
 if (p.data_GetType() == mcET_MONOMIAL) {
 
  if (math_GetCount() == 1 &&
   m.math_GetCount() == 1) {

   // we contain only one element, and this is true also for the "m" monomial...
   // perform check on the contained elements
   bool res = data_Get(0).math_CanBeAddedWith(m.math_Get(0));

   // if the two elements can be summed so that the result
   // is contained in the first one, they return TRUE, but
   // if the result cannot be contained in the first one,
   // then math_CanBeAddedWith() will return FALSE but this does not
   // mean that they cannot be added in a mcMonomial-context...
   //
   // Example:
   //        x + x     <-- two mcSymbols cannot be added
   //                      so that the result is contained
   //                      in the first mcSymbol
   //         2x       <-- two mcSymbols can be added in a mcMonomial
   //
   if (res) return TRUE;
  }

  // if two monomials are similars, then they can always be added...
  // see the #isSimilarTo function for a definition of "similarity"
  if (math_isSimilarTo(m))
   return TRUE;
 }

 return FALSE;
}

mcBasicOpRes mcMonomialHelpers::math_Add(const mcElement &p, mcElement *pp, bool add)
{
 const mcMonomial &m = (const mcMonomial &)p;
 mcASSERT(p.data_GetType() == mcET_MONOMIAL, wxT("Cannot add non-monomials"));

 // the prerequisite for this algorithm to work is that this array
 // contains only mcMultOp and none mcDivOp
 math_RemoveAllOp();

 // this is the only difference between addition/subtraction
 //mcElementType optoinsert = (add ? mcET_ADDOP : mcET_SUBOP);

 // if we are containing a single element and this is true also for
 // the other addend, then, first of all check if the two contained elements can 
 // be added (and the result can be stored in one of the two mcElements)
 if (math_GetCount() == 1 && m.math_GetCount() == 1) {

  mcElement operand = m.math_Get(0);
  
  // suppose we have two mcSymbols to add: the result cannot
  // be stored inside one of the two but as mcMonomial we can
  // still store it...
  if (math_Get(0).math_CanBeAddedWith(operand)) {
   //mcASSERT(math_Get(0).math_CanBeAddedWith(operand), 
   //  "Error in mcMonomialHelpers::math_CanBeAddedWith");
   
   // just store the result in our first element...
   mcMATHLOG(wxT("mcMonomialHelpers::math_Add - %s [%s] and [%s]"), 
    (add ? wxT("adding") : wxT("subtracting")), mcTXT(math_Get(0)), mcTXT(operand));
   return math_Get(0).math_Add(operand, NULL, add);
  }
 }

 // now, we can do two things:
 // 1) sum up the coefficients of the two monomials
 // 2) pick up the non-common factors of the two monomials 
 mcASSERT(math_isSimilarTo(m), wxT("math_CanBeAddedWith() is buggy"));
 //mcLOG("mcMonomialHelpers::math_Add - The two monomials are similar = %d", b);

 // just find the coefficients and sum/subtract them
 mcRealValue thiscoeff = math_GetCoeff();  
 mcRealValue mcoeff = m.math_GetCoeff();
 mcMATHLOG(wxT("mcMonomialHelpers::math_Add - the two coeff to %s are: [%s] and [%s]"), 
  (add ? wxT("ADD") : wxT("SUBTRACT")), mcTXTV(thiscoeff), mcTXTV(mcoeff));
 
 if (add)
  thiscoeff += mcoeff;
 else
  thiscoeff -= mcoeff;

 mcMATHLOG(wxT("mcMonomialHelpers::math_Add - the result is [%s]"), mcTXTV(thiscoeff)); 
 math_SetCoeff(mcNumber(thiscoeff));
 
 // re-add those operators which are required
 data_Repair();

 // in all the cases, the second addend must be set to zero... 
 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcMonomialHelpers::math_MultiplyBy(const mcElement &e, mcElement *pp)
{
 mcASSERT(e.data_GetType() == mcET_MONOMIAL, 
  wxT("Only monomials can be used here; use math_MultiplyBySimple() instead"));

 mcMonomial &m = (mcMonomial &)e;
 
 mcElement num(mcEmptyElement);
 if ((num=data_GetWrapped(mcET_NUMBER)) != mcEmptyElement &&
  mcNumber(num).data_Get() == 1.0) {  

  // replace with the elements in the given monomial the simple "1"
  // contained into this monomial
  data_DeleteAll();
  data_Merge(m);

 } else {
 
  // put the new factors just after the end of this monomial  
  data_Merge(m);
 }

 // check that everything is okay (and add mcMultOp where required)
 data_Repair();

 // the second operand has been completely merged: it can be removed
 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcMonomialHelpers::math_DivideBy(const mcElement &e, mcElement *pp)
{
 mcASSERT(e.data_GetType() == mcET_MONOMIAL, 
  wxT("Only monomials can be used here; use math_DivideBySimple() instead"));

 // just create a fraction...
 mcPolynomial &den = math_EmbedInFraction(FALSE).data_GetFraction().data_GetDen();

 // ...and set its denominator to the given element
 mcMonomial towrap(e);
 den.data_DeleteAll();
 den.math_WrapMonomial(towrap);
 
 // the second operand has been embedded in a fraction
 return mcBOR_REMOVE_OPERAND;
}






// -----------------------------------------------------
// mcMONOMIALMATH - helper functions
// -----------------------------------------------------

bool mcMonomialHelpers::math_isSimilarTo(const mcMonomial &m) const
{
 // scan the two arrays when they are simplified at the most level
 mcMonomial m1(this);
 mcMonomial m2(m);
 
 // remove the coefficients of the monomials...
 m1.math_RemoveCoeff();
 m2.math_RemoveCoeff();

 // do the real comparison
 mcMATHLOG(wxT("mcMonomialHelpers::math_isSimilarTo - are [%s] and [%s] similar ?"),
            mcTXT(m1), mcTXT(m2));
 bool res = m1.math_Compare(m2, mcFIND_NOFLAGS);
 mcMATHLOG(wxT("mcMonomialHelpers::math_isSimilarTo - %s"),
    (res == TRUE ? wxT("yes they are") : wxT("no they aren't")));

 // data_Delete the temporary backups...
 //data_Delete m1;
 //data_Delete m2;

 return res;
}

void mcMonomialHelpers::math_TransformDivOp()
{
 // scans the array and replaces mcMultDivOps with mcFractions...
 for (int i=0; i < data_GetCount()-1; i++) {

  // convert from mcDivOp to mcMultOp
  if (data_Get(i).data_GetType() == mcET_DIVOP) {

   // make the reciprocal of the elements which follows this mcDivOp....
   mcElement replacement = NULL;
   data_Get(i+1).math_MakeReciprocal(&replacement);

   if (replacement != mcEmptyElement) {

    // we must replace the i+1-th element with the given pointer...
    data_AddElements(&replacement, 1, i+1, TRUE);
   }

   // and replace the div op with a mult op   
   data_AddNewOp(mcET_MULTOP, i);
  }
 }
}

void mcMonomialHelpers::math_RemoveAllOp()
{
 // turn div ops into mult ops
 math_TransformDivOp();

 // remove all mult operators
 for (int i=0; i < data_GetCount(); i++) {

  if (data_isOp(i)) {  // this should be a mcMultOp

   data_Delete(i);
   data_MoveElemLeft(i);
  }
 }
}

void mcMonomialHelpers::math_RemoveCoeff()
{
 for (int i=0; i < math_GetCount(); i++) {

#ifdef EXTENDED_COEFF
  if (!data_Get(i).math_ContainsUnknowns(NULL))
   if (!Remove(i, TRUE))
    i--;  // recheck this element
#else
  // find all free mcNumbers, and data_Delete them...
  if (math_Get(i).data_GetType() == mcET_NUMBER) {

   // #Remove will return TRUE if a mcNumber intialized with zero
   // was added to the array to avoid to leave it empty... in this
   // case we must avoid to recheck that mcNumber
   if (!math_Remove(i, TRUE))
    i--;  // recheck this element
  }
#endif
 }
}

mcMonomial mcMonomialHelpers::math_DetachNonCommonFactors(const mcMonomial &m)
{
 // create an empty monomial which will be filled with the
 // non common factors 
 mcMonomial res;

 // scan the entire array
 for (int i=0; i < data_GetCount(); i++) {
  
  mcElementType t = data_Get(i).data_GetType();
  int n = -1;
  
  // check the i-th element of this array
  // against the elements of the same type
  // in the given monomial
  for (int j=0; j < m.math_GetCount(); j++)
   if (t == m.math_Get(j).data_GetType())
    if (data_Get(i).math_Compare(m.math_Get(j), TRUE))
     n = j;
  
  if (n == -1) {
   
   // add this element to the array to return
   res.data_AddElements(data_GetArray(i), 1, -1, TRUE);
   
   // and remove that element from this array
   data_Delete(i);
   data_MoveElemLeft(i);
   i--;
  }
 }

 return res;
}

void mcMonomialHelpers::math_SimplifyCoeff()
{
 mcMATHLOG(wxT("mcMonomialHelpers::math_SimplifyCoeff [%s] - process starting"), mcTXTTHIS);

 // all mcNumber which are tied by multiplications, are cumulated here:
 mcNumber num = *mcNumberHelpers::smath_pOne;

 // all mcNumbers preceded by mcDivOp will be cumulated here:
 mcNumber den = *mcNumberHelpers::smath_pOne;

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

  int n = data_GetElemIndexOfType(i, mcET_NUMBER);

  // merge these two mcNumbers (which is not granted are adiacent)
  // using the operator which is 
  mcElementType t = mcET_MULTOP;
  
  // if there is nothing before or there is a non-operator,
  // then a mcMultOp must be used...
  if (n >= 0) {
   if (n > 0 && data_isOp(n-1))
    t = data_Get(n-1).data_GetType();
   
   // the two mcNumbers are separated by one operator: use it to
   // merge them...
   if (t == mcET_MULTOP)
    num.math_SimpleMultiplyBy(data_Get(n));
   else if (t == mcET_DIVOP)
    den.math_SimpleMultiplyBy(data_Get(n));  
  }
 }

 // now, add the num/den at the beginning of the array...
 math_ApplyOpSimple(mcET_DIVOP, num, den);

 // remove old coefficient and add the new one at the beginning of
 // the array... 
 math_SetCoeff(num);
 mcMATHLOG(wxT("mcMonomialHelpers::math_SimplifyCoeff [%s] - coeff simplified"), mcTXTTHIS);
}

//mcMonomial
mcRealValue mcMonomialHelpers::math_GetCoeff() const
{
#ifdef EXTENDED_COEFF

 mcMonomial &coeff = (mcMonomial &)mcNewMonomial();

 // return everything which doesn't contain any unknown
 for (int i=0, max=data_GetCount(); i < max; i++) {

  mcElement p = data_Get(i);
  if (!p->math_ContainsUnknowns(NULL))
   coeff->data_AddElements(&p, 1, -1);
 }

 if (coeff->data_GetCount() > 0)
  return coeff;
 return *mcNumberHelpers::smath_pOne;

#else

 int n = data_GetNumOfElemType(mcET_NUMBER);
 mcMonomial touse(this);

 if (n > 1) {
  mcMonomial copy(this);

  // reduce to one mcNumber all the various mcNumbers 
  // scattered in the array...
  copy.math_SimplifyCoeff();

  // instead of *this, use the temporary "copy" to get the coeff....
  touse.data_Ref(copy);
  
  // we should not need to check the new count of mcNumbers
#ifdef __MCDEBUG__
  n = touse.data_GetNumOfElemType(mcET_NUMBER);
#else
  n = 1;
#endif
 }

 mcASSERT(n <= 1, wxT("Something wrong in math_SimplifyCoeff"));
 
 // if we have our mcNumber we just have to return a copy of it...
 if (n > 0)
  return mcNumber(touse.data_GetElemOfType(0, mcET_NUMBER)).data_Get();//*mdata_sign;
 
 // no mcNumbers in the array means a simple "1.0"
 return mcRealValue(1);//*mdata_sign;

#endif
}

void mcMonomialHelpers::math_SetCoeff(const mcNumber &coeff)//mcMonomial &n)
{
 mcNumber n(coeff);

 // remove old coeff
 math_RemoveCoeff();

 // update the sign variable
 /*if (n.data_Get() >= 0)
  mdata_sign = 1;
 else {

  // we must always store only positive coefficients !
  mdata_sign = -1;
  n.math_Abs();
 }*/

 // in some cases (when the array would be empty otherwise)
 // the #RemoveCoeff() function leaves one mcNumber at the
 // beginning of the array...
 bool overwrite = FALSE;
 if (data_GetCount() > 0 && data_Get(0).data_GetType() == mcET_NUMBER)
  overwrite = TRUE;

 // add the new coefficient (eventually overwriting last one)
 data_AddElements((mcElement *)(&n), 1, 0, overwrite);
}

void mcMonomialHelpers::math_ChangeCoeffSign()
{ 
 // this function cannot be put in the header file !!!!
 math_SetCoeff(mcNumber(math_GetCoeff().ChangeSign())); 
}

/*
mcMonomial mcMonomialHelpers::math_GetFactors() const
{
 
 for (int i=0,max=math_GetCount(); i<max; i++)
  math_Get(i)->math_GetFactors();
}*/

mcMonomial mcMonomialHelpers::math_GetLCM(const mcElement &p) const
{
 mcMATHLOG(wxT("mcMonomialHelpers::math_GetLCM - computing lcm between [%s] and [%s]"), 
    mcTXTTHIS, mcTXT(p));

 mcMonomial arr(p);
 mcMonomial res(this);

 if (arr.math_GetCount() == 1 && math_GetCount() == 1) {

  mcElement a(arr.math_Get(0));
  mcElement b(math_Get(0));

  // the lowest common multiple simply is the product
  // of a and b if a and b are different
  if (!a.math_Compare(b, TRUE)) {

   res.math_SimpleMultiplyBy(a);
  }

 } else {

  for (int j=0,max=arr.math_GetCount(); j < max; j++) {

   mcElement tofind(arr.math_Get(j));
   mcMATHLOG(wxT("mcMonomialHelpers::math_GetLCM - now processing [%s]"), mcTXT(tofind));
   
   // find the first occurrence of 'tofind'
   int idx=res.math_GetIndexOf(0, tofind);
   
   if (idx > -1) {

    // get the LCM between the j-th element of "arr"
    // and the idx-th element of "res"
    mcElement &tmp = res.math_Get(idx);   
    mcMonomial mon(tmp.math_GetLCM(tofind));
   
    // remove the old factor and add the contents
    // of the new monomial containing the LCM just computed
    res.math_Remove(idx);
    res.math_SimpleMultiplyBy(mon);

    // this algorithm requires no more than one element
    // with the same base of the "tofind" element...
    mcASSERT(res.math_GetIndexOf(1, tofind) == -1, 
     wxT("Cannot be present more than a factor of 'tofind'..."));

   } else {

    // the j-th factor of wxT("arr") is not present in "res":
    // we must add it...
    res.math_SimpleMultiplyBy(tofind);
   }

   mcMATHLOG(wxT("mcMonomialHelpers::math_GetLCM - final lcm now is [%s]"), mcTXT(res));
  }
 }

 mcMATHLOG(wxT("mcMonomialHelpers::math_GetLCM - lcm is [%s]"), mcTXT(res));
 return res;
}

mcMonomial mcMonomialHelpers::math_GetGCD(const mcElement &p) const
{
 mcMATHLOG(wxT("mcMonomialHelpers::math_GetGCD - computing gcd between [%s] and [%s]"), 
    mcTXTTHIS, mcTXT(p));

 // create the monomial used to compute GCD and to return the result:
 //mcMonomial arr1(this);
 mcMonomial arr2(p);
 mcMonomial res;

 // to compute the GCD we must be sure that arr1 & arr2
 // do no contain the same factors with same exponents
 //arr2.math_MaxSimplify();

 if (arr2.math_GetCount() == 1 && math_GetCount() == 1) {

  mcElement a(arr2.math_Get(0));
  mcElement b(math_Get(0));

  if (a.data_GetType() != b.data_GetType())
   return *mcMonomialHelpers::smath_pOne;

  // we have two simple elements and we just need their GCD
  return a.math_GetGCD(b);

 } else {
  
  res.math_ResetToOne();
  for (int i=0; i < math_GetCount(); i++) {
   for (int j=0; j < arr2.math_GetCount(); j++) {
    
    // we've got two elements:
    //    
    //  idx  | 0 | 1 | 2 | 3 |
    //       |---|---|---|---|
    // *this | a | b | c | d |
    //
    //   i ------------^
    //
    //  idx  | 0 | 1 | 2 |
    //       |---|---|---|
    //   m   | c | d | e |
    //
    //   j ----^
    //
    
    mcElement tmp(math_Get(i).hlp()->math_GetGCD(arr2.math_Get(j)));
    if (!mcMonomial(tmp).math_isWrappingOnly(1.0))
     res.math_SimpleMultiplyBy(tmp);

    mcMATHLOG(wxT("mcMonomialHelpers::math_GetGCD - gcd currently is [%s]"), 
      mcTXT(res));
   }
  }
 }

 mcMATHLOG(wxT("mcMonomialHelpers::math_GetGCD - final gcd is [%s]"), mcTXT(res));
 return res;
}

---

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

[ Top ]