Main page

---

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


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

#ifndef mcPRECOMP
 #include <wx/tokenzr.h>
 #include "mc/Polynomial.h"
 #include "mc/Monomial.h"
 #include "mc/MathUtils.h"
#endif



// these are required by mcPolynomialMath functions
#include "mc/Bracket.h"
#include "mc/Number.h"
#include "mc/Fraction.h"
#include "mc/Parenthesis.h"
#include "mc/Symbol.h"


mcIMPLEMENT_MAIN_CLASS(mcPolynomial, mcElementArray);



// setup customizable variables
int mcPolynomialHelpers::sgui_nSpaceBetween = 2;
mcPolynomial *mcPolynomialHelpers::smath_pOne = NULL;
mcPolynomial *mcPolynomialHelpers::smath_pEmpty = NULL;


// global objects
mcPolynomial mcEmptyPolynomial((mcPolynomialHelpers*)NULL);




// ----------------------------------------
// mcPOLENTRY
// ----------------------------------------

/*int mcPolEntry::math_GetMonIdx(const mcPolynomial &owner)
{ return owner.math_DataToMathIdx(mdata_midx); }

int mcPolEntry::math_GetElemIdx(const mcPolynomial &owner)
{ return owner.math_DataToMathIdx(mdata_eidx); }*/



bool isPolynomialOkay(const mcElement &p)
{
 static bool lastwasop = FALSE;

 if (p.data_GetType() != mcET_MONOMIAL && 
  p.data_GetType() != mcET_ADDOP && 
  p.data_GetType() != mcET_SUBOP) {

  // only monomials, add & sub operators are supported
  return FALSE;
 }

 if ((p.data_GetType() == mcET_ADDOP || 
  p.data_GetType() == mcET_SUBOP) && !lastwasop) {

  lastwasop = TRUE;

 } else if (p.data_GetType() == mcET_MONOMIAL && lastwasop) {

  lastwasop = FALSE;

 } else {

  // this array is containing something which is not a operator
  // nor a mcMonomial... or it contains one of these elements
  // but in an invalid order...
  return FALSE;
 }

 return TRUE; 
}






// ----------------------------------------
// mcPOLYNOMIALDATA
// ----------------------------------------

#ifdef __MCDEBUG__

void mcPolynomialHelpers::data_Check() const
{   
 // check that a + or - is separing all the monomials in the array
 bool b = FALSE;
 if (data_GetCount() > 0 && data_isOp(0))
  b = TRUE;

 // if we say to ScanArray to check only even elements, the first would
 // be skipped !!! check it here....
 if (!b && data_GetCount() > 0) {

  mcASSERT(!data_isOp(0), 
   wxT("If 'b' is FALSE, the first element should be a non-op !!!"));
  mcASSERT(data_Get(0).data_GetType() == mcET_MONOMIAL, 
   wxT("If the first element is not an op, then it should be a mcMonomial !!!"));
 }
 
#ifdef mcENABLE_VERBOSE_CHECK
 mcLOG(wxT("mcPolynomialHelpers::data_Check - checking [%s]"), mcTXTTHIS);
#endif
 mcASSERT(data_ScanArray(isPolynomialOkay, b), 
  wxT("Not all the monomials in the array are ") \
  wxT("separed by a mcAddOp or a mcSubOp"));

 // this MUST be true... it's an important prerequisite of math functions
 //mcASSERT(data_GetCount() == 0 || data_isOp(0), "The expression must always start with a + or -");
 mcElementArrayHelpers::data_Check();
}

#endif

bool mcPolynomialHelpers::data_isWrappingOnly(mcElementType t) const
{
 if (data_GetCount() > 1)  // more than an element ?
  return FALSE;

 // check if we are directly containing the given element type...
 // (which can be only a mcOperator or mcMonomial, in this case)
 if (data_Get(0).data_GetType() == t)
  return TRUE;

 // EXTENDED FEATURE mcPOLYNOMIAL-SPECIFIC:
 // if we're containing a single monomial, then check if it's
 // wrapping only the required element type: data_GetWrapped
 // will allow the programmer to extract it...
 if (data_Get(0).data_GetType() == mcET_MONOMIAL &&
  ((const mcMonomial &)data_Get(0)).data_isWrappingOnly(t))
  return TRUE;
 return FALSE;
}

const mcElement &mcPolynomialHelpers::data_GetWrapped(mcElementType t) const
{
 // we need to call this function to be sure that we
 // do not have more than one monomial...
 if (!data_isWrappingOnly(t))
  return mcEmptyElement;

 // if t is the identifier of a mcMonomial or a mcOperator, we can directly
 // return it here
 if (data_Get(0).data_GetType() == t)
  return data_Get(0);

 // otherwise we can extract here from the single monomial we contain...
 return ((const mcMonomial &)data_GetElemOfType(0, mcET_MONOMIAL)).data_GetWrapped(t);
}

bool mcPolynomialHelpers::math_isWrappingOnly(mcElementType t) const
{
 // see data_isWrappingOnly for details.... 
 if (math_GetCount() != 1)
  return FALSE;
 if (math_Get(0).data_GetType() == t)
  return TRUE;
 if (math_Get(0).math_isWrappingOnly(t))
  return TRUE;
 return FALSE;
}

const mcElement &mcPolynomialHelpers::math_GetWrapped(mcElementType t) const
{
 // see data_isWrappingOnly for details....
 if (!math_isWrappingOnly(t))
  return mcEmptyElement;
 if (math_Get(0).data_GetType() == t)
  return math_Get(0);
 return math_Get(0).math_GetWrapped(t);
}

bool mcPolynomialHelpers::data_CreateFirstOp()
{
 if (!data_isArrayEmpty() && data_isOp(0))
  return FALSE;   // one is already present...
 
 // if the first element of the this polynomial is *not* an operator
 // we must add one !!!
 data_MoveElemRight(0);
 data_AddNewOp(mcET_ADDOP, 0);  // by default, add a +
 return TRUE;
}

void mcPolynomialHelpers::data_DeleteFirstOp()
{
 if (data_isArrayEmpty() || !data_isOp(0))
  return;  // there is no a first operator to data_Delete

 data_DeleteFirst(1);  // just remove first element
}

mcElement &mcPolynomialHelpers::data_AddNewWrappedElement(mcElementType t, 
                bool bOverwrite, int pos)
{
 mcASSERT(t != mcET_MONOMIAL, wxT("Cannot nest monomials"));

 // create an element of type "t" and create a monomial containing it
 mcElement res = mcElementHelpers::data_NewElem(t);
 int n = data_AddNewMonomialContaining(&res, pos, bOverwrite);
 if (n == -1) return mcEmptyElement;

 // then return the index of the new monomial
 mcMonomial &m = (mcMonomial &)data_Get(pos);
 return m.data_Get(n);
}

void mcPolynomialHelpers::data_DetachAndShiftMonomial(int n)
{
 // be sure the n-th element is a monomial
 mcASSERT(data_Get(n).data_GetType() == mcET_MONOMIAL, 
  wxT("This function works on monomials only"));

 // data_Detach the n-th monomial and its sign
 data_Detach(n);
 data_MoveElemLeft(n);

 if (n > 0 && data_isOp(n-1)) {
  data_Detach(n-1);
  data_MoveElemLeft(n-1);
 }
}

int mcPolynomialHelpers::data_AddNewMonomialContaining(mcElement *contents, 
                int n, int pos, bool bOverwrite)
{
 // create the new monomial
 mcMonomial m;
 
 // add to it the given elements
 mcASSERT(n > 0, wxT("Cannot add zero elements"));
 int idx = m.data_AddElements(contents, n);
 
 // and then add the monomial to this array
 data_AddElements((mcElement *)(&m), 1, pos, bOverwrite);
 return idx;
}

bool mcPolynomialHelpers::data_ReplaceParentheses(int leftm, int leftidx, 
              int rightm, int rightidx, 
              bool bMoveOnBracketEnd)
{
 const mcMonomial &left = (const mcMonomial &)data_Get(leftm);
 const mcMonomial &right = (const mcMonomial &)data_Get(rightm);
 const mcParenthesis &rightp = (const mcParenthesis &)right.data_Get(rightidx);
 mcLOG(wxT("mcPolynomialHelpers::data_ReplaceParentheses - ")
  wxT("the monomial containing the left bracket is [%s]"), mcTXT(left));
 mcLOG(wxT("mcPolynomialHelpers::data_ReplaceParentheses - ")
  wxT("the monomial containing the right bracket is [%s]"), mcTXT(right));
 
 // ok, we have found a right bracket and we can thus
 // create our new mcBracket...
 mcPolynomial contents;
    
 // if the monomial containing the left bracket contains something
 // which follows the left parenthesis, then copy it in our
 // brand-new polynomial... 
 if (left.data_GetCount() - leftidx > 0) {
  
  int n = left.data_GetCount() - leftidx - 1;
  
  if (rightm == leftm) {
   
   // if the monomial containing the LEFT and the RIGHT
   // parentheses are the same, then we must adjust n
   n -= left.data_GetCount()-rightidx;
  }
  
  if (n > 0)
   contents.data_AddNewMonomialContaining(
    left.data_GetArray(leftidx+1),
    n, 
    -1,
    TRUE);
 }
    
 // now add all the monomials placed between the monomial
 // containing the LEFT parenthesis and the one containing
 // the RIGHT one...
 if (rightm-leftm > 0) {
  
  contents.data_AddElements(
   data_GetArray(leftm+1),
   rightm-leftm-1);
 }
    
 // finally, add the elements ,which are placed in the monomial
 // containing the RIGHT bracket, which precede the parenthesis...
 if (rightm != leftm && rightidx > 0) {
  
  contents.data_AddNewMonomialContaining(
   right.data_GetArray(),
   rightidx); 
   //TRUE);
 }
    
 // don't create empty polynomials !!!
 if (contents.data_isArrayEmpty()) {
  
  // add a simple empty box; the result will be:
  //
  //     (--)     where -- is the empty box !!!!
  //
  contents.data_AddNewEmptyMonomial();
 }

 // don't create empty monomials !!!
 /*const mcMonomial &m = contents.data_Get(0);*/
 if (((const mcMonomial &)contents.data_GetElemOfType(0, mcET_MONOMIAL)).data_isArrayEmpty()) {
  
  // in these cases:
  //
  //          (   + ... )
  //            ^- empty monomial  
  //
  // we cannot just add an empty box: we must
  // instead remove the first monomial; in this
  // way, the operator between 1th and 2nd, becomes
  // the first operator of the bracket's polynomial...
  contents.data_DeleteFirst(1);
 }
 
 // complete bracket creation...
 mcBracket br;
 br.data_SetContent(contents);
    
 // eventually set the bracket's exponent
 // (stored in a temporary field of mcParenthesis) 
 if (rightp.hlp()->mdata_pTmpExp != mcEmptyElement &&
  !rightp.hlp()->mdata_pTmpExp.data_isArrayEmpty()) {
    
  mcLOG(wxT("mcPolynomialHelpers::data_ReplaceParentheses - ")
   wxT("the exponent of the bracket is [%s]"), mcTXT(rightp.hlp()->mdata_pTmpExp));
  br.data_SetExpSub(TRUE, rightp.hlp()->mdata_pTmpExp);
 }
    
 mcLOG(wxT("mcPolynomialHelpers::data_ReplaceParentheses - ")
  wxT("the new bracket is [%s]"), mcTXT(br));
 br.data_Check();
    
 // ok, now we have our new bracket; but it must replace
 // ALL the elements that we have copied inside the bracket...
 mcMonomial &m = (mcMonomial &)left;
    
 // data_Delete the useless elements contained in the first monomial
 int cursoridx = -1;
 if (rightm != leftm) {
     
  m.data_DeleteLast(m.data_GetCount()-leftidx);
  m.data_AddElements((mcElement*)(&br), 1);
  cursoridx = m.data_GetCount()-1;
  
 } else {
     
  // both the LEFT and the RIGHT parentheses are contained
  // in the same monomial; special code is required in this case...
  m.data_AddElements((mcElement*)(&br), 1, leftidx, TRUE);
  cursoridx = leftidx;
     
  // remove the elements placed between the bracket we have
  // just added and the right parenthesis...
  for (int g=leftidx+1; g < rightidx+1; g++) {
      
   m.data_Delete(leftidx+1);
   m.data_MoveElemLeft(leftidx+1);
  }
 }
    
 // place the cursor of the monomial at the end of the
 // bracket we have created...
 if (mcMathCore::Get()->isGUIEnabled()) {
  if (bMoveOnBracketEnd) {
      
   // end of the monomial is the end of the bracket, too:
   //     ... (...)| ...     <-- final pos of cursor
   m.gui_SetCursorPos(mcCP_END);
      
  } else {
      
   m.gui_SetCursorOnElemBegin(cursoridx);
   
   // this will set the cursor here:
   //     ... (|...) ...
   // instead of
   //     ... |(...) ...
   // thus simulating the real input of the parenthesis
   m.gui_MoveCursor(mcMCF_RIGHT, mcMCF_NOMODIFIERS);
  }
 }
    
 // finally, add to the first monomial the useful elements 
 // contained in the right monomial...
 if (rightm != leftm) {
  
  m.data_AddElements(
   right.data_GetArray(rightidx+1),
   right.data_GetCount()-rightidx-1);
  
  // and last, remove the right monomial...
  data_Delete(leftm+1);
  data_MoveElemLeft(leftm+1);
 }
 
 // remove the monomials placed between the two containing
 // the LEFT and the RIGHT bracket...
 for (int g=leftm+1; g < rightm; g++) {
  
  data_Delete(leftm+1);
  data_MoveElemLeft(leftm+1);
 }
    
 mcLOG(wxT("mcPolynomialHelpers::data_ReplaceParentheses - ")
  wxT("after removing replaced elements, I'm set to [%s]"), mcTXTTHIS); 
    
 // move cursor to a valid position
 if (mcMathCore::Get()->isGUIEnabled())
  mgui_nCursorPos = leftm;
    
 // stop here
 data_Check();
 return TRUE;  // a pair of mcParenthesis have been replaced
}
    
bool mcPolynomialHelpers::data_ReplaceParentheses(bool bMoveOnBracketEnd)
{
 bool bFoundFirst = FALSE; // TRUE if the LEFT bracket has already been found

 int monomialidx = -1, // the index of the monomial containing the LEFT bracket
  bracketidx = -1; // the bracket's index of the LEFT bracket

 int bridx = -1,   // the current bracket's index in the current monomial
  i;     // the index of the current monomial
 
 for (i=0; i < data_GetCount(); i++) {
  
  // skip non-monomials...
  if (data_Get(i).data_GetType() != mcET_MONOMIAL)
   continue;
  
  // ok, process this monomial...
  const mcMonomial &m = (const mcMonomial &)data_Get(i);
  
  // ...scanning all its elements...
  for (int j=0, max=m.data_GetCount(); j < max; j++) {
   
   const mcElement &curr = m.data_Get(j);
   if (curr.data_GetType() != mcET_PARENTHESIS)
    continue;
    
   // get a pointer to the just found parenthesis
   bridx = j;
   const mcParenthesis &p = m.data_Get(bridx);
   
   if (!bFoundFirst) {
    
    // wait for the next...
    if (!p.data_isLeftBracket())
     continue;
    
    // ok, we have found the left parenthesis... now,
    // we can go on searching its counterpart...
    bFoundFirst = TRUE;
    monomialidx = i;
    bracketidx = bridx;
    
    // copy the elements which are contained in the current
    // monomial and which follow the parenthesis in the
    // polynomial which will be used as the content array
    // for the new bracket element we are trying to create...
    
   } else {
    
    
    if (p.data_isLeftBracket()) {
     
     // hmmmm, we have find a left bracket instead of
     // a right bracket... update our indexes because
     // inner brackets must be solved as firsts
     monomialidx = i;
     bracketidx = bridx;
     continue;
    }
    
    // proceed with replacement
    return data_ReplaceParentheses(monomialidx, bracketidx, i, 
            bridx, bMoveOnBracketEnd);
   }
  }
 }
 
 // no mcParenthesis have been replaced
 return FALSE;
}

void mcPolynomialHelpers::data_ReplaceAllParentheses()
{
 bool exit = FALSE;
 while (!exit) {

  // higly probably, cursor position will be invalid
  // after this operations...
  exit = !data_ReplaceParentheses(FALSE);
 }
}

void mcPolynomialHelpers::gui_ReplaceBracket(const mcBracket &br, bool left)
{
 mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - replacing the %s of [%s]"),
    (left ? wxT("left") : wxT("right")), mcTXT(br));
 mcPolynomial contents(br.data_GetConstContent());
 mcMonomial &m = mcEmptyMonomial;

 int monomialidx = -1, // the index of the monomial containing 'br'
  pcursoridx = -1, // a copy of the index of the previous monomial
  bridx = -1,   // the "br"'s index inside data_Get(monomialidx)
  mcursoridx = -1; // the index of the element preceding "br"

 // this is a prerequisite...
 mcASSERT(contents.data_GetCount() > 0, wxT("Cannot break an empty bracket..."));

 // first of all, find the monomial which contains the bracket which
 // must be replaced by mcParenthesis + its contents...
 for (int i=0; i < data_GetCount(); i++) {

  // discard non-monomial elements
  if (data_Get(i).data_GetType() != mcET_MONOMIAL)
   continue;
  const mcMonomial &tocheck = (const mcMonomial &)data_GetConst(i);
  
  // does this monomial contains the bracket to replace ?
  if ((bridx = tocheck.data_GetIndexOf(br)) != -1) {
   monomialidx = i;  // save these info
   pcursoridx = monomialidx;
   mcursoridx = bridx-1;
   m = tocheck;
   break;
  }
 }

 mcASSERT(m != mcEmptyElement, wxT("Something wrong"));
 mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - the monomial ")
   wxT("with the bracket to replace is [%s]"), mcTXT(m));
 m.data_Delete(bridx);
 m.data_MoveElemLeft(bridx);

 // ok, add the left parenthesis if the parenthesis which had been removed
 // is the RIGHT one...
 if (!left) {

  mcParenthesis left;
  left.data_SetAsLeftBracket();
  left.data_AddProperty(mcEP_INITIALIZED);
  m.data_AddElements(&left, 1, bridx);
  bridx++;

  mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - the monomial is [%s]"), mcTXT(m));
 }

 // maybe that the first element of the bracket is not a monomial but a
 // mcAddOp or a mcSubOp... better check...
 mcMonomial &first = (mcMonomial &)contents.data_GetElemOfType(0, mcET_MONOMIAL);
 if (contents.data_Get(0).data_GetType() == mcET_MONOMIAL) {
  m.data_AddElements(first.data_GetArray(), 
       first.data_GetCount(), bridx);
  //bridx = m.data_GetIndexOf(br);

  // delete this monomial since it's already been added
  contents.data_Delete(0);
  contents.data_MoveElemLeft(0);
 }

 mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - the monomial is [%s]"), mcTXT(m));

 // add the monomials contained in the just-removed bracket
 if (contents.data_GetCount() > 1) {
 
  data_Merge(contents);
  monomialidx += contents.data_GetCount();
 }
 
 m = (mcMonomialHelpers *)data_Get(monomialidx).hlp();

 // if the parenthesis which must result as the removed one is the
 // LEFT, we must add the RIGHT one...
 if (left) {
  mcParenthesis right;
  right.data_SetAsRightBracket();
  right.data_AddProperty(mcEP_INITIALIZED);
  m.data_AddElements(&right, 1, bridx+1);

  mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - the monomial is [%s]"), mcTXT(m));
 }


 // set the cursor in the right position
 if (!left) {
  mgui_nCursorPos = monomialidx;

  // move the monomial cursor too
  if (bridx+1 >= m.data_GetCount())
   m.gui_SetCursorPos(mcCP_END);
  else
   m.gui_SetCursorOnElemEnd(bridx+1);
 }

 if (left) {

  // move cursor
  mgui_nCursorPos = pcursoridx;
  m = (mcMonomialHelpers *)data_Get(pcursoridx).hlp();

  if (mcursoridx < 0) {

   // there were no elements before the bracket; the cursor
   // must be placed at the beginning of the monomial...
   m.gui_SetCursorPos(mcCP_BEGIN);

  } else {

   // place the cursor on the element which was preceding the
   // bracket we replaced...
   m.gui_SetCursorOnElemEnd(mcursoridx);
  }
 }

 // ok, we have finished....
 data_Check(); 
 mcGUILOG(wxT("mcPolynomialHelpers::gui_ReplaceBracket - we are now ")
   wxT("set to [%s]"), mcTXTTHIS);
}

int mcPolynomialHelpers::data_FindMonomialContaining(int occ, const mcElement &elem) const
{
 int n = -1;

 for (int i=0; i < data_GetCount(); i++) {
  
  // skip non monomial elements
  if (data_Get(i).data_GetType() != mcET_MONOMIAL) continue;

  // search, non-recursively, in this monomial
  if ((n = mcMonomial(data_Get(i)).data_GetIndexOf(elem)) != -1) {   
   if (occ == 0)
    return n;
   occ--;  // try with next occurrence
  }
 }

 // could not find any result
 return -1;
}







// ----------------------------------------
// mcPOLYNOMIALGUI
// ----------------------------------------

bool mcPolynomialHelpers::gui_isArrayEmpty()
{
 if (data_isArrayEmpty() || (data_GetCount() == 1 && data_isOp(0)))
  return TRUE;
 return FALSE;
}

int mcPolynomialHelpers::gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl) const
{
 mcGUILOG(wxT("mcPolynomialHelpers::gui_ExDraw [%s]"), mcTXTTHIS);
 int a = gui_GetSelElemCount();
 
 // if a selection among two or more monomials is present in the polynomial, 
 // draw it ourselves, if a selection is present but it is limited to one
 // monomial only, let that monomial draw it...
 if (a > 1) {

  // we will care about the selection rectangle drawing...
  int mflags = flags & ~mcDRW_ALLOW_TOTAL_SELECTION;

  // the selection is "extended": draw only non-selected monomials
  int w, n = mcElementArrayHelpers::gui_ExDraw(dc, x, y, mflags, pt, cl);

  // draw selection rectangle + selected monomials & 
  // check if we must change return code
  if ((w=gui_DrawSelection(dc, x, y, flags, pt, cl)) != mcDRW_NOACTIVEELEM)
   n = w;
  return n;
 } 

 return mcElementArrayHelpers::gui_ExDraw(dc, x, y, flags, pt, cl, FALSE, -1, TRUE);
}

void mcPolynomialHelpers::gui_ExOnSelect(wxDC &dc, wxRect &rc, int cl)
{
 // select elements using the mcElementArray function
 mcElementArrayHelpers::gui_ExOnSelect(dc, rc, cl);

 // adjust selection if required, selecting the operators which are
 // placed before completely selected monomials
 for (int a=gui_GetSelStart(), b=gui_GetSelEnd(); a < b; a++)
  if (data_Get(a).gui_isAllSelected())
   if (a > 0 && data_isOp(a-1))
    data_Get(a-1).gui_SelectAll();
}

int mcPolynomialHelpers::gui_AddNewElement(mcElementType type, const mcKey &key, int pos)
{
 //mcElementType m = mcMathCore::Get().isKeyBeginKey(key);
 if (pos == -1) pos = data_GetCount();

 // check we are going to add the right type of element !!!
 mcASSERT(type == mcET_MONOMIAL || type == mcET_ADDOP || type == mcET_SUBOP, 
  wxT("Cannot create something which is not a mcOperator or a mcMonomial !!!!"));
 mcElementArrayHelpers::gui_AddNewElement(type, key, pos);

 // check if we have added a new operator
 if (type == mcET_ADDOP || type == mcET_SUBOP) {
  if (pos == data_GetCount()-1 || data_isOp(pos+1)) {

   // handle the case:
   //     ... ab| ...     user creates a mcAddOp or a mcSubOp
   // which is also the case of:
   //     ... ab|+c ...   user creates a mcAddOp or a mcSubOp
   pos++;
   data_MoveElemRight(pos);
   gui_AddNewEmptyMonomial(pos);
   
  } else if (pos > 0 && data_isOp(pos-1)) {
   
   // handle the case:
   //    ... ab+|bc ...     user creates a mcAddOp or a mcSubOp
   //
   // In this case cursor must not be moved: it is
   // already placed on the new monomial !!!
   //
   data_MoveElemRight(pos);
   gui_AddNewEmptyMonomial(pos);

  } else if (pos == 0) {

   // handle the case:
   //        |ab+bc+cd ...  user creates a mcAddOp or a mcSubOp
   // 
   // In this case, we are going to add an operator in the
   // first position of the array !!!   
   pos++;
  }
 }

 gui_RecalcSize();
 return pos;
}

mcInputRes mcPolynomialHelpers::gui_Input(const mcKey &ev, mcElement *newelem)
{
 // in this function we must handle ONLY a special case: a mcAddSubOp
 // placed in the first entry of the array, thus working 
 // as unary operator.
 //
 // NOTE: if we are wrapping only a mcEmptyBox, then the mcCP_END and
 //       mcCP_BEGIN flags coincide: since we don't know what mcEmptyBoxes
 //       return as cursor position (the cursor can be placed only in a
 //       single position inside a mcEmptyBox and thus it does not make
 //       sense to refer to a leftmost or rightmost position)
 //
 if (gui_GetCursorPos().isBegin() || data_isWrappingOnly(mcET_EMPTYBOX)) {
  mcElementType n = mcElementHelpers::gui_isKeyBeginKey(ev);

  if (n == mcET_ADDOP || n == mcET_SUBOP) {

   bool replace = FALSE;

   // don't send this to the first (eventually present) monomial...
   // instead, add it at the beginning of the array (eventually
   // replacing a previously present first operator...)
   if (data_GetCount() > 0 && data_isOp(0))
    replace = TRUE;
   mcElement &e = data_AddNewElement(n, replace, 0);

   // need to recalc the size
   e.gui_RecalcSize();

   // do not forget the cursor set on a mcOperator...
   if (!replace) mgui_nCursorPos++;
   gui_CheckCursorPos();

   gui_RecalcSize();
   return mcIR_OKAY;
  }

 }

 // UNTESTED !!!
 mcElementType n = mcElementHelpers::gui_isKeyBeginKey(ev);
 if (n == mcET_PARENTHESIS)
  gui_OnNewParenthesis(mcBracketHelpers::gui_isLeftParenthesis(ev.GetKeyCode()));

 // let the base class function handle everything...
 mcInputRes r = mcElementArrayHelpers::gui_Input(ev, newelem);

 // this is a special routine for mcParenthesis
 if (mgui_bRemoveParenthesis) {
  data_ReplaceParentheses(!mgui_bMoveCursorAtBracketBegin);
  mgui_bRemoveParenthesis = FALSE;
  gui_DeepRecalcSize();
 }

 if (mgui_pBracketToReplace != mcEmptyElement) {
  gui_ReplaceBracket(mgui_pBracketToReplace, mgui_bRemoveLeftParenthesis);
  mgui_pBracketToReplace = NULL;
  gui_DeepRecalcSize();
 }

 return r;
}

mcInputRes mcPolynomialHelpers::gui_BackInput(const mcKey &key, mcElement *pnewelem, int n)
{
 int last;
 bool b;

 switch (n) {
 case mcIR_OKAY:
  break;

 case mcIR_REPLACE_THIS:
  if (mgui_nCursorPos == 0) {
   mcMathCore::Get()->SyntaxError(wxT("Cannot data_Delete this element"));
   return mcIR_OKAY;
  }

  // data_Delete the focused element & shift left to close the hole in the array
  data_Delete(mgui_nCursorPos);
  data_MoveElemLeft(mgui_nCursorPos);

  // close last hole with the new element overwriting the old one
  data_AddElements(pnewelem, 1, mgui_nCursorPos-1, TRUE);
  mgui_nCursorPos--;
  (*pnewelem) = NULL;

  // do not continue processing of other flags
  return mcIR_OKAY;

 case mcIR_DELETE_THIS:

  if (mgui_nCursorPos == 0 && data_GetCount() > 1) {
   // handle the case:
   //     __|__ + abc ...        user data_Deletes the empty box
   //
   return mcIR_DELETE_PREVIOUS;
  }
  
  // data_Delete the current monomial
  data_Delete(mgui_nCursorPos);
  data_MoveElemLeft(mgui_nCursorPos);
  
  if (mgui_nCursorPos > 0) {
   
   // data_Delete the + or - operator which precedes the data_Deleted monomial
   mcASSERT(data_isOp(mgui_nCursorPos-1), wxT("An operator was expected"));
   data_Delete(mgui_nCursorPos-1);
   data_MoveElemLeft(mgui_nCursorPos-1);
   mgui_nCursorPos--;
   
   // check if we have just data_Deleted the first operator of the array
   if (mgui_nCursorPos == 0) {
    
    // if we had an operator placed at the beginning of the array,
    // and the user want to data_Delete it when the cursor is placed
    // over the 
    data_MoveElemRight(0);
    gui_AddNewEmptyMonomial(0);
    return mcIR_OKAY;
   }
  }
  
  // move cursor left (this must be done AFTER the eventual
  // remotion of the previous operator !!!!)
  mgui_nCursorPos--;

  if (mgui_nCursorPos >= 0) {
   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);  
  }
  
  // was it the last monomial of the array (and was it containing 
  // an emptybox) ?
  if (data_isArrayEmpty())
   return mcIR_DELETE_THIS;  // the array is empty !!!
  break;

 case mcIR_DELETE_PREVIOUS:

  // the focused monomial asked us to data_Delete the previous element, which is
  // sure an operator + or -. This means that we must merge the focused
  // monomials with the previous one.
  
  if (mgui_nCursorPos == 0) {

   // cannot data_Delete the previous element because it doesn't exist !!!
   return mcIR_DELETE_PREVIOUS;
  }

  // what if the monomial asked to data_Delete the first operator in the array ?
  if (mgui_nCursorPos == 1) {
   
   // the user can see the first operator and he wants to data_Delete it;
   // we cannot data_Delete first operator but we can reset it to a +
   // and hid it...
   // the user will think that an operator does not exist anymore
   // but the appearances deceive... :-)
   mcASSERT(data_isOp(0), wxT("If the first element is not an operator, cursor")
    wxT("is acutally placed on an operator..."));
   data_Delete(0);
   data_MoveElemLeft(0);
   mgui_nCursorPos--;
   return mcIR_OKAY;
  }

  // merge the two monomials
  b = mcMonomial(data_Get(mgui_nCursorPos-2)).gui_MergeWith(data_Get(mgui_nCursorPos));
  mcASSERT(b, wxT("Two monomials should always be able to merge..."));

  // data_Delete the old monomial and its operator
  data_Delete(mgui_nCursorPos-1);
  data_Delete(mgui_nCursorPos);
  data_MoveElemLeft(mgui_nCursorPos);
  data_MoveElemLeft(mgui_nCursorPos-1);

  // move cursor to the monomial
  mgui_nCursorPos -= 2;

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

 case mcIR_DELETE_NEXT:
    
  // the focused monomial asked us to data_Delete the next element, which is
  // sure an operator + or -. This means that we must merge the focused
  // monomials with the next one.

  last = data_GetCount()-1;
  if (mgui_nCursorPos == last) {

   // no elements following...
   return mcIR_DELETE_NEXT;
  }

  // cursor check
  mcASSERT(mgui_nCursorPos < last-1, wxT("If the monomial cannot end with an operator ")
    wxT("and the cursor is not on the last monomial, it must be placed ")
    wxT("on the previous monomial, which should be at data_GetCount()-2"));

  // merge the two monomials
  b = mcMonomial(data_Get(mgui_nCursorPos)).gui_MergeWith(data_Get(mgui_nCursorPos+2));
  mcASSERT(b, wxT("Two monomials should always be able to merge..."));
  mcUNUSED(b);

  // data_Delete the old monomial and its operator
  data_Delete(mgui_nCursorPos+1);
  data_Delete(mgui_nCursorPos+2);
  data_MoveElemLeft(mgui_nCursorPos+1);
  data_MoveElemLeft(mgui_nCursorPos+1);

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

 case mcIR_DISTRIBUTE:
  mcASSERT(pnewelem != NULL && *pnewelem != mcEmptyElement, 
   wxT("No element to distribute !!"));

  if (pnewelem->data_GetType() == mcET_BRACKET) {

   // this is the case when the user tries to delete the right
   // or left parenthesis of a mcBracket element...
   bool left = ((const mcBracket *)pnewelem)->hlp()->mgui_bRemoveLeftBracket;
   gui_SetBracketToReplace(*pnewelem, left);
  }
  break;

 default:
  mcASSERT(0, wxT("Unhandled return flag"));
 }

 return mcIR_OKAY;
}

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

 //if (cp.isInside() || cp.isBeginEnd()) {
  
  mcInsertRes r = data_Get(mgui_nCursorPos).gui_Insert(toinsert, NULL);

 /* switch (r) {
  case mcINSR_OKAY:
   return mcINSR_OKAY;

  case mcINSR_REPLACE_THIS:
   break;
  }
 }*/

 return mcINSR_OKAY;

 /*if (toinsert.data_GetType() != mcET_POLYNOMIAL)
  return data_Get(mgui_nCursorPos).gui_Insert(toinsert, NULL);
*/
 return mcINSR_OKAY;
}

void mcPolynomialHelpers::gui_SetCursorPos(const mcCursorPos &code)
{
 // do not use default mcElementArrayHelpers::gui_SetCursorPos: it works for the
 // all the elements without doing any distinction between operators and
 // non operators elements: we need mcElementArrayHelpers::gui_SetCursorPosSkippingOp()...
 mcElementArrayHelpers::gui_SetCursorPos/*SkippingOp*/(code);
}

void mcPolynomialHelpers::gui_CheckCursorPos() const
{
 // check that cursor is not beyond upper and lower limit
 if (data_GetCount() > 0) {

  // cursor position must be a valid integer in the range 0, data_GetCount()-1
  mcASSERT(data_isValidElem(mgui_nCursorPos), 
    wxT("Cursor placed on an invalid element !"));
  mcASSERT(mgui_nCursorPos >= 0, 
    wxT("Cursor position undefined"));
  mcASSERT(mgui_nCursorPos < data_GetCount(), 
    wxT("Cursor position is beyond upper limit"));

  mcASSERT(!data_Get(mgui_nCursorPos).gui_GetCursorPos().isUndefined(),
     wxT("Cursor position undefined"));

 } else {

  // array is empty; cursor position should be 0
  mcASSERT(mgui_nCursorPos == -1, wxT("Array is empty, wrong cursor position"));
 }
 
 // check that cursor is not inside an operator
 if (!data_isArrayEmpty()) {
  mcASSERT(!data_isEmptyEntry(mgui_nCursorPos), wxT("Cursor position is wrong"));
  mcASSERT(!data_isOp(mgui_nCursorPos), wxT("Cursor position is wrong"));
 } 
}

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

 mcASSERT(type == mcET_ADDOP || type == mcET_SUBOP, 
  wxT("The splitter elements can be only mcAddOp or mcSubOp"));

 // split the element in two parts; by now, this function
 // can be used only by mcNumbers & mcMonomials...
 bool b = data_Get(mgui_nCursorPos).gui_Split(&ptmp);
 mcASSERT(!b, wxT("A monomial asked us to be deleted ?"));
 mcUNUSED(b);  // to avoid warnings
 
 // 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 and fill it with the second part of
 // the splitted monomial
 data_MoveElemRight(mgui_nCursorPos+1);
 data_Set(mgui_nCursorPos+1, ptmp);
 
 // create another hole between the old and the new monomial
 data_MoveElemRight(mgui_nCursorPos+1);
 
 // and fill it with the splitter operator
 data_AddNewOp(type, mgui_nCursorPos+1);
 
 // adjust cursor on the new monomial
 mgui_nCursorPos +=2;
}

int mcPolynomialHelpers::data_AddNewEmptyMonomial(int pos)
{
 // this function uses the begin key of a mcEmptyBox to create
 // the new empty monomial: in this way we can use all the
 // GUI input rules encoded in mcPolynomialHelpers::gui_math_AddNewElement 
 // for free....
 if (pos == -1) pos = data_GetCount();

 // add a new monomial containing only an empty box
 mcMonomial m;  // create a new
 mcElement &box = m.data_AddNewElement(mcET_EMPTYBOX);
 box.data_AddProperty(mcEP_INITIALIZED);

 data_AddElements(&m, 1, pos);
 data_Check();

 return pos;
}

void mcPolynomialHelpers::gui_AddNewEmptyMonomial(int pos)
{
 // this function uses the begin key of a mcEmptyBox to create
 // the new empty monomial: in this way we can use all the
 // GUI input rules encoded in mcPolynomialGUI::AddNewElement 
 // for free....
 mcKey fake(mcEmptyBoxHelpers::sgui_pNewEmptyBox->GetEvent(), TRUE);
 if (pos == -1) pos = data_GetCount();

 // add a new monomial containing only an empty box
 mgui_nCursorPos = gui_AddNewElement(mcET_MONOMIAL, fake, pos);
}







// ----------------------------------------
// mcPOLYNOMIALIO
// ----------------------------------------

wxXml2Node mcPolynomialHelpers::io_GetMathML(bool bdata_GetPresentation) const
{
 // if this mcPolynomial contains just one element, we can just return
 // the MathML piece of that element without using an MROW
 if (data_GetCount() == 1) {
  
  // too easy... :-)
  return data_Get(0).io_GetMathML(bdata_GetPresentation);
 }
  
 // begin MROW section
 wxXml2Node maintag;
 maintag.CreateTemp(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("mrow"));

 // for each monomial, also take in count its first operator
 for (int i=0; i < data_GetCount(); i++) {

  // THIS PIECE OF CODE SHOULD BE USED IF THE OPERATORS WHICH LINK
  // THE MONOMIALS ARE CONTAINED IN THE MONOMIAL'S ARRAY: THIS IS
  // NOT THE BEHAVIOUR OF THE CURRENT MATH'S STRUCTURE but I do not 
  // want to data_Delete this code because it could still be useful in
  // future !!!
  /* data_Get the + or - from this monomial
  mcElement p = ((mcMonomial &)data_Get(i))->data_Get(0);
  if (i != 0 || p.data_GetType() != mcET_OPERATOR || p->data_GetSubType() != mcET_ADDOP) {

   // it's really necessary to insert this operator....
   maintag.math_AddChild(p.io_GetMathML(bdata_GetPresentation));
  }*/

  // get the mrow section from this monomial
  wxXml2Node node(data_Get(i).io_GetMathML(bdata_GetPresentation));
  maintag.AddChild(node);
 }

 return maintag;
}

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

 // concatenate the inlined expressions which compose the math contents
 for (int i=0; i < data_GetCount(); i++) {
  
  // A LITTLE POLYNOMIAL-SPECIFIC BEHAVIOUR:
  // since the sign of a monomial is stored both in the monomial's
  // coefficient 
  wxString tmp = data_Get(i).io_GetInlinedExpr();
  //if (!data_isOp(i) && tmp.StartsWith("-")) tmp.Remove(0, 1);

  str += tmp;
 }


 return str;
}

bool mcPolynomialHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &err)
{
 wxXml2Node p, toinsert = wxXml2EmptyNode;
 //mcElement ptmp = NULL;
 //int res = mcIR_OKAY;

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

 p = tag.GetChildren();
 while (p != wxXml2EmptyNode) {
  
  if (p.GetType() == wxXML_ELEMENT_NODE && p.GetName() == wxT("mo")) {
   
   // this is an operator, like + or -, separing two monomials;
   // send it as init tag to the monomial
   toinsert = p;

  } else if (p.GetType() == wxXML_ELEMENT_NODE && p.GetName() != wxT("mrow")) {
   
   // mcMonomial requires everything to be encapsulated in an MROW,
   // but this monomial is not; let's do ourselves
   /*wxXml2Node tmp(wxXML_ELEMENT_NODE, wxT("mrow"));
   wxXml2Node *firstchild = new wxXml2Node(*p);
   tmp.data_SetChildren(firstchild);
   
     if (!pnew.io_ImportPresentationMathML(&tmp, err))
   return FALSE;*/
   p.Encapsulate(wxT("mrow"));
  }
  
  if (p.GetType() == wxXML_ELEMENT_NODE && p.GetName() == wxT("mrow")) {
   
   // create a new monomial to parse this node
   mcMonomial pnew;
   
   // adds the last MO child of the main tag if it was present
   if (toinsert != wxXml2EmptyNode) {
    p.GetChildren().AddPrevious(toinsert);
    toinsert = wxXml2EmptyNode;
   }
   
   // just a normal MROW representing a monomial...
   if (!pnew.io_ImportPresentationMathML(p, err))
    return FALSE;
   
   // add our new monomial in this array
   data_AddElements(&pnew, 1);
  }
  
  // proceed with next
  p = p.GetNext();
 }

 return TRUE;
}

bool mcPolynomialHelpers::io_ImportInlinedExpr(const wxString &todecode, int *c, 
            wxString &pErr, int mlimit)
{
 wxString token(todecode);
 int count, n = 0;

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

 while (!token.IsEmpty() && (mlimit < 0 || n < mlimit))
 {
  // now, check if we must add an operator...  
  wxString str = token.GetChar(0);  
  mcElementType newop = mcElementHelpers::io_isCharBeginChar(str);
  if (mcOperatorHelpers::data_isOp(newop)) {
   
   // add the operator and remove it from the token string
   data_AddNewElement(newop);
   token.Remove(0, 1);
   
  } else {
   
   // if this is not the first time this while() cycle has
   // been run and there is no operator to separe previously
   // imported monomial from the next one.... then there's a
   // BIG problem...
   mcASSERT(data_isArrayEmpty(), 
    wxT("A mcPolynomial must contain mcMonomials *always* ")
    wxT("interleaved with mcAddOp/mcSubOps"));   
  }
  
  // and add it to this array
  mcMonomial pnew;
  n++;

  // import a new monomial
  if (!pnew.io_ImportInlinedExpr(token, &count, pErr))
   return FALSE;
   
  // update the token string
  data_AddElements(&pnew, 1);
  token = token.Right(token.Len()-count);
 }

 // store the number of characters imported
 if (c) *c = todecode.Len()-token.Len();

 // a little exception for parentheses:
 // try to replace all mcParenthesis with mcBrackets... 
 mcIOLOG(wxT("mcPolynomialHelpers::io_ImportInlinedExpr - before pruning brackets: [%s]"), mcTXTTHIS);
 data_ReplaceAllParentheses();

 // remove all the mcParenthesis which could not be replaced with
 // mcBrackets....
 for (int i=0, max=data_GetNumOfElemType(mcET_MONOMIAL); i < max; i++) {
  mcMonomial &m = (mcMonomial &)data_GetElemOfType(i, mcET_MONOMIAL);

  // do the hard work...
  m.data_DeleteAllElemType(mcET_PARENTHESIS);
  m.data_Repair();
 }

 mcIOLOG(wxT("mcPolynomialHelpers::io_ImportInlinedExpr - after pruning brackets: [%s]"), mcTXTTHIS);

 // extra-work required ?
 io_PostProcessChildren();

 return TRUE;
}





// ----------------------------------------
// mcPOLYNOMIALMATH
// ----------------------------------------

mcPolynomial mcPolynomialHelpers::math_GetPolynomialWrapper() const
{
 mcPolynomial pol(this);

 // it is very important to detach pol from us:
 // we could modify ourselves, later and this would
 // result in an automatic modification of the polynomial
 // which we are returning now...
 pol.data_MakePrivateCopy();

 return pol;
}

mcArrayEntry mcPolynomialHelpers::math_WrapMonomial(const mcMonomial &mon)
{
 // TOTEST:
 data_DeleteAll();

 // just add the given monomial to this array
 int midx = data_AddElements((mcElement *)(&mon), 1); 

 // and return a reference to its entry in the array...
 data_Check();
 return mcArrayEntry(this, mcMAKEPOL_IDX(midx, 0));
}

mcArrayEntry mcPolynomialHelpers::math_WrapSimple(const mcElement &p)
{
 // we have to do just a little check...
 if (p.data_GetType() != mcET_MONOMIAL) {

  // create a monomial wrapper for the given element
  mcMonomial m;
  int idx = m.data_AddElements(&p, 1);

  // add the monomial to the array and then return a reference
  // not to the monomial we've added but to the element which
  // was wrapped into the monomial we wrapped...
  mcArrayEntry ret = math_WrapMonomial(m);
  ret.data_SetIdx((ret.mdata_idx << 16) | idx);  
  return ret;
 }

 // we don't need to wrap anything: it's already a mcMonomial...
 return math_WrapMonomial(mcMonomial(p));
}

mcElementArray mcPolynomialHelpers::math_CreateWrapperFor(const mcElement &toembed) const
{
 if (toembed.data_GetType() != mcET_MONOMIAL && 
  toembed.data_GetType() != mcET_POLYNOMIAL) {
  
  // before creating a mcPolynomial and adding to it "toembed" 
  // (as mcElementArrayHelpers::CreateWrapperFor does),
  // wrap "toembed" in a mcMonomial...
  mcMonomial tmp;
  tmp.math_WrapSimple(toembed);
  return mcElementArrayHelpers::math_CreateWrapperFor(tmp);
 }

 return mcElementArrayHelpers::math_CreateWrapperFor(toembed);
}

int mcPolynomialHelpers::math_DataToMathIdx(int dataindex) const
{
 // discard invalid cases
 data_CheckIndex(dataindex);
 if (data_isOp(dataindex)) // op are not mapped in math coord
  return -1;

 // using the shift we are sure that both 4/2 and 5/2 will give as result 2.
 // This is required when the array begins with an operator and thus
 // the given index can be odd and nonetheless referring to a mcMonomial...
 return (dataindex >> 1);
}

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

  mcMATHLOG(wxT("mcPolynomialHelpers::math_MathToDataIdx [%s] - ")
   wxT("invalid conversion required"), mcTXTTHIS);
  return -1;  // no conversion is possible
 }

 // Perform a quick conversion taking in count the rule which 
 // is respected in each valid mcPolynomial: between two monomials
 // there is *always* a mcAddOp/mcSubOp which divides them.
 // Also takes in count that the operator may contain an operator
 // as first entry which could alter the formula...
 return mathindex*2 + (int)(data_isOp(0));
}









// ------------------------------------
// mcPOLYNOMIALMATH - sign management
// ------------------------------------

int mcPolynomialHelpers::math_GetSign(int n) const
{
 // get the index of the n-th monomial
 n = math_MathToDataIdx(n);
 mcASSERT(n != -1, wxT("Invalid index !!"));
 
 // if there is no operator at the begin of the array, it's by default +.
 if (n == 0) return 1;
 mcASSERT(data_isAddSubOp(n-1),
  wxT("A polynomial must contain monomials always separated by mcAddOp or mcSubOp"));
 
 return (data_Get(n-1).data_GetType() == mcET_ADDOP) ? 1 : -1;
}

void mcPolynomialHelpers::math_SetSign(int n, int sgn)
{
 int i = math_MathToDataIdx(n);
 
 if (i > 0) {
  
  // we are sure that the i-th monomial is not the first
  // element of the array: an operator is sure preceding it...
  mcASSERT(data_isOp(i-1), wxT("A monomial should always be preceded by an op"));
  
  // change the previous operator
  data_AddNewOp(((sgn < 0) ? mcET_SUBOP : mcET_ADDOP), i-1);
  
 } else {
  
  if (sgn < 0) {

   // add a new mcSubOp operator at the beginning of the array
   data_MoveElemRight(0);
   data_AddNewOp(mcET_SUBOP, 0);
   //mcMATHLOG("[%s]", mcTXTTHIS);
   
  } else {
   
   // we should add a mcAddOp at the beginning of the array:
   // quite useless; just do nothing
  }
 }
}
bool mcPolynomialHelpers::math_DeleteFirstOp()
{
 if (data_isArrayEmpty() || 
  !data_isOp(0))
  return FALSE;   // there is no first operator
 
 if (data_isOp(0) && 
  data_Get(0).data_GetType() != math_GetNeutralOpType())
  return FALSE;   // nothing to delete/that can be deleted

 // the first element of the array is a mcAddOp; we can safely remove it
 data_Delete(0);
 data_MoveElemLeft(0);
 return TRUE;
}

mcExpSimRes mcPolynomialHelpers::math_Reorder()
{
 mcMATHLOG(wxT("mcPolynomialHelpers::math_Reorder - going to reorder [%s]"), mcTXTTHIS);

 // we need to have an array containing *everywhere*
 // the pattern OPERATOR + MONOMIAL: the ReorderElements function
 // cannot work with variable-lenght patterns...
 data_CreateFirstOp();
 int n = math_ReorderElements(data_GetArray(), data_GetCount(), 1, 2);
 data_Check();

 // eventually remove the first operator we were forced to add
 math_DeleteFirstOp();
 mcMATHLOG(wxT("mcPolynomialHelpers::math_Reorder - result is [%s]"), mcTXTTHIS);
 
 // did we moved anything ?
 return (n == 0 ? mcESR_DONE : mcESR_NOTFINISHED);
}

void mcPolynomialHelpers::math_ChangeAllSigns()
{
 for (int i=0; i < math_GetCount(); i++)
  math_ChangeSign(i);
}

void mcPolynomialHelpers::math_SyncCoeffWithSigns()
{
 // scan the array resetting signs
 for (int i=0,max=math_GetCount(); i < max; i++) {

  mcRealValue coeff = math_Get(i).math_GetCoeff();
  
  if (coeff < 0) {

   // since the coefficient of the monomial is negative,
   // we must change not only the mcOperator in front of it,
   // but also its coefficient...
   math_SetSign(i, -1);  // this changes the operator before the monomial
   //math_Get(i).math_Abs();

   mcMATHLOG(wxT("mcPolynomialHelpers::math_SyncCoeffWithSigns - I set ")
    wxT("the sign of the [%s] monomial (which has coeff [%s]) to NEGATIVE"), 
    mcTXT(math_Get(i)), mcTXTV(coeff));

  } else if (coeff > 0) {

   // the coeff of the monomial is positive
   math_SetSign(i, +1);  // this changes the operator before the monomial   

   mcMATHLOG(wxT("mcPolynomialHelpers::math_SyncCoeffWithSigns - I set ")
    wxT("the sign of the [%s] monomial (which has coeff [%s]) to POSITIVE"), 
    mcTXT(math_Get(i)), mcTXTV(coeff));

  } else {

   // the coeff of the monomial is exactly zero...
   // do nothing since this monomial is useless
  }
 }
}

const mcNumber &mcPolynomialHelpers::math_GetNumSign(const mcMonomial &tofind, int n) const
{
 int pos = math_NonRecursiveFindInChildren(n, tofind.hlp());
 if (pos < 0) return mcEmptyNumber;

 // we've found the given monomial, now gets its sign
 int sign = math_GetSign(pos);
 return (sign == 1 ? *mcNumberHelpers::smath_pOne : *mcNumberHelpers::smath_pMinusOne);
}

void mcPolynomialHelpers::math_PackSign(mcMonomial &m, int occ) const
{
#ifdef EXTENDED_COEFF
 mcMonomial num = m.math_GetCoeff();
#else
 mcNumber num = m.math_GetCoeff();
#endif
 mcNumber mult = math_GetNumSign(m, occ);
 mcASSERT(mult != mcEmptyElement, wxT("We could not find 'm'"));

 num.math_SimpleMultiplyBy(mult);
 m.math_SetCoeff(num);
}





// ---------------------------------------
// mcPOLYNOMIALMATH - monomial management
// ---------------------------------------

int mcPolynomialHelpers::math_FindMonomialContaining(const mcElement &elem, 
              int occ, int *res) const
{
 int n = -1;
 for (int i=0,max=math_GetCount(); i < max; i++) {
  
  // search, non-recursively, in this monomial
  n = math_Get(i).math_GetIndexOf(occ, elem);
  if (n != -1) {

   // so we need to store the entry of the element we've found ?
   if (res) *res = n;
   return i;
  }
 }

 // could not find any result
 return -1;
}

const mcMonomial &mcPolynomialHelpers::math_GetMonomialContaining(const mcElement &elem, 
                 int occ, int *res) const
{
 int idx = math_FindMonomialContaining(elem, occ, res);

 if (idx != -1)
  return math_Get(idx);
 return mcEmptyMonomial;
}

mcMonomial mcPolynomialHelpers::math_GetCoeffOf(int mathidx, const mcElement *toremove, 
            int ntoremove) const
{
 // data_Get a copy of the monomial...
 mcMonomial res = math_Get(mathidx);

 // ...remove all the elements required from the copy
 for (int i=0; i < ntoremove; i++)
  res.math_Delete(0, toremove[i], FALSE);

 // and pack the sign of the monomial inside it if it's required
 if (math_GetSign(mathidx) == -1) math_PackSign(res);

 return res;
}

mcMonomial mcPolynomialHelpers::math_GetCoeffOf(const mcSymbolProperties *sym, 
           const mcPolynomial &exp, int occ) const
{
 mcMATHLOG(wxT("mcPolynomialHelpers::math_GetCoeffOf [%s] - searching [%s]^[%s]"),
    mcTXTTHIS, mcTXTP(sym), mcTXT(exp));

 // create a temporary object linked to the given symbol
 // and with the given exponent
 mcSymbol s(sym->data_GetSafeLinkedSym());

 if (exp.math_isWrappingOnly(0.0)) {

  int n = -1;

  // search the zero-degree term
  for (int i=0; i < math_GetCount(); i++) {
   if (!math_Get(i).math_Contains(s)) {

    n++;

    // copy this monomial, which should be the only
    // one not to contain the given symbol,
    if (n == occ) return mcMonomial(math_Get(i));
   }
  }

  return mcEmptyMonomial;
 }

 s.math_SetExp(exp);

 // then, find it 
 int n = -1;
 const mcMonomial &res = math_GetMonomialContaining(s, occ, &n);
 if (res == mcEmptyMonomial) return mcEmptyMonomial;

 // copy it (don't modify the array !!)
 mcMonomial m(res);

 // we could use data_GetCoeffOf in this way:
 // mcMonomial &ret = data_GetCoeffOf(pos, (const mcElement &*)&s, 1);
 // mcSAFE_data_Delete(s);
 // but since we already know where s is placed (at n-th pos), proceed
 // without using the other data_GetCoeffOf (and repeating some code):
 m.math_Remove(n, FALSE);

 //if (m.math_math_GetSign() == -1) PackSign(m);
 //mcASSERT(0, "");

 return m;
}

mcMonomial mcPolynomialHelpers::math_GetCoeffOf(const mcSymbolProperties *sym, 
            const mcRealValue &exp, int occ) const
{
 mcPolynomial tmp;
 tmp.math_WrapNumber(exp);

 // data_Get a copy of the monomial and remove the symbol we've just found
 mcMonomial ret = math_GetCoeffOf(sym, tmp, occ);
 //mcSAFE_data_Delete(tmp);

 return ret;
}

mcIntegerValue mcPolynomialHelpers::math_GetMaxDegreeFor(const mcSymbolProperties *sym) const
{
 mcIntegerValue max = 0;

 for (int i=0; i < math_GetCount(); i++) {
  
  // collect the max degree for this symbol from the i-th monomial
  mcIntegerValue d = math_Get(i).math_GetMaxDegreeFor(sym);
  if (!d.isValid()) return *mcIntegerValue::pNAN;

  // and check it against the max degree for all previous monomials
  max = max.GetMax(d);
 }

 mcASSERT(max.isValid(), wxT("Something really wrong"));
 return max;
}

mcExpSimRes mcPolynomialHelpers::math_SimplifySolveOp(long flags)
{
 bool stilltowork = FALSE;

 mcMATHLOG(wxT("mcPolynomialHelpers::math_SimplifySolveOp"));

 // cannot store data_GetCount()-1 because elements maybe removed in the loop
 for (int i=0; i < math_GetCount(); i++) {
  
  // get left operand
  mcMonomial &left = math_Get(i);
  mcOperator &lp = math_GetOpPreceding(i);
  
  for (int j=0; j < math_GetCount(); j++) {

   // get right one
   mcMonomial &right = math_Get(j);
   if (i == j) continue;
   
   // get the i-th operator of the array
   mcOperator &rp = math_GetOpPreceding(j);
   if (rp == mcEmptyElement) continue;
   mcMATHLOG(wxT("mcPolynomialHelpers::math_SimplifySolveOp - I'm trying to apply ")
    wxT("the op [%s] between the [%s] and [%s] elements"), 
    mcTXT(rp), mcTXT(left), mcTXT(right));

   // apply the op
   mcElement rep = mcEmptyElement;
   mcBasicOpRes res;
   int sign=1;
   
   if (lp.data_GetType() == rp.data_GetType()) {

    mcOperator *op = (mcOperator *)mcElementHelpers::data_GetInstanceOf(mcET_ADDOP);
    res = op->math_Apply(left, right, &rep);
    if (res == mcBOR_INVALID)
     continue;

   } else {

    mcOperator *op = (mcOperator *)mcElementHelpers::data_GetInstanceOf(mcET_SUBOP);
    res = op->math_Apply(left, right, &rep);
    if (lp.data_GetType() == mcET_SUBOP)
     sign=-1;
    if (res == mcBOR_INVALID)
     continue;

    // set the monomial's sign accordingly to the
    // result of the ADD/SUBTRACT operation and
    // accordingly with the sign of the monomial
    // before the operation
    if (left.math_GetCoeff() < 0) {
     math_SetSign(i, -1*sign);
     math_Get(i).math_Abs();
    } else {
     math_SetSign(i, 1*sign);
    }
   }
   
   // the operator could be applied...
   stilltowork = TRUE;
   mcMATHLOG(wxT("mcPolynomialHelpers::math_SimplifySolveOp - applied ")
    wxT("the op [%s] between the [%s] and [%s] elements"), 
    mcTXT(rp), mcTXT(left), mcTXT(right));
   
   // handle res
   math_HandleBasicOpRes(res, rep, j);
  }
 }

 if (stilltowork)
  return mcESR_NOTFINISHED;
 return mcESR_DONE;
 //return mcElementArrayHelpers::math_SimplifySolveOp(flags);
}

mcExpSimRes mcPolynomialHelpers::math_Simplify(long flags, mcElement *newelem)
{
 mcLOG(wxT("mcPolynomialHelpers::math_Simplify"));
 
 // perform array simplification 
 mcExpSimRes r = mcElementArrayHelpers::math_Simplify(flags, newelem);
 math_DeleteFirstOp();
 if (r != mcESR_DONE) return r;
 
 // additional simplification step:
 //if (math_DeleteFirstOp())  // remove the first op when it's useless (+)
 // return mcESR_NOTFINISHED; 

 // additional simplification step #2:
 //math_FactoreOut();
  
 return mcESR_DONE;  // there was no first operator to data_Delete...
}





// ---------------------------------------
// mcPOLYNOMIALMATH - basic operations
// ---------------------------------------

mcBasicOpRes mcPolynomialHelpers::math_Add(const mcElement &e, mcElement *pp, bool add)
{
 mcMATHLOG(wxT("mcPolynomialHelpers::math_Add [%s] - I'm %s [%s]"), mcTXTTHIS, 
  (add == TRUE ? wxT("adding") : wxT("subtracting")), mcTXT(e));
 mcPolynomial p(e);
 
 if (p.data_isArrayEmpty())
  return mcBOR_REMOVE_OPERAND;
 
 if (add) {

  // don't force the creation of the "+" operator if this array is empty
  // or if the given array already has a first op...
  if (!this->data_isArrayEmpty() &&
   !p.data_isOp(0)) {
   
   data_AddNewOp(mcET_ADDOP);
  }
  
  // now we can merge with the given polynomial
  data_Merge(p);
  
 } else {
  
  mcPolynomial p2(p);
  
  // a - b = a + (-b) .....
  p2.math_ChangeAllSigns();
  mcMATHLOG(wxT("[%s]"), mcTXT(p2));
  math_SimpleAdd(p2);
 }
 
 data_Check();
 
 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcPolynomialHelpers::math_MultiplyBy(const mcElement &e, mcElement *pp)
{
 if (data_isArrayEmpty())
  return mcBOR_REMOVE_OPERAND;

 mcPolynomial p(e);
 mcPolynomial pnew = mcEmptyElement;

 // if this array contains more than one monomial,
 // or just a negative element, bracket it.
 if (math_GetCount() > 1 || math_GetSign(0) == -1) {
  
  // bracketize everything
  mcElementArrayHelpers::math_EmbedInBracket();
 }

 // if the given array to multiply contains more than one 
 // monomial, bracket a copy of it
 if (p.math_GetCount() > 1) {

  // we cannot modify the given element !!!!
  pnew = p;
  p = pnew;

  // bracket the copy of the given array
  p.math_EmbedInBracket();
  //p.math_data_DeleteFirstOp();
 }

 // now, both the operands contains one monomial only....
 mcASSERT(p.math_GetCount() == 1, wxT("Something wrong"));
 mcASSERT(this->math_GetCount() == 1, wxT("Something wrong"));

 // ... and we can now multiply them
 mcBasicOpRes r = math_Get(0).math_MultiplyBy(p.math_Get(0), pp);

 // clean up if necessary
 //if (pnew) data_Delete pnew;

 // check that everything is okay
 data_Check();

 // handle the returned flag....
 switch (r) {
 case mcBOR_INVALID:
 case mcBOR_REPLACE_OPERAND:
 case mcBOR_REPLACE_BOTH:
  mcASSERT(0, wxT("Two monomials which cannot be multiplied ?"));

 case mcBOR_REMOVE_OPERAND:
  return mcBOR_REMOVE_OPERAND;

 default:
  mcASSERT(0, wxT("TODO"));
 }

 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcPolynomialHelpers::math_DivideBy(const mcElement &pol, mcElement *pp)
{
 if (data_isArrayEmpty())
  return mcBOR_REMOVE_OPERAND;

 // create a fraction with the current contents as numerator,
 // the given polynomial as denominator
 mcASSERT(pol.data_GetType() == mcET_POLYNOMIAL, wxT("see math_DivideBy() description..."));
 math_EmbedInFraction().data_GetFraction().data_SetDen(pol);

 mcMATHLOG(wxT("mcPolynomialHelpers::math_DivideBy - dividing by [%s], result is [%s]"),
    mcTXT(pol), mcTXTTHIS);

 return mcBOR_REMOVE_OPERAND;
}






// ---------------------------------------
// mcPOLYNOMIALMATH - miscellaneous
// ---------------------------------------

/*
mcElement mcPolynomialHelpers::math_GetLCM(const mcElement &p) const
{
 // work on copies
 mcPolynomial b(p);
 b.math_EmbedInBracket();

 math_SimpleMultiplyBy(b);
 //data_Delete b;

 return b;
}
*/

void mcPolynomialHelpers::math_DeleteSelection()
{
 // data_Delete the elements selected
 gui_DeleteSelection();
 data_Check();
}

mcIntegerValue mcPolynomialHelpers::math_RaiseGetCoeff(int *indexes, int m)
{
 mcIntegerValue res = 1;
 
 // we must calculate the coefficient in this way:
 //
 //  ( indexes[0] ) ( indexes[1] ) ( indexes[2] )  
 //  (            ) (            ) (            ) ....
 //  ( indexes[1] ) ( indexes[2] ) ( indexes[3] ) 
 //
 for (int x=0; x < m; x++)
  res *= mcIntegerValue::GetComb(indexes[x], indexes[x+1]);
 
 return res;
}

bool mcPolynomialHelpers::math_CanBeRaisedTo(const mcPolynomial &pol) const
{
 int count = math_GetCount();

 // see mcPolynomialHelpers::math_RaiseChildrenTo about
 // the way these cases are handled
 if (count == 0 || count == 1)
  return TRUE;

 // for more children, then we need that the given exponent
 // contains just a number
 if (!pol.math_isWrappingNumOnly())
  return FALSE;

 mcRealValue r(pol.math_GetWrappedNumber());

 if (r.isInteger())
  return TRUE;
 return FALSE;
}

void mcPolynomialHelpers::math_RaiseTo(const mcRealValue &r)
{
 mcMATHLOG(wxT("mcPolynomialHelpers::math_RaiseChildrenTo [%s] - raising to [%s]"),
    mcTXTTHIS, mcTXTV(r));
 mcIntegerValue n = r;

 // first of all, handle the simplest cases
 if (math_GetCount() == 0) 
  return;   // no elements to modify

 if (math_GetCount() == 1) {

  // we contain only a single monomial:
  // (a)^1432.4432423[...] = a^1432.4432423[...]
  math_Get(0).math_RaiseTo(r);
  return;
 }

 // then, check if the given value is okay
 if (!r.isInteger()) {

  // we are in such a situation:
  //     (a+b+c+d+...z)^1432.4432423[...]
  // that is, we cannot raise this polynomial to a real value:
  // we can just bracketize the polynomial and set that value
  // as the exponent of the bracket...
  math_EmbedInBracketAndRaiseTo(r);
  return;

 } else if (n == 1) {

  // we are raising something to one...
  // (a+b+c+...)^1 = a+b+c+...
  return;
 }

 mcMATHLOG(wxT("mcPolynomialHelpers::math_RaiseTo - raising %d monomials to %s"),
          math_GetCount(), n.GetStr().c_str());
 int x, m = math_GetCount(), *indexes = new int[m+2];
 
 // first index must be n, last must be zero
 // (like also all other indexes, even if these ones
 // will be incremented at the end of the while cycle)
 indexes[0] = n.GetInt();
 for (x=1; x < m+2; x++)
  indexes[x] = 0;
 
 mcPolynomial res;
 bool exit = FALSE;
 int level = 1;
 while (!exit) {
  
  mcMonomial mx;

  // this is the sign of the "mx" monomial: 1=+   -1=-
  int sign = 1;
  
  // calc the coeff for this new monomial through the
  // formula explained in the "Formulas & Algorithms used"
  // section in the docs
  mcIntegerValue coeff = math_RaiseGetCoeff(indexes, m);
  mx.math_WrapNumber(coeff);
  mcMATHLOG(wxT("mcPolynomialHelpers::math_RaiseTo - the coeff of the %d-th monomial is %s"),
      res.math_GetCount(), coeff.GetStr().c_str());
  for (int y=0; y < m; y++) {
   
   // get the y-th monomial of *this
   mcMonomial tmp(math_Get(y));
   
   // raise it (update global monomial sign)
   int exp = indexes[y]-indexes[y+1];

   // do not create a lot of a^0, b^0 and...
   if (exp != 0) {

    // ... do not create a lot of a^1, b^1 (create a, b)
    if (exp != 1) tmp.math_RaiseTo(mcPolynomial(exp));
    sign *= (int)pow(math_GetSign(y), exp);

    // and add it to the new polynomial we are building
    mx.math_MultiplyBy(tmp, NULL);
   }
  }
  
  res.math_SimpleAdd(mx, (sign == 1 ? TRUE : FALSE));
  
  // advance indexes 
  if (level < m) {
   
   // advance index level
   indexes[level]++;
   if (level+1 < m || indexes[level] == indexes[level-1])
    level++;

  } else if (level == m) {
   
   // reset those levels which have been completed
   level--;
   bool startcycle = FALSE;
   while (indexes[level-1] <= indexes[level]) {
    indexes[level] = 0;
    level--;
    startcycle = TRUE;
    
    if (level == 0) {
     
     // we have completed the
     // outermost cicle and thus
     // we have done our duty
     exit = TRUE;
     break;
    }
   }
   
   // ok, we can start a new cycle at a new level
   if (startcycle) {
    indexes[level]++;
    level++;
   }
  }
 }

 delete indexes;
 data_DeepCopy(res.chlp());
}

mcBasicOpRes mcPolynomialHelpers::math_RaiseTo(const mcPolynomial &p)
{
 if (math_CanBeRaisedTo(p)) {

  if (math_GetCount() == 0) 
   return mcBOR_REMOVE_OPERAND;  // no elements to modify

  if (math_GetCount() == 1)
   return math_Get(0).math_RaiseTo(p);

  // unwrap the number contained in the given polynomial and
  // raise everything to it...
  math_RaiseTo(p.math_GetWrappedNumber());
  return mcBOR_REMOVE_OPERAND;
 }

 // cannot do anything else...
 math_EmbedInBracketAndRaiseTo(p);
 return mcBOR_REMOVE_OPERAND;
}
/*
void mcPolynomialHelpers::math_Bracketize(int *n, int count)
{ 
 mcBracket br;

 int max = math_GetCount();
 for (int i=0; i < count; i++) {

  mcASSERT(n[i] < max, wxT("Invalid index"));
 
  // collect this monomial
  mcMATHLOG(wxT("mcPolynomialHelpers::math_Factorize - factorizing [%s]"), mcTXT(math_Get(n[i])));
  bool add = (math_GetSign(n[i]) == 1 ? TRUE : FALSE);
  br.data_GetContent().math_SimpleAdd(math_Get(n[i]), add);  
 }

 // now remove those monomials added to the bracket
 for (int j=0; j < count; j++) {

  mcMATHLOG(wxT("mcPolynomialHelpers::math_Factorize - removing [%s]"), mcTXT(math_Get(n[j]-j)));

  // we need to offset this index by j since each time we remove
  // a monomial all the other ones are shifted left
  math_Remove(n[j]-j);
 }

 // add the bracket to replace them
 math_SimpleAdd(br);
}*/
/*
mcMonomial mcPolynomialHelpers::math_GetFactors() const
{
 mcPolynomial res;

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

 return res;
}
*/
void mcPolynomialHelpers::math_Factorize(int *n, int count)
{

}

mcMonomial mcPolynomialHelpers::math_GetGCDFor(int *n, int count) const
{
 mcMonomial gcd(mcEmptyElement);
 bool all = FALSE;

 if (math_GetCount() == 0)
  return mcEmptyElement;

 if (count==-1) { 

  // we want to get the GCD among *all* the monomials
  count = math_GetCount(); 
  all = TRUE;

  // take initially as the GCD of the array the first monomial... 
  gcd = math_Get(0);

 } else {

  // get as GCD the first given index
  mcASSERT(count >= 1, wxT("Invalid count of elements"));
  gcd = math_Get(n[0]);
 }

 for (int i=1; i<count; i++) {

  mcMonomial m(mcEmptyElement);
  if (all)
   m = math_Get(i);
  else
   m = math_Get(n[i]);
 
  // ... then compute the GCD between the first (i-1)-th already
  // processed monomials and the i-th
  gcd = gcd.math_GetGCD(m);
 }

 return gcd;
}

void mcPolynomialHelpers::math_FactoreOut(int *n, int count, bool bForceUseless)
{
 // we need at least two monomials...
 if (math_GetCount() <= 1) return;

 // we've got the GCD for all the monomials of the array:
 // we should do nothing if it is 1.0
 mcMonomial gcd(math_GetGCDFor(n, count));
 bool gcdisone = gcd.math_isWrappingOnly(1.0);
 if (gcdisone && !bForceUseless)
  return;
 mcMATHLOG(wxT("mcPolynomialHelpers::math_FactoreOut - the GCD ")
    wxT("among all my monomials is [%s]"), mcTXT(gcd));

 // BEFORE:
 //                a + b + c + d ...
 // AFTER:
 //         n*(a/n + b/n + c/n + d/n ...)
 //
 // where n = GCD(a,b,c,d,...)
 // 
 mcArrayEntry br = math_EmbedInBracket(n, count);
 mcPolynomial &contents = br.data_GetBracket().data_GetContent();

 if (gcdisone || contents.math_GetCount() <= 1)
  return;
 
 // divide _all_ bracket's monomials by the GCD we've computed...
 for (int j=0,max=contents.math_GetCount(); j<max; j++)
  contents.math_Get(j).math_SimpleDivideBy(gcd); 

 // last touch: the factor we've just created must
 // multiply the bracket.
 mcMonomial &m = (mcMonomial &)math_GetMonomialContaining(br.data_GetRef());
 m.math_SimpleMultiplyBy(gcd);

 data_Check();
}

void mcPolynomialHelpers::math_FactoreOut(const mcSymbolProperties *unk,
            const mcPolynomial &pol,
            bool bForceUseless)
{
 // stop here and avoid a lot of calculus if we contain a single monomial...
 if (math_GetCount() <= 1) return;

 // we'll create an array as large as this array so we are
 // sure that we won't need to extend it...
 int *arr = new int[math_GetCount()];
 int count=0;

 // fill the array with the indexes of those monomials containing
 // the given symbol...
 for (int i=0,max=math_GetCount(); i < max; i++)
  if (math_Get(i).math_ContainsSymbol(unk, pol))
   arr[count++] = i;

 // then, just factore out everything possible from those monomials...
 if (count == 0) {
  delete [] arr;
  return;  // no such symbol found
 }

 math_FactoreOut(arr, count, bForceUseless);
 delete [] arr;
}

void mcPolynomialHelpers::math_FactoreOutFreeOf(const mcSymbolProperties *unk,
            const mcPolynomial &pol,
            bool bForceUseless)
{
 // stop here and avoid a lot of calculus if we contain a single monomial...
 if (math_GetCount() <= 1) return;

 // we'll create an array as large as this array so we are
 // sure that we won't need to extend it...
 int *arr = new int[math_GetCount()];
 int count=0;

 // fill the array with the indexes of those monomials containing
 // the given symbol...
 for (int i=0,max=math_GetCount(); i < max; i++)
  if (!math_Get(i).math_ContainsSymbol(unk, pol))
   arr[count++] = i;

 // then, just factore out everything possible from those monomials...
 if (count == 0) {
  delete [] arr;
  return;  // no such symbol found
 }

 math_FactoreOut(arr, count, bForceUseless);
 delete [] arr;
}

void mcPolynomialHelpers::math_FactoreOut(const mcSymbolArray *arr)
{
 // just factore out all the symbols contained in the given array
 for (int i=0; i < arr->data_GetCount(); i++)
  math_FactoreOut(arr->data_GetSymbol(i), mcEmptyPolynomial, FALSE);
}

void mcPolynomialHelpers::math_FactoreOutConstants()
{ math_FactoreOut(&mcSymbol::arrConstants); }

void mcPolynomialHelpers::math_FactoreOutUnknowns()
{ math_FactoreOut(&mcSymbol::arrUnknowns); }

void mcPolynomialHelpers::math_FactoreOutParameters()
{ math_FactoreOut(&mcSymbol::arrParameters); }

mcExpSimRes mcPolynomialHelpers::math_HandleExpSimFlag(mcExpSimRes r, mcElement *pnew, int i)
{
 // only mcPolynomials can handle this flag...
 if (r == mcESR_DISTRIBUTE) {

  mcMonomial &m = (mcMonomial &)data_Get(i);
  int pnewidx = m.data_GetIndexOf(*pnew);

  // this is a flag returned only by a few elements: handle it with
  // some specialized code...
  if (pnew->data_GetType() == mcET_BRACKET)
   math_DistributeBracket(i, pnewidx);
  else {

   // we have specialized code for this case but this
   // one is missing....
   mcASSERT(0, wxT("Unhandled case..."));
  }

  return mcESR_NOTFINISHED;
 }

 // only mcPolynomials can handle this flag...
 if (r == mcESR_CHANGE_SIGN) {

  math_ChangeSign(math_DataToMathIdx(i));
  return mcESR_NOTFINISHED;
 }

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

void mcPolynomialHelpers::math_DistributeBracket(int mdataidx, int bridx)
{
 mcASSERT(data_Get(mdataidx).data_GetType() == mcET_MONOMIAL, 
  wxT("the first parameter is the data index of the monomial with the bracket to expand")); 
 int signbeforebr = 1;

 // extract the monomial with the bracket to expand
 mcMonomial m = data_Detach(mdataidx);   // the monomial containing the bracket
 data_MoveElemLeft(mdataidx);
 mcASSERT(m.data_GetElemIndexOfType(0, mcET_BRACKET) == m.math_MathToDataIdx(bridx),
  wxT("the given monomial should contain the bracket to expand at the given math idx"));

 // extract the bracket and its contents
 mcBracket br = m.math_Get(bridx);    // the bracket to distribute
 mcPolynomial brcontents = br.data_GetContent();
 mcMATHLOG(wxT("mcPolynomialHelpers::math_DistributeBracket - the bracket's contents are [%s]"), mcTXT(brcontents));

 // remember the type of operator placed before the bracket
 if (mdataidx > 0 && data_isAddSubOp(mdataidx-1)) {
  signbeforebr = (data_Get(mdataidx-1).data_GetType() == mcET_ADDOP) ? 1 : -1;
  data_MoveElemLeft(mdataidx-1);
  mdataidx--;
 }

 // if we are contained in a monomial, then we can use
 // the DISTRIBUTIVE property to create a new polynomial 
 // that we can use to replace our parent:
 //
 //   P + Q + XY(a + b + c)WZ + R + S           superparent
 //           XY(a + b + c)WZ                   parent
 //
 // final results:
 //
 //   P + Q + XYaWZ + XYbWZ + XYcWZ + R + S     superparent
 //           XYaWZ + XYbWZ + XYcWZ             (*newelem)
 //

 // second, create pnewcount monomials inside of pnew
 int pnewcount = brcontents.math_GetCount();
 int mcount = m.math_GetCount();
 for (int n=0; n < pnewcount; n++) {

  // third, init the n-th monomial with a simple "1"
  mcMonomial newm;
  newm.math_ResetToOne();
  int add = 1;

  // four, fill each monomial with the factors of the parent
  for (int i=0; i < mcount; i++) {

   mcElement tomult = m.data_Get(i);
   if (tomult == br) {

    // do not multiply by this bracket, but by the n-th element 
    // contained _inside_ this bracket
    tomult = brcontents.math_Get(n);

    // remember the sign which is preceding that monomial
    add = brcontents.math_GetSign(n);

    // multiply by an entire monomial, not just a simple element
    newm.math_SimpleMultiplyBy(tomult);
    
   } else {
    
    // tomult should not be a mcElementArray-derived class:
    // it should be a simple element.
    newm.math_SimpleMultiplyBy(tomult);
   }
  }

  // be sure that the monomial is okay
  newm.data_Check();

  // last, add this monomial to the newp
  //newp.math_SimpleAdd(&newm, add);
  mcElementType t = (add*signbeforebr == 1) ? mcET_ADDOP : mcET_SUBOP;
  data_MoveElemRight(mdataidx);
  data_Set(mdataidx, mcElementHelpers::data_NewElem(t));
  data_MoveElemRight(mdataidx+1);
  data_Set(mdataidx+1, newm);
  mdataidx+=2;
 }

 // ok, tell the parent to use "newp" as replacement
 data_Check();

 mcMATHLOG(wxT("mcPolynomialHelpers::math_DistributeBracket - result is [%s]"), mcTXTTHIS);
}

mcMonomial mcPolynomialHelpers::math_GetGCD(const mcElement &p) const
{ 
 mcPolynomial arr(p);

 // if we are both containing a single element, our work is quite easy...
 if (math_isFactorized() && arr.math_isFactorized())
  return math_Get(0).hlp()->math_GetGCD(arr.math_Get(0));

 // at least one of the two arrays (*this or arr) is containing
 // more than a single monomial: GCD has no sense in this case....
 //return *mcMonomialHelpers::smath_pOne;
 return math_GetGCDFor(NULL, -1);
}

mcMonomial mcPolynomialHelpers::math_GetLCM(const mcElement &p) const
{ 
 mcPolynomial arr(p);

 // if we are both containing a single element, our work is quite easy...
 if (math_isFactorized() && arr.math_isFactorized())
  return math_Get(0).hlp()->math_GetLCM(arr.math_Get(0));

 // at least one of the two arrays (*this or arr) is containing
 // more than a single monomial: LCM is then the product of these
 // two polynomials
 mcBracket br1(mcPolynomial(this).math_EmbedInBracket().data_GetRef());
 mcBracket br2(arr.math_EmbedInBracket().data_GetRef());
 
 mcMonomial res;
 res.data_AddElements(&br1, 1);
 res.math_SimpleMultiplyBy(br2);

 return res;
}



mcArrayEntry mcPolynomialHelpers::math_EmbedInBracket(int *n, int count)
{
 if (count == -1)
  return mcElementArrayHelpers::math_EmbedInBracket();

 mcPolynomial pol;
 mcBracket br;

 // select only the given monomials 
 for (int i=0; i < count; i++) {

  // add/subtract the required monomials
  bool add = (math_GetSign(n[i]) == 1) ? TRUE : FALSE;
  pol.math_SimpleAdd(math_Get(n[i]), add);

  // cannot remove now the n[i]-th monomial since otherwise
  // we would make invalid the n[i+1], n[i+2]... indexes
  math_Remove(n[i]);
  for (int j=i+1; j < count; j++)
   n[j]--;
 }


 // allocate a new mcBracket
 br.data_SetContent(pol);
 
 // this object will take care of the bracket...
 math_SimpleAdd(br);
 
 mcArrayEntry ourb(this, mcMAKEPOL_IDX(data_GetCount()-1, 0));
 mcASSERT(ourb.data_GetRef().data_GetType() == mcET_BRACKET, wxT("What is this ?!?!?"));
 
 return ourb;
}

mcArrayEntry mcPolynomialHelpers::math_GetIndexOf(int occ, const mcMonomial &tofind, 
              bool positivesign) const
{
 // scan the array
 for (int i=0,max=math_GetCount(); i<max; i++) {

  // not only compare the given monomial with our i-th one,
  // but also do check the sign of that monomial
  if (math_Get(i).math_Compare(tofind, TRUE) &&
   positivesign == (math_GetSign(0) != 0)) {

   occ--;
   if (occ == -1)
    return mcArrayEntry(this, mcMAKEPOL_IDX(math_MathToDataIdx(i), 0));

   // search the next occurrence
  }
 }

 return mcEmptyArrayEntry;
}

---

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

[ Top ]