Main page

---

Fraction.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 "Fraction.cpp"
#endif

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

#ifndef mcPRECOMP
 #include "mc/MathCore.h"
 #include "mc/Fraction.h"
 #include "mc/Monomial.h"
 #include "mc/Number.h"
 #include "mc/Bracket.h"
#endif



mcIMPLEMENT_MAIN_CLASS(mcFraction, mcElement);



// setup customizable variables
int mcFractionHelpers::sgui_nSpaceAboveBelow = 2;
int mcFractionHelpers::sgui_nSpaceBetween = 1;
int mcFractionHelpers::sgui_nAdditionalWidth = 4;
int mcFractionHelpers::sgui_nAdditionalSpace = 8;

// This is the special key which must be used to create a new fraction
// through the mcElementGUI input system.
// This is not a simple CTRL+F combination because gui_isBeginKey() will
// return TRUE only if the given key is set as a special key.
mcKey *mcFractionHelpers::sgui_pNewFraction = NULL;





// ----------------------------------------
// mcFRACTIONDATA
// ----------------------------------------

void mcFractionHelpers::data_AddElements(bool bNum, mcElement *p, int num, int pos, 
         bool bOverwrite, bool bForceCopy)
{
 // just call the math_AddElements function of the num/den
 if (bNum)
  data_GetNum().data_AddElements(p, num, pos, bOverwrite, bForceCopy);
 else 
  data_GetDen().data_AddElements(p, num, pos, bOverwrite, bForceCopy);
}

#ifdef __MCDEBUG__

wxString mcFractionHelpers::data_Debug(long flags) const
{
 int step = mcMathCore::Get()->m_nIndentationStep;
 return wxString::Format(
  wxT("mcFraction [\n")
  wxT("---->>>>>>>>>>>>>>>>>> NUMERATOR <<<<<<<<<<<<<<<<----\n")
  wxT("%s")
  wxT("---->>>>>>>>>>>>>>>>> DENOMINATOR <<<<<<<<<<<<<<<----\n")
  wxT("%s")
  wxT("mcFraction ]"), 
  data_GetNum().data_GetDebug(step, flags).c_str(), 
  data_GetDen().data_GetDebug(step, flags).c_str());
}

void mcFractionHelpers::data_Check() const
{
 // first of all, check our children (that is, num & den)
 mcElementHelpers::data_Check();

 // then, check they are not empty...
 // FIXME: is this check okay ?
 mcASSERT(data_GetNum().data_GetCount() > 0, wxT("An empty numerator ?"));
 mcASSERT(data_GetDen().data_GetCount() > 0, wxT("An empty denominator ?"));
}

#endif




// ----------------------------------------
// mcFRACTIONGUI
// ----------------------------------------

bool mcFractionHelpers::gui_isBeginKey(const mcKey &key) const
{
 if (key.MatchKey(*sgui_pNewFraction))
  return TRUE;
 return FALSE;
}

bool mcFractionHelpers::gui_isEndKey(const mcKey &ev) const
{
 switch (mgui_nCursorPos) {
 case mcFRACTION_LEFTMOST:
 case mcFRACTION_RIGHTMOST:
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(ev) ||    
   mcMathCore::Get()->m_pCancelKey->MatchKey(ev))
   return FALSE;
  return TRUE;
  
 case mcFRACTION_INSIDENUM:
  return data_GetNum().gui_isEndKey(ev);
  
 case mcFRACTION_INSIDEDEN:
  return data_GetDen().gui_isEndKey(ev);
 }
 
 mcASSERT(0, wxT("Un-handled cursor position"));
 return FALSE;
}

int mcFractionHelpers::gui_GetYAnchor() const
{
 return data_GetNum().gui_GetHeight()+
   sgui_nSpaceAboveBelow+sgui_nSpaceBetween+
   mcElementHelpers::gui_GetThickness(NULL)/2;
}

void mcFractionHelpers::gui_DoRecalcSize()
{
 // calculate size of the fraction
 mgui_sz.SetWidth(mcMAX(data_GetNum().gui_GetWidth(),
       data_GetDen().gui_GetWidth()) + 
       sgui_nAdditionalWidth + sgui_nAdditionalSpace);

 mgui_sz.SetHeight(data_GetNum().gui_GetHeight() +
     data_GetDen().gui_GetHeight() +
     sgui_nSpaceAboveBelow * 2 +
     sgui_nSpaceBetween*2 +
     mcElementHelpers::gui_GetThickness(NULL));
}

wxPoint mcFractionHelpers::gui_GetNumPos() const
{
 // calculate the position of the numerator using coordinates relative to
 // this element. Center it horizontally
 return wxPoint((gui_GetWidth()-data_GetNum().gui_GetWidth())/2, sgui_nSpaceAboveBelow);
}

wxPoint mcFractionHelpers::gui_GetDenPos() const
{
 // calculate the position of the denominator using coordinates relative to
 // this element. Center it horizontally
 return wxPoint((gui_GetWidth()-data_GetDen().gui_GetWidth())/2,
  data_GetNum().gui_GetHeight() + sgui_nSpaceBetween*2 +
  mcElementHelpers::gui_GetThickness(NULL) + sgui_nSpaceAboveBelow);
}

void mcFractionHelpers::gui_OnSelect(wxDC &dc, wxRect &rc)
{
 bool existselection = FALSE;

 // collect data
 wxRect num(gui_GetNumPos(), data_GetNum().gui_GetSize());
 wxRect den(gui_GetDenPos(), data_GetDen().gui_GetSize());

 // TODO: theorically we should such a check to be sure
 //       that only math-coherent selections can be possible:
 /*if (hlp()->GetParent().data_GetType() == mcET_POLYNOMIAL) {
  if (((mcElementArray*)(hlp()->GetParent())).gui_GetSelElemCount() > 0)
   existselection = TRUE;
 }*/

 // remove old selection
 // FIXME: gui_DeSelect() is recursive: so we could try to remove
 //        it from non-mcElementArray to gain speed
 gui_DeSelect();

 // since we haven't got access to our parent, avoid it
 existselection = FALSE;

 // check if we must call the gui_OnSelect() function of the numerator,
 // the gui_OnSelect() function of the denominator or both...
 bool n = num.Intersects(rc), d = den.Intersects(rc);

 if ((n && d) || existselection) {

  // the selection intersects both numerator & denominator: we cannot allow
  // a partial selection: we must select all the element
  gui_SelectAll();

 } else if (n) {

  // the selection intersects just numnerator: check it and eventually
  // select the fraction (to let the parent know we contain at least
  // one element selected)
  data_GetNum().gui_OnSelect(dc, rc);

  if (data_GetNum().gui_isSelected())
   gui_Select();

 } else if (d) {

  data_GetDen().gui_OnSelect(dc, rc);

  if (data_GetDen().gui_isSelected())
   gui_Select();
 }
}

int mcFractionHelpers::gui_Draw(wxDC &hDC, int x, int y, long flags, const wxPoint &pt) const
{
 wxPoint n = gui_GetNumPos(), d = gui_GetDenPos(), ptn, ptd;
 wxRect num(n, data_GetNum().gui_GetSize());
 wxRect den(d, data_GetDen().gui_GetSize());
 int f=0, numid, denid;
 long fn=flags, fd=flags;

 // offset the rects
 num.x += x;
 num.y += y;
 den.x += x;
 den.y += y;

 // if both the numerator and the denominator are entirely selected, then
 // we must avoid that the num and the den draw their own selection rectangles:
 // the parent of this element will care about that !!!
 if (this->gui_isAllSelected()) {
  
  fn &= ~mcDRW_ALLOW_TOTAL_SELECTION;
  fd &= ~mcDRW_ALLOW_TOTAL_SELECTION;

 } else {

  fn |= mcDRW_ALLOW_TOTAL_SELECTION;
  fd |= mcDRW_ALLOW_TOTAL_SELECTION;
 }

 // draw the numerator and the denominator
 ptn = ptd = pt;
 if (flags & mcDRW_USEPOINT) {

  // check the position of the cursor and then delete
  // unnecessary work: the cursor cannot be both over num & den !!!
  if (num.Inside(pt)) {

   // denominator can be drawn as non active
   fd |= mcDRW_NONACTIVE;
   ptd = wxDefaultPosition;
   f = 1;   // return numerator's ID

  } else if (den.Inside(pt)) {

   // numerator can be drawn as non active
   fn |= mcDRW_NONACTIVE;
   ptn = wxDefaultPosition;
   f = -1;   // return denominator's ID

  } else {

   // the cursor is not inside the numerator nor the denominator:
   // it must be placed in the empty space of the fraction...
   f = 1000;
   ptn = ptd = wxDefaultPosition;
   fn |= mcDRW_NONACTIVE; 
   fd |= mcDRW_NONACTIVE;
  }
 }

 // draw num & den
 numid = data_GetNum().gui_Draw(hDC, num.x, num.y, fn, ptn);
 denid = data_GetDen().gui_Draw(hDC, den.x, den.y, fd, ptd);

 // draw the fraction line
 y += sgui_nSpaceAboveBelow+data_GetNum().gui_GetHeight()+sgui_nSpaceBetween;

 // draw the fraction line thick
 hDC.SetPen(*wxBLACK_PEN);
 int thickness = mcElementHelpers::gui_GetThickness(&hDC);
 for (int i=0; i < thickness; i++, y++)
  hDC.DrawLine(x+sgui_nAdditionalSpace/2, y, 
     x+gui_GetWidth()-sgui_nAdditionalSpace/2, y);

 // choose which ID must be returned
 switch (f) {
 case 0:
  return data_GetID();
 case 1:
  return numid;
 case -1:
  return denid;
 }

 // cursor was on empty space
 return mcDRW_NOACTIVEELEM;
}

mcInputRes mcFractionHelpers::gui_Input(const mcKey &key, mcElement *pnew)
{
 int res;

 // if the fraction hasn't been initialized yet
 if (key.MatchKey(*sgui_pNewFraction) &&
  !data_hasProperty(mcEP_INITIALIZED)) {

  // fill numerator and denominator with empty boxes
  data_GetNum().gui_AddNewEmptyMonomial();
  data_GetDen().gui_AddNewEmptyMonomial();

  data_AddProperty(mcEP_INITIALIZED);
  gui_RecalcSize();

  return mcIR_OKAY;
 }

 switch (mgui_nCursorPos) {
 case mcFRACTION_LEFTMOST:
  // since isEndChar should reject all inputs when cursor
  // is in this position, this code should never be executed
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
   return mcIR_DELETE_PREVIOUS;
  if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
   return mcIR_DELETE_THIS;
  mcASSERT(0, wxT("Code should never get here; check isEndChar() function"));

 case mcFRACTION_RIGHTMOST:
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
   return mcIR_DELETE_THIS;
  if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
   return mcIR_DELETE_NEXT;
  mcASSERT(0, wxT("Code should never get here; check isEndChar() function"));

 case mcFRACTION_INSIDENUM:
  res = data_GetNum().gui_Input(key, pnew);

  if (res == mcIR_DELETE_PREVIOUS || res == mcIR_DELETE_THIS)
   return mcIR_DELETE_THIS;

  gui_RecalcSize();
  break;

 case mcFRACTION_INSIDEDEN:
  res = data_GetDen().gui_Input(key, pnew);

  if (res == mcIR_DELETE_PREVIOUS || res == mcIR_DELETE_THIS)
   return mcIR_DELETE_THIS;

  gui_RecalcSize();
  break;
 }

 return mcIR_OKAY;
}

mcInsertRes mcFractionHelpers::gui_Insert(const mcElement &toinsert, mcElement *newelem)
{
 switch (mgui_nCursorPos) {
 case mcFRACTION_INSIDENUM:
  data_GetNum().gui_Insert(toinsert, NULL);
  break;

 case mcFRACTION_INSIDEDEN:
  data_GetDen().gui_Insert(toinsert, NULL);
  break;

 default:
  mcASSERT(0, wxT("Invalid cursor position"));
 }

 return mcINSR_OKAY;
}

mcMoveCursorRes mcFractionHelpers::gui_MoveCursor(mcMoveCursorFlag flags, long modifiers)
{
 int result;

 switch (mgui_nCursorPos) {
 case mcFRACTION_LEFTMOST:
  if (flags == mcMCF_LEFT) {
   return mcMCR_SETFOCUS_PREVIOUS;
  }
  if (flags == mcMCF_RIGHT) {
   mgui_nCursorPos = mcFRACTION_INSIDENUM;
   data_GetNum().gui_SetCursorPos(mcCP_BEGIN);
  }
  if (flags == mcMCF_UP)
   return mcMCR_SETFOCUS_ABOVE;
  if (flags == mcMCF_DOWN)
   return mcMCR_SETFOCUS_BELOW;
  break;

 case mcFRACTION_RIGHTMOST:
  if (flags == mcMCF_LEFT) {
   mgui_nCursorPos = mcFRACTION_INSIDENUM;
  }
  if (flags == mcMCF_RIGHT) {
   return mcMCR_SETFOCUS_NEXT;
  }
  if (flags == mcMCF_UP)
   return mcMCR_SETFOCUS_ABOVE;
  if (flags == mcMCF_DOWN)
   return mcMCR_SETFOCUS_BELOW;
  break;

 case mcFRACTION_INSIDENUM:

  // drop request to the numerator
  result = data_GetNum().gui_MoveCursor(flags, modifiers);

  // check if cursor is still inside the expression
  if (result == mcMCR_SETFOCUS_PREVIOUS) {
   mgui_nCursorPos = mcFRACTION_LEFTMOST;
  }
  if (result == mcMCR_SETFOCUS_NEXT) {
   mgui_nCursorPos = mcFRACTION_RIGHTMOST;
  }
  if (result == mcMCR_SETFOCUS_ABOVE) {
   return mcMCR_SETFOCUS_ABOVE;
  }
  if (result == mcMCR_SETFOCUS_BELOW) {
   mgui_nCursorPos = mcFRACTION_INSIDEDEN;
   data_GetDen().gui_SetCursorPos(mcCP_BEGIN);
  }

  break;

 case mcFRACTION_INSIDEDEN:
  // drop request to the denominator
  result = data_GetDen().gui_MoveCursor(flags, modifiers);

  // check if cursor is still inside the expression
  if (result == mcMCR_SETFOCUS_PREVIOUS) {
   mgui_nCursorPos = mcFRACTION_LEFTMOST;
  }
  if (result == mcMCR_SETFOCUS_NEXT) {
   mgui_nCursorPos = mcFRACTION_RIGHTMOST;
  }
  if (result == mcMCR_SETFOCUS_ABOVE) {
   mgui_nCursorPos = mcFRACTION_INSIDENUM;
   data_GetNum().gui_SetCursorPos(mcCP_BEGIN);
  }
  if (result == mcMCR_SETFOCUS_BELOW) {
   return mcMCR_SETFOCUS_BELOW;
  }

  break;
 }

 return mcMCR_OKAY;
}

int mcFractionHelpers::gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &pt)
{
 // just check if the given point is inside the num or the den...
 wxRect num(gui_GetNumPos(), data_GetNum().gui_GetSize());
 wxRect den(gui_GetDenPos(), data_GetDen().gui_GetSize());
 
 if (num.Inside(pt)) {
  mgui_nCursorPos = mcFRACTION_INSIDENUM; 
  return data_GetNum().gui_MoveCursorUsingPoint(dc, pt);
 }
 if (den.Inside(pt)) {
  mgui_nCursorPos = mcFRACTION_INSIDEDEN;
  return data_GetDen().gui_MoveCursorUsingPoint(dc, pt); 
 }
   
 return mcMCR_OKAY;
}

int mcFractionHelpers::gui_GetRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 int n;

 switch (mgui_nCursorPos) {
 case mcFRACTION_LEFTMOST:
  pt->x = 0;
  pt->y = 0;
  return gui_GetSize().GetHeight();

 case mcFRACTION_RIGHTMOST:
  pt->x = gui_GetSize().GetWidth();
  pt->y = 0;
  return gui_GetSize().GetHeight();

 case mcFRACTION_INSIDENUM:
  n = data_GetNum().gui_GetRelCursorPos(hDC, pt);
  pt->x += gui_GetNumPos().x;
  pt->y += gui_GetNumPos().y;
  return n;

 case mcFRACTION_INSIDEDEN:
  n = data_GetDen().gui_GetRelCursorPos(hDC, pt);
  pt->x += gui_GetDenPos().x;
  pt->y += gui_GetDenPos().y;
  return n;
 }

 return 0;
}

void mcFractionHelpers::gui_SetCursorPos(const mcCursorPos &cp)
{
 if (cp.isBegin())
  mgui_nCursorPos = mcFRACTION_LEFTMOST;
 else if (cp.isEnd())
  mgui_nCursorPos = mcFRACTION_RIGHTMOST;
 else
  mcASSERT(0, wxT("Cannot accept these flags"));
}

void mcFractionHelpers::gui_GetCursorPos(mcCursorPos &cp) const
{
 if (mgui_nCursorPos == mcFRACTION_LEFTMOST)
  cp.gui_Push(mcCP_BEGIN);
 else if (mgui_nCursorPos == mcFRACTION_RIGHTMOST)
  cp.gui_Push(mcCP_END);
 else
  cp.gui_Push(mgui_nCursorPos);
}

mcElement mcFractionHelpers::gui_GetSelection() const
{
 bool n = data_GetNum().gui_isSelected(), 
  d = data_GetDen().gui_isSelected();

 if (n && d) {

  // a little check
  mcASSERT(gui_isAllSelected(), wxT("If both num & den are selected, the element ")
   wxT("should be marked as completely selected"));

  // return a copy of this fraction: it's entirely selected !!!
  mcElement *toreturn = new mcFraction(this);
  return *toreturn;  //TOTEST

 } else if (n) {

  // return only the selected elements of the numerator
  return data_GetNum().gui_GetSelection();

 }

 return data_GetDen().gui_GetSelection();
}

void mcFractionHelpers::gui_DeleteSelection()
{
 mcElementHelpers::gui_DeleteSelection();

 // be sure that num & den are not removed completely...
 if (data_GetNum().data_GetCount() == 0)
  data_GetNum().gui_AddNewEmptyMonomial();
 if (data_GetDen().data_GetCount() == 0)
  data_GetDen().gui_AddNewEmptyMonomial();

 gui_RecalcSize();
}







// ----------------------------------------
// mcFractionIO
// ----------------------------------------

wxXml2Node mcFractionHelpers::io_GetMathML(bool bGetPresentation) const
{
 wxXml2Node maintag;

 // add some mathml code
 if (bGetPresentation) {

  maintag.CreateTemp(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("mfrac"));

 } else {

  maintag.CreateTemp(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("apply"));
  wxXml2Node divide(wxXML_ELEMENT_NODE, maintag, wxT("divide"));
 }

 // get math ml both for numerator & denominator
 wxXml2Node num = data_GetNum().io_GetMathML(bGetPresentation),
   den = data_GetDen().io_GetMathML(bGetPresentation);
 maintag.AddChild(num);
 maintag.AddChild(den);

 return maintag;
}

bool mcFractionHelpers::io_CheckBracketNeed(const mcPolynomial &p, const wxString &exp) const
{
 bool res = FALSE;

 // we need to bracketize this polynomial if:
 //
 // 1) the polynomial contains more than one element
 res |= (p.data_GetCount() > 1);

 mcMonomial m = mcMonomial(p.data_GetElemOfType(0, mcET_MONOMIAL));
 if (m != mcEmptyElement && m.data_GetCount() > 0) {

  // 2) the polynomial, contains one element which is not
  //    a mcBracket and, as inlined expr, it is longer than 3 characters..
  res |= (m.data_Get(0).data_GetType() != mcET_BRACKET && exp.Len() > 3);
 }

 return res;
}

wxString mcFractionHelpers::io_GetInlinedExpr() const
{
 wxString strNum = data_GetNum().io_GetInlinedExpr();
 wxString strDen = data_GetDen().io_GetInlinedExpr();

 // export everything as ()/()
 bool bracketizeNum = io_CheckBracketNeed(data_GetNum(), strNum);
 bool bracketizeDen = io_CheckBracketNeed(data_GetDen(), strDen);

 if (bracketizeNum) strNum = wxT("(") + strNum + wxT(")");
 if (bracketizeDen) strDen = wxT("(") + strDen + wxT(")");

 // add the final slash
 return strNum + wxT("/") + strDen;
}

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

 // the given tag should have exactly 2 children
 wxXml2Node num = tag.GetChildren();
 wxXml2Node den = num.GetNext();

 if (den.GetNext() != wxXml2EmptyNode) {
  pErr = wxT("Found an <MFRAC> tag with more than two nested tags.");
  return FALSE;
 }

 if (den == wxXml2EmptyNode || num == wxXml2EmptyNode) {
  pErr = wxT("Found an <MFRAC> tag with less than two nested tags.");
  return FALSE;
 }

 if (num.GetName() != wxT("mrow"))
  num.Encapsulate(wxT("mrow"));
 if (den.GetName() != wxT("mrow"))
  den.Encapsulate(wxT("mrow"));
 num.SetNext(den);
 tag.SetChildren(num);

 if (!data_GetNum().io_ImportPresentationMathML(num, pErr))
  return FALSE;
 if (!data_GetDen().io_ImportPresentationMathML(den, pErr))
  return FALSE;

 return TRUE;
}

bool mcFractionHelpers::io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 mcUNUSED(str);
 mcUNUSED(count);
 mcUNUSED(pErr);

 // this is not an import error; this is a programming flaw !!
 mcASSERT(0, wxT("mcFractionIO MathML import functions should never be called ")
     wxT("because mcDivOp will import all the data for the '/' symbols ")
        wxT("which will be then converted to mcFraction later..."));
 return FALSE;
}

void mcFractionHelpers::io_SetNum(const wxString &num)
{
 wxString str;

 // data_GetNum().Init(num);   wouldn't work because
 // mcElementArray::io_isBeginChar always returns FALSE...
 data_GetNum().io_ImportInlinedExpr(num, NULL, str);
}

void mcFractionHelpers::io_SetDen(const wxString &den)
{
 wxString str;

 // data_GetNum().Init(num);   wouldn't work because
 // mcElementArray::io_isBeginChar always returns FALSE...
 data_GetDen().io_ImportInlinedExpr(den, NULL, str);
}




// ----------------------------------------
// mcFRACTIONMATH
// ----------------------------------------

void mcFractionHelpers::math_SetExp(const mcPolynomial &p)
{
 // set exponent both in the num & den
 // NOTE: if we set the same exponent both in num & den,
 //       the result is no exponent because they can be 
 //       immediately simplified.
 //       However, this function can still be useful for
 //       other algorithms like math_Expand(long flags)
 //data_GetNum().math_SetExp(p);
 //data_GetDen().math_SetExp(p);
 mcASSERT(0, wxT(""));
}

bool mcFractionHelpers::math_Compare(const mcElement &p, long flags) const
{
 if (p.data_GetType() != mcET_FRACTION)
  return FALSE;

 // both num & den must be tested...
 mcFraction f(p);
 return data_GetNum().math_Compare(f.data_GetNum(), flags) &&
   data_GetDen().math_Compare(f.data_GetDen(), flags);
}

mcMathType mcFractionHelpers::math_GetMathType() const
{
 mcMathType num = data_GetNum().math_GetMathType();
 mcMathType den = data_GetDen().math_GetMathType();

 // by now, just multiply the two classifications...
 num.math_MultiplyBy(den);

 // ...then, check if the denominator contains one or more unknowns: if it
 // does, then the global math data must be considered as RATIONAL...
 if (data_GetDen().math_ContainsUnknowns())
  num.m_tMath1 = mcMTL1_RATIONAL;

 return num;
}

mcRealValue mcFractionHelpers::math_Evaluate() const
{
 mcRealValue num = data_GetNum().math_Evaluate();
 mcRealValue den = data_GetDen().math_Evaluate();

 // can we proceed ?
 if (!num.isValid() ||
  !den.isValid())
  return *mcRealValue::pNAN;

 // just perform a division between num & den
 return num/den;
}

void mcFractionHelpers::math_Flip()
{
 // just swap den & num
 mcPolynomial tmp = data_GetNum();
 data_GetNum() = data_GetDen();
 data_GetDen() = tmp;
}





// ---------------------------------
// mcFRACTIONMATH basic operations
// ---------------------------------

bool mcFractionHelpers::math_CanBeMultWith(const mcElement &p) const
{ return TRUE; }

bool mcFractionHelpers::math_CanBeAddedWith(const mcElement &p) const
{ return TRUE; }

bool mcFractionHelpers::math_CanBeDivBy(const mcElement &p) const
{ return TRUE; }


//void mcFractionHelpers::math_AddOrmath_Subtract(const mcElement &p, bool add)
mcBasicOpRes mcFractionHelpers::math_Add(const mcElement &p, mcElement *pp, bool add)
{
 switch (p.data_GetType()) {
 case mcET_FRACTION:
  {
   mcFraction f(p);
   
   // now, make common den between the two denominators...
   mcMonomial lcm(data_GetDen().math_GetLCM(f.data_GetDen()));
   mcPolynomial common;
   common.data_AddNewMonomial(lcm);
   
   // multiply the num of this fraction by the common den 
   // divided by denominator of this fraction
   mcPolynomial mult(common);
   mult.math_SimpleDivideBy(data_GetDen());
   data_GetNum().math_SimpleMultiplyBy(mult);
   
   mult.data_DeleteAll();  // mult can be reused now
   
   // now, multiply the num of the other fraction by the common
   // den divided by the denominator of the other fraction
   mult = common;
   mult.math_SimpleDivideBy(f.data_GetDen());   
   mcPolynomial tmp(f.data_GetNum());
   tmp.math_SimpleMultiplyBy(mult);
   
   // add/sub "tmp" to the numerator...
   if (add)
    data_GetNum().math_SimpleAdd(tmp);
   else
    data_GetNum().math_SimpleSubtract(tmp);
   
   // set the common den as the denominator of this fraction
   data_SetDen(common);
  }
  break;
  
 case mcET_NUMBER:
 case mcET_SYMBOL:
 case mcET_MONOMIAL:
 case mcET_POLYNOMIAL:
 case mcET_RADICAL:
 case mcET_BRACKET:
 case mcET_FUNCTION:
  {
   // multiply a copy of the denominator by the symbol/number
   // that we are processing...
   mcPolynomial tmp = data_GetDen();
   tmp.math_SimpleMultiplyBy(p);
   
   // ... and add/subtract it to the numerator...
   data_GetNum().math_SimpleAdd(tmp, add);
  }
  break;

 default:
  mcASSERT(0, wxT("Something is really wrong..."));
  break;
 }

 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcFractionHelpers::math_MultiplyBy(const mcElement &p, mcElement *pp)
{
 mcASSERT(p.math_isValidMath(), wxT("Invalid operand"));

 if (p.data_GetType() == mcET_FRACTION) {

  mcFraction f(p);
  
  // just multiply num by num & den by den:
  // 
  //   a     c     a*c
  //  --- * --- = -----
  //   b     d     b*d
  //
  data_GetNum().math_SimpleMultiplyBy(f.data_GetNum());
  data_GetDen().math_SimpleMultiplyBy(f.data_GetDen());
  
 } else {
  
  // just multiply the numerator
  //
  //   a         a*c
  //  --- * c = -----
  //   b          b
  //
  data_GetNum().math_SimpleMultiplyBy(p);
 }
 
 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcFractionHelpers::math_DivideBy(const mcElement &p, mcElement *pp)
{
 mcASSERT(p.math_isValidMath(), wxT("Invalid operand"));

 if (p.data_GetType() == mcET_FRACTION) {

  mcFraction f(p);
  
  // flip the other fraction
  // 
  //   a     c     a     c
  //  --- : --- = --- * ---
  //   b     d     b     d
  //  
  f.math_Flip();
  f.data_Check();
  *pp = f;

  return mcBOR_REPLACE_OPERAND_AND_SET_MULTOP;
  
 } else {
  
  // just multiply the denominator by the given element:
  //
  //   a          a
  //  --- : c = -----
  //   b         b*c
  //
  data_GetDen().math_SimpleMultiplyBy(p);
 }

 return mcBOR_REMOVE_OPERAND;
}




// ---------------------------------------
// mcFRACTION - simplification/expansion
// ---------------------------------------

mcExpSimRes mcFractionHelpers::math_Simplify(long flags, mcElement *newelem)
{
 mcPolynomial &n = data_GetNum(), &d = data_GetDen();

 // STEP #1: simplify num & den
 mcExpSimRes n1 = n.math_Simplify(flags);
 mcExpSimRes n2 = d.math_Simplify(flags);

 // if num or den is not completely simplified, wait next call...
 if (n1 != mcESR_DONE || n2 != mcESR_DONE)
  return mcESR_NOTFINISHED;

 // STEP #1b: simplify a "sign" if possible
 if (n.math_isFirstMonomialNegative() && d.math_isFirstMonomialNegative()) {

  // ok, changing the sign both to num & den we solve the problem...
  n.math_ChangeAllSigns();
  d.math_ChangeAllSigns();
  return mcESR_NOTFINISHED;
 }

 if (n.math_isFirstMonomialNegative()) {

  // the denominator signs are okay as they are...
  // we'll change our signs changing the sign
  // in front of the monomial which contains us
  n.math_ChangeAllSigns();
  return mcESR_CHANGE_SIGN;
 }

 
 // STEP #2: try to remove denominator (if it's possible !)
 // check if the denominator just contains a simple "1" or a
 // simple "-1"...
 if (d.math_GetCount() == 1) {

  mcRealValue value = d.math_Evaluate();

  // handle the wxT("-1") case, reporting it to the "+1" case
  if (value == -1.0) {
   n.math_ChangeAllSigns();
   value = 1.0;
  }
  
  if (value == 1.0) {

   // pack the numerator inside a bracket
   mcBracket br;
   br.data_SetContent(n);

   // denominator can be removed... this fraction
   // can be simplified to its numerator
   (*newelem) = br;
   
   return mcESR_REPLACE_THIS;
  }
 }

 // STEP #3: try to simplify numerator with denominator...
 if (n.math_isFactorized() && d.math_isFactorized())
  return math_SimplifyFactors(flags, newelem);

 // if the num or den is not factorized after it has been completely
 // simplified, we cannot do anything more...
 return mcESR_DONE;
}

mcExpSimRes mcFractionHelpers::math_SimplifyFactors(long flags, mcElement *newelem)
{
 mcPolynomial &n = data_GetNum(), &d = data_GetDen();
 
 mcUNUSED(newelem);

 // both num & den contain one monomial only...
 // thus we contain something like:
 //
 //      a          (ax+b)(...)               ax + b
 //     ---   or   ------------   but not   ----------
 //      b           a*b*(...)                 ...
 //
 // In this case, we can try to apply a divop 
 // between all the num & den elements 
 mcMonomial &m1 = n.math_Get(0);
 mcMonomial &m2 = d.math_Get(0);
 
 for (int i=0; i < m1.math_GetCount(); i++) {
  
  mcElement &first = (mcElement &)m1.math_Get(i);
  for (int j=0; j < m2.math_GetCount(); j++) {
   
   mcElement &second = (mcElement &)m2.math_Get(j);
   if (first.math_CanBeDivBy(second)) {

    mcMATHLOG(wxT("mcFractionHelpers::math_SimplifyFactors - dividing ")
     wxT("[%s] by [%s]"), mcTXT(first), mcTXT(second));
    
    // divide the i-th numerator's element
    // by the j-th denominator's element
    mcElement replacement;
    mcBasicOpRes r = first.math_DivideBy(second, &replacement);
    
    //.math_HandleBasicOpRes(r, replacement, j);
    switch(r) {
    case mcBOR_INVALID:
     mcASSERT(0, wxT("Something was wrong"));
     break;

    case mcBOR_REPLACE_OPERAND:
     m2.data_AddElements(&replacement, 1, 
      m2.math_MathToDataIdx(j), TRUE);
     m2.data_Check();
     break;

    case mcBOR_REMOVE_OPERAND:
     m2.math_Remove(j, FALSE);
     break;

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

 // we tried to divide all the factors of the numerator with
 // all the factors of the denominator without success:
 // this fraction should be reduced to the minimal terms.
 return mcESR_DONE;
}

mcExpSimRes mcFractionHelpers::math_Expand(long flags, mcElement *newelem)
{
 mcPolynomial &n = data_GetNum(), &d = data_GetDen();
 mcExpSimRes n1 = n.math_Expand(flags);
 mcExpSimRes n2 = d.math_Expand(flags);

 // if num or den is not completely simplified, wait next call...
 if (n1 != mcESR_DONE || n2 != mcESR_DONE)
  return mcESR_NOTFINISHED;

 return mcESR_DONE;
}

/*
mcPolynomial &mcFractionHelpers::math_&math_GetFactors() const
{
 // 
}*/

mcMonomial mcFractionHelpers::math_GetLCM(const mcElement &p) const
{
 mcFraction f(p);
 mcFraction res;

 mcPolynomial num = data_GetNum().math_GetLCM(f.data_GetNum());
 mcPolynomial den = data_GetDen().math_GetLCM(f.data_GetDen());
 res.data_SetNum(num);
 res.data_SetDen(den);

 return res;
}

mcMonomial mcFractionHelpers::math_GetGCD(const mcElement &p) const
{
 mcFraction f(p);
 mcFraction res;

 mcPolynomial num = data_GetNum().math_GetGCD(f.data_GetNum());
 mcPolynomial den = data_GetDen().math_GetGCD(f.data_GetDen());
 res.data_SetNum(num);
 res.data_SetDen(den);

 return res;
}

mcBasicOpRes mcFractionHelpers::math_RaiseTo(const mcPolynomial &p)
{
 data_GetNum().math_SimpleRaiseTo(p);
 data_GetDen().math_SimpleRaiseTo(p);

 return mcBOR_REMOVE_OPERAND;
}

---

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

[ Top ]