Main page

---

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

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/MathCore.h"
 #include "mc/Number.h"
 #include "mc/Monomial.h"
 #include "mc/Fraction.h"
#endif



mcIMPLEMENT_MAIN_CLASS(mcNumber, mcExpElement);


// setup static variables
mcNumber *mcNumberHelpers::smath_pOne = NULL;
mcNumber *mcNumberHelpers::smath_pTwo = NULL;
mcNumber *mcNumberHelpers::smath_pFour = NULL;
mcNumber *mcNumberHelpers::smath_pMinusOne = NULL;
mcNumber *mcNumberHelpers::smath_pZero = NULL;

wxString mcNumberHelpers::sgui_strFloatingPoint = wxT(".,");
int mcNumberHelpers::sgui_nDigitToShow = -1;
bool mcNumberHelpers::smath_bUseIntegersWhenPossible = TRUE;


// global objects
mcNumber mcEmptyNumber(NULL);



// ----------------------------------------
// mcNUMBER
// ----------------------------------------

mcFraction mcNumber::math_TransformInFraction()
{ return hlp()->math_TransformInFraction(); }




// ----------------------------------------
// mcNUMBERDATA
// ----------------------------------------

bool mcNumberHelpers::gui_isDigit(int c) { 
 switch (c) {
 case wxT('0'): case wxT('1'): 
 case wxT('2'): case wxT('3'):
 case wxT('4'): case wxT('5'):
 case wxT('6'): case wxT('7'):
 case wxT('8'): case wxT('9'):
  return TRUE;
 }
 return FALSE;
}

/*
void mcNumberHelpers::data_UpdateSign()
{
 // sometimes, this routine is called when the element section is
 // not ready yet
 if (hlp() == NULL || hlp()->isBeingDeleted())
  return;

 mcRealValue n = Get();

 // SPECIAL BEHAVIOUR: always keep the values stored in mcNumbers
 // positive; just notify the sign change to our parent, if it is
 // a mcMonomial.
 // If this would not be done, then the signs of monomials
 // (stored in the form of mcAddOp/mcSubOps placed between each
 //  mcMonomial contained in a mcPolynomial) would be useless
 // because they would not reflect their coefficient' signs.
 mcElement p = hlp()->GetParent();
 if (p && p.data_GetType() == mcET_MONOMIAL && n < 0.0) {

  // if we manage to change the sign of our parent, then
  // we can mantain the contents positive...
  if (((mcMonomial*)p).math_ChangeSign())
   m_n = m_n.abs();  // don't use Set() because it calls us
 }
}
*/




// ----------------------------------------
// mcNUMBERGUI
// ----------------------------------------

bool mcNumberHelpers::gui_isBeginKey(const mcKey &ev) const
{
 if (mcNumberHelpers::gui_isDigit(ev.GetKeyCode()) && ev.GetModifiers() == 0)
  return TRUE;
 return FALSE;
}

bool mcNumberHelpers::gui_isBaseEndKey(const mcKey &ev) const
{
 // when cursor is inside num, legal inputs are digits,
 // delete & cancel keys and edit exponent key
 if (mcNumberHelpers::gui_isDigit(ev.GetKeyCode()) || 
  mcNumberHelpers::gui_isDecimalPoint(ev.GetKeyCode()) || 
  mcMathCore::Get()->MatchEditKeys(ev))
  return FALSE;
 return TRUE;
}

void mcNumberHelpers::gui_DoRecalcBaseSize()
{
 wxString tmp = gui_GetStr();

 // using correct font, retrieve base size
 wxScreenDC dc;
 gui_SelectStyle(dc);
 mgui_szBase = gui_GetSizeOf(&dc, tmp);
}

int mcNumberHelpers::gui_DrawBase(wxDC &hDC, int x, int y, long flags, 
          const wxPoint &pt) const
{
 mcGUILOG(wxT("mcNumberHelpers::gui_DrawBase"));
 wxString tmp = gui_GetStr();

 if (!(flags & mcDRW_NONACTIVE)) {

  // if the given point is valid (that is, flags & mcDRW_USEPOINT == 1)
  // or flags & mcDRW_ALLACTIVE == 1, then we must draw ourselves as active
  hDC.SetBrush(*mcElementHelpers::sgui_pActivationBrush);
  hDC.SetPen(*wxBLACK_PEN);
  hDC.DrawRectangle(x-sgui_nAdditionalActivationSpaceLeftRight, y, 
   gui_GetBaseSize().GetWidth()+sgui_nAdditionalActivationSpaceLeftRight*2,
   gui_GetBaseSize().GetHeight());
 }

 // print the base using correct font and colors
 gui_SelectStyle(hDC); 
 hDC.SetBackgroundMode(wxTRANSPARENT);
 hDC.DrawText(tmp, x, y);

 return data_GetID();
}

void mcNumberHelpers::gui_EditBase()
{
 // cursor is now editing the base
 mgui_nCursorPos = data_Get().GetNumOfDigits();
 mgui_nCursorLoc = mcECL_INSIDEBASE;
}

void mcNumberHelpers::gui_Set(const wxString &str)
{
 wxString n = str;

 // first of all, remove the leading zeroes
 while (n.GetChar(0) == wxT('0')) {

  // don't forget to move the cursor !!!
  n.Remove(0, 1);
  mgui_nCursorPos--;

  // anyway, don't make the string empty: n == "0" is valid...
  if (n.Len() == 1)
   break;
 }

 // reset & sync the number
 mgui_strTrailer = wxT("");
 data_Set(n);

 // do we have a trailer to memorize ?
 int len = gui_GetStr().Len();
 if (len < (int)n.Len())
  mgui_strTrailer = n.Right(n.Len()-len);
}

mcInputRes mcNumberHelpers::gui_BaseInput(const mcKey &key, mcElement *pnew)
{
 // handle the EDITEXP and EDITSUBSCRIPT keypresses
 if (gui_HandleSubExpEditKeys(key) == mcIR_OKAY)
  return mcIR_OKAY;

 // do not base the input function on the cursor position
 if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key)) {

  if (mgui_nCursorPos == 0) {

   // delete the previous element
   return mcIR_DELETE_PREVIOUS;
  }

  if (mgui_nCursorPos == 1 && data_Get().GetNumOfDigits() == 1) {

   // this element contains only one digit: delete it
   return mcIR_DELETE_THIS;
  }

  // delete the digit which is placed on the left of the cursor
  wxString str = gui_GetStr();
  str.Remove(mgui_nCursorPos-1, 1);
  gui_Set(str);

  // move cursor
  mgui_nCursorPos--;

 } else if (mcMathCore::Get()->m_pCancelKey->MatchKey(key)) {

  if (mgui_nCursorPos == data_Get().GetNumOfDigits()) {

   // element is placed on the rightmost point
   return mcIR_DELETE_NEXT;
  }

  if (mgui_nCursorPos == 0 && data_Get().GetNumOfDigits() == 1) {

   // this element contains only one digit: delete it
   return mcIR_DELETE_THIS;
  }

  // delete the digit which is placed on the right of the cursor
  wxString str = gui_GetStr();
  str.Remove(mgui_nCursorPos, 1);
  gui_Set(str);

  // don't move the cursor

 } else if (mcNumberHelpers::gui_isDigit(key.GetKeyCode())) {

  // add the digit at the current pos of data_Get()...
  if (data_Get() == 0 && mgui_nCursorPos == 0) mgui_nCursorPos++;
  
  // insert the digit in the number-like string
  wxString str = gui_GetStr();
  str = str.Left(mgui_nCursorPos) + key.GetKeyCode() + 
   str.Right(str.Len()-mgui_nCursorPos);
  mgui_nCursorPos++;

  // then, convert the string to mcRealValue
  gui_Set(str);

 } else if (mcNumberHelpers::gui_isDecimalPoint(key.GetKeyCode())) {

  // check if this is possible...
  if (!data_Get().isInteger()) {
   mcMathCore::Get()->SyntaxError(wxT("Cannot insert another decimal point !!!"));
   return mcIR_OKAY;
  }

  // then, add the decimal point...
  //data_Set(Get() + 0.5);
  mgui_strTrailer = mcNUMBER_DECIMAL_POINT;
  mgui_nCursorPos++;
 }

 // recompute size
 gui_RecalcSize();

 return mcIR_OKAY;
}

mcInsertRes mcNumberHelpers::gui_BaseInsert(const mcElement &toinsert, mcElement *newelem)
{
 

 return mcINSR_OKAY;
}

bool mcNumberHelpers::gui_Split(mcElement *p)
{
 bool b = FALSE;

 // the user pressed an end char while the cursor is still inside
 // the digits... this element must be split in two parts divided
 // by the operator or the element typed in. The first one will be
 // stored here, in this number, the second half, instead, must be
 // returned as a pointer to a new element
 mcNumber pnew;

 // WARNING: the order of these two lines cannot be changed, because
 // first call depends from data_Get(), which is modified by second call
 pnew.data_Set(data_Get().GetFromDigitRange(mgui_nCursorPos, -1));
 this->data_Set(data_Get().GetFromDigitRange(0, mgui_nCursorPos));

 pnew.gui_RecalcSize();
 gui_RecalcSize();

 // if one of the two elements has the num set as zero, we must return NULL
 // for it, because cursor is at the begin/end of this element.
 if (this->data_Get() == 0)
  b = TRUE;  // yes, this element must be removed

 *p = pnew;
 if (pnew.data_Get() == 0)
  *p = NULL;  // the second element is empty...

 return b;
}

bool mcNumberHelpers::gui_MergeWith(const mcElement &p)
{
 if (p.data_GetType() != mcET_NUMBER)
  return FALSE;  // could not perform merging...

 mcNumber n(p);
 int len = n.data_Get().GetNumOfDigits();

 // merge the two numbers
 mcRealValue res = data_Get()*mcRealValue(10).pow(len) + n.data_Get();
 data_Set(res);

 // size should have changed
 gui_RecalcSize();

 // merge was okay
 return TRUE;
}

mcMoveCursorRes mcNumberHelpers::gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 int n;

 // up/down movements (don't care about actual cursor position)
 if (flag == mcMCF_UP)
  return mcMCR_SETFOCUS_ABOVE;
 if (flag == mcMCF_DOWN)
  return mcMCR_SETFOCUS_BELOW;

 switch (flag) {
 case mcMCF_LEFT:

  if (mgui_nCursorPos > 0) {
   // cursor is somewhere inside num; we still
   // have space on the left
   mgui_nCursorPos--;

  } else if (mgui_nCursorPos == 0) {
   // the cursor is at the left of the leftmost digit of
   // this element... moving cursor left, focus is not
   // our any more
   return mcMCR_SETFOCUS_PREVIOUS;
  }
  break;

 case mcMCF_RIGHT:
  n = data_Get().GetNumOfDigits(); // how many chars is the base long ?

  if (mgui_nCursorPos < n) {
   // cursor is somewhere inside num; we still
   // have space on the right
   mgui_nCursorPos++;

  } else {

   // the cursor is at the rightmost digit of this
   // element... moving cursor right, focus is not
   // our any more
   return mcMCR_SETFOCUS_NEXT;
  }
  break;

 case mcMCF_UP:
 case mcMCF_DOWN:
  break;  // already checked (just to avoid warnings)
    }

    // everything was okay
    return mcMCR_OKAY;
}

int mcNumberHelpers::gui_BaseMoveCursorUsingPoint(wxDC &hDC, const wxPoint &pt)
{
 int w, h, r, n;
 wxRect rc;

 // be sure given pointer is okay
 mcASSERT(pt.x > 0 && pt.y > 0, wxT("Invalid pointer"));

 // find the nearest digit to the given poit
 w = gui_GetWidthOfChar(&hDC, this);
 h = gui_GetHeightOfChar(&hDC, this);
 r = data_Get().GetNumOfDigits();

 for (n=0; n < r; n++) {

  // build the rectangle for the n-th digit of this number
  rc.x = n*w;
  rc.width = w;
  rc.y = 0;
  rc.height = h;

  if (rc.Inside(pt)) {

   // test if the cursor is in the left half of this digit
   rc.width /= 2;
   if (rc.Inside(pt))
    mgui_nCursorPos = n;
   else
    mgui_nCursorPos = n+1;
  }
 }

 return mcMCR_OKAY;
}

int mcNumberHelpers::gui_GetBaseRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 wxString tmp = gui_GetStr();
 int n;

 // convert in a string of chars the digits at the left of the cursor,
 // deleting all the digits on the right respect the cursor position 
 tmp = tmp.Left(mgui_nCursorPos);

 // set the cursor position next to the first mgui_nCursorPos
 // digits (in coord. relative to this element) of this element
 gui_SelectStyle(hDC);
 pt->x = gui_GetWidthOf(&hDC, tmp);
 pt->y = 0;

 // if we are at the leftmost digit of this mcNumber, this
 // function will return the height of an empty string...
 // it's better check this special case
 n = ((tmp.Length() == 0) ?
  gui_GetHeightOfChar(&hDC, this) :
  gui_GetHeightOf(&hDC, tmp));

 return n;
}

void mcNumberHelpers::gui_GetBaseCursorPos(mcCursorPos &cp) const
{
 // if cursor is at the left of the leftmost digit, it's at the
 // beginning of this element
 if (mgui_nCursorPos == 0) {
  cp.gui_Push(mcCP_BEGIN);
  return;
 }

 // if the cursor is at the right of the rightmost digit (and the
 // element hasn't got a visible exponent), cursor is at the end
 if (mgui_nCursorPos == (int)gui_GetStr().Len()) {
  cp.gui_Push(mcCP_END);
  return;
 }

 // cursor must be somewhere inside the base
 cp.gui_Push(mgui_nCursorPos);
}

void mcNumberHelpers::gui_SetBaseCursorPos(const mcCursorPos &cp)
{
 if (cp.isEnd())
  // if there's no exp, the rightmost digit of this mcNumber is
  // the rightmost digit of the base; otherwise set the cursor
  // position at "cnumber level" but at the end of the exp...
  mgui_nCursorPos = gui_GetStr().Len();
 else if (cp.isBegin())
  // mgui_nCursorPos=0 always means cursor is at the xmost
  // digit of the entire mcNumber
  mgui_nCursorPos = 0;
}






// ----------------------------------------
// mcNUMBERIO
// ----------------------------------------

bool mcNumberHelpers::io_isBeginChar(const wxString &str) const
{
 if (str.IsNumber() && mcNumberHelpers::gui_isDigit(str.GetChar(0)))
  return TRUE;
 return FALSE;
}

wxXml2Node mcNumberHelpers::io_GetBaseMathML(bool bGetPresentation) const
{
 if (bGetPresentation) {

  // create an <mn> tag
  return wxXml2Node(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mn"),
      data_Get().GetExtStr());

 } else {

  // create a <cn> tag
  return wxXml2Node(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("cn"),
      data_Get().GetExtStr());
 }
}

wxString mcNumberHelpers::io_GetBaseInlinedExpr() const
{
 // just do a number2string conversion
 return data_Get().GetSmartStr();
}

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

 if (tag.GetChildren().GetType() != wxXML_TEXT_NODE) {

  // ooooooops
  pErr = wxT("The MathML to import is not valid MathML 2.0\n")
    wxT("or there was an error while parsing it.");
  return FALSE;
 }

 // extract data & check it
 data_Set(tag.GetChildren().GetContent());
 data_AddProperty(mcEP_INITIALIZED);

 // everything should be perfect
 return TRUE;
}

bool mcNumberHelpers::io_ImportBaseInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 // extract data
 *count = 0;
 for (int i=0; i < (int)str.Len(); i++) {
  wxChar c = str.GetChar(i);
  if (mcNumberHelpers::gui_isDigit(c) || c == wxT('.') || c == wxT(','))
   (*count)++;  // advance number-lenght counter
  else
   break;  // all the digits must be adjacent....
 }

 mcASSERT(*count > 0, wxT("There should be at least one digit..."));

 // extract the actual info
 data_Set(str.Left(*count));
 data_AddProperty(mcEP_INITIALIZED);

 return TRUE;
}





// ----------------------------------------
// mcNUMBERMATH - basic operations
// ----------------------------------------

bool mcNumberHelpers::math_CanBeAddedWith(const mcElement &p) const
{ 
 if (p.data_GetType() == mcET_NUMBER)
  return TRUE;

 // mcExpElement::math_MultiplyBy would fail because it assumes always a 
 // mcExpElement and all other mcExpElement-derived classes already
 // implement the add() operation for mcNumber...
 return FALSE;
}

bool mcNumberHelpers::math_CanBeMultWith(const mcElement &p) const
{
 // if this number is zero then it can be multiplied by everything:
 // the result will always be zero.
 if (data_Get() == 0.0)
  return TRUE;
 return math_CanBeAddedWith(p);
}

bool mcNumberHelpers::math_CanBeDivBy(const mcElement &p) const
{
 if (math_isZero(p)) return FALSE;

 // if this number is zero then it can be divided by everything:
 // the result will always be zero.
 if (data_Get() == 0.0)
  return TRUE;

 // otherwise, a number can be divided only by another number...
 if (p.data_GetType() != mcET_NUMBER)
  return FALSE;

 mcNumber n(p);
 if (math_isValid() && n.math_isValid()) {
  
  // do we have to care about integers/floating-point ?
  // anyway if one of the two numbers is not integer,
  // then we must perform floating-point division 
  // (maybe it will be transformed into an integer later
  //  in a simplify step...)
  if (!mcNumberHelpers::smath_bUseIntegersWhenPossible ||
   !this->data_Get().isInteger() || !n.data_Get().isInteger())
   return TRUE;
  
  // this number and its divisor are integers; to have the result
  // integer, this number can be divided only by
  // numbers containing us as a factor...
  mcIntegerValue us = mcIntegerValue(data_Get());
  mcIntegerValue it = mcIntegerValue(n.data_Get());
  bool areprime = us.isPrimeTo(it);
  mcMATHLOG(wxT("mcNumberHelpers::math_CanBeDivBy - checking if %s and %s are prime; gcd is %s, res is %d"), 
       us.GetStr().c_str(), it.GetStr().c_str(), us.GCD(it).GetStr().c_str(), areprime);

  if (areprime)
   return FALSE;  // we cannot make result integer !
  return TRUE;
 }
 
 // one of the two numbers is not valid...
 return FALSE;
}

mcBasicOpRes mcNumberHelpers::math_Add(const mcElement &p, mcElement *pp, bool add)
{
 mcASSERT(p.data_GetType() == mcET_NUMBER, wxT("Error in #math_CanBeAddedWith"));
 mcNumber n(p);

 if (add)
  data_Set(data_Get() + n.data_Get());
 else
  data_Set(data_Get() - n.data_Get());

 mcLOG(wxT("mcNumberHelpers::math_Add - ADDING; res is %s"), mcTXTV(data_Get()));

 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcNumberHelpers::math_MultiplyBaseOnlyBy(const mcElement &p, mcElement *pp)
{
 // check for a simple case
 if (data_Get() == 0.0)
  return mcBOR_REMOVE_OPERAND;  // multiplication performed: 0*anything = 0

 // multiply
 mcNumber n(p);
 mcASSERT(p.data_GetType() == mcET_NUMBER, wxT("Error in #math_CanBeMultWith"));

 // here we cannot have problems of approximation: 
 // - if both *this and n are integer, the result will be an integer
 // - if one of *this or n is floating-point, the result will be a floating-point
 //   which will be eventually converted in a fraction by math_Simplify(long flags)
 data_Set(data_Get() * n.data_Get());

 // transform this number in a fraction, if needed
 if (!data_Get().isInteger() && mcNumberHelpers::smath_bUseIntegersWhenPossible) {

  mcIntegerValue n1, n2;
  math_GetNumDen(n1, n2);
  data_Set(n1);

  mcNumber replacement(n2);
  (*pp) = replacement;

  return mcBOR_REPLACE_OPERAND;
 }

 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcNumberHelpers::math_DivideBaseOnlyBy(const mcElement &p, mcElement *pp)
{
 // special case: this number contains a simple zero
 if (data_Get() == 0.0)
  return mcBOR_REMOVE_OPERAND;   // division performed: 0/anything = 0 

 // divide
 mcNumber n(p);
 mcASSERT(!math_isZero(p), wxT("Cannot perform divisions by zero"));
 mcASSERT(p.data_GetType() == mcET_NUMBER, wxT("Error in #math_CanBeDivBy"));
 
 mcRealValue res = data_Get() / n.data_Get();

 // transform this number in a fraction, if needed
 if (!res.isInteger() && mcNumberHelpers::smath_bUseIntegersWhenPossible) {  

  //mcIntegerValue n1, n2;
  //math_GetNumDen(n1, n2);
  mcRationalValue rat(data_Get(), n.data_Get());
  rat.Canonicalize();

  // use the canonicalized num & den
  data_Set(rat.GetNum());
  mcNumber replacement(rat.GetDen());

  mcMATHLOG(wxT("mcNumberHelpers::math_DivideBaseOnlyBy [%s] - dividying by [%s] ")
   wxT("trying to preserve this as a fraction (%s/%s)..."), mcTXTTHIS,
   mcTXT(p), data_Get().GetStr().c_str(), replacement.data_Get().GetStr().c_str());

  (*pp) = replacement;
  return mcBOR_REPLACE_OPERAND;

 } else {

  // if the result is integer or we don't care about the integers/floating-point,
  // we can directly set the result...
  data_Set(res);
 }
 
 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcNumberHelpers::math_MultiplyBaseBy(const mcElement &p, mcElement *pp)
{
 // special case
 if (data_Get() == 0.0)
  return mcBOR_REMOVE_OPERAND;  // multiplication performed: 0*anything = 0

 // wrap the given element into a mcNumber, only after checking
 // for the case above
 mcNumber n(p);

 // multiply taking in count the exponents
 mcASSERT(p.data_GetType() == mcET_NUMBER, wxT("Error in #math_CanBeMultWith"));

 // both the numbers (and their exponents) should be valuables
 mcRealValue n1 = this->math_Evaluate();
 mcRealValue n2 = n.math_Evaluate();
 mcASSERT(n1.isValid() && n2.isValid(), wxT("Error in #math_CanBeMultWith"));

 // just perform a multiplication
 data_Set(n1 * n2);

 // transform this number in a fraction, if needed
 if (!data_Get().isInteger() && mcNumberHelpers::smath_bUseIntegersWhenPossible) {

  mcIntegerValue m1, m2;
  math_GetNumDen(m1, m2);
  data_Set(m1);
  
  mcNumber replacement(m2);
  (*pp) = replacement;

  return mcBOR_REPLACE_OPERAND;
 }

 return mcBOR_REMOVE_OPERAND;
}





// -----------------
// mcNUMBERMATH
// -----------------

bool mcNumberHelpers::math_GetNumDen(mcIntegerValue &num, mcIntegerValue &den)
{
 // try to find the num & den of the generator fraction of this number
 mcRationalValue rat(data_Get());

 // be sure it's a normalized fraction (no common factors between num & den)
 rat.Canonicalize();

 num = rat.GetNum();
 den = rat.GetDen();

 return TRUE;
}

mcFraction mcNumberHelpers::math_TransformInFraction()
{
 mcIntegerValue n, d;
 if (!math_GetNumDen(n, d))
  return NULL;

 // create the element which must be used to replace this number...
 mcFraction f;

 mcNumber num(n);
 mcNumber den(d);

 f.data_GetNum().math_WrapSimple(num);
 f.data_GetDen().math_WrapSimple(den);
 
 return f;
}

bool mcNumberHelpers::math_isZero(const mcElement &p)
{
 if (p.data_GetType() == mcET_NUMBER && 
  mcNumber(p).data_Get() == 0.0)
  return TRUE;
 return FALSE;
}

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

 // now we are sure p is a mcNumber
 if (mcNumber(p).data_Get() == data_Get())
  return TRUE;
 return FALSE;
}

mcExpSimRes mcNumberHelpers::math_SimplifyBase(long flags, mcElement *pnew)
{
 // if this number is not an integer, then transform it !!!
 if (!data_Get().isInteger() && mcNumberHelpers::smath_bUseIntegersWhenPossible) {

  (*pnew) = math_TransformInFraction();
  if ((*pnew) == NULL)
   return mcESR_DONE;
  mcASSERT((*pnew) != mcEmptyElement, wxT("Could not simplify...."));

  return mcESR_REPLACE_THIS;
 }

 // on the base only, no simplifications can be done...
 return mcESR_DONE;
}

mcExpSimRes mcNumberHelpers::math_SimplifyBaseExp(long flags, mcElement *)
{
 // simplify base with the exponent if we can make the
 // resultant number more easier to "use":
 //
 //     2^64      should not be simplified 
 //               (18446744073709551616 is much more cumbersome)
 //     2^3       should be simplified: 8 is shorter & easier to use
 // 
 
 // raise a temporary clone of this element
 mcNumber tmp(this);
 mcRealValue exp = tmp.data_GetExp().math_Evaluate();
 tmp.data_Set(data_Get().pow(exp));
 tmp.data_DestroyExpSub(TRUE);
 
 // and remember how much long it was...
 mcRealValue lenght = tmp.math_GetTotalLenght();
 //delete tmp;
 
 // ... then compare that lenght with the current one...
 if (math_GetTotalLenght() > lenght) {

  // ... and if the raised form is shorter, then raise *this
  mcRealValue exp = data_GetExp().math_Evaluate();
  data_Set(data_Get().pow(exp));
  data_DestroyExpSub(TRUE);
  
  // this element still cannot be used in the next calculations:
  // if we return mcSER_DONE here, we would get these two steps:
  //
  //  3+2^2   ---.     7
  //
  // instead, we want to have:
  //
  //  3+2^2   ---.    3+4     -----.    7
  // 
  return mcESR_NOTFINISHED;

 } else {

  // since the raised form is longer, we should consider
  // to perform something which is the inverse of the process
  // we tried above: we could try to detect if this number is
  // a perfect power of something:
  // since 18446744073709551616 is more cumbersome than 2^64,
  // we should be able to detect such a number and transform
  // it to the relative power...
 }
 
 return mcESR_DONE;
}

mcExpSimRes mcNumberHelpers::math_ExpandBase(long flags, mcElement *)
{
 return mcESR_DONE;
 /*if (

 mcRealValue exp = tmp.data_GetExp().math_Evaluate();
 Set(Get().pow(exp));

 return mcESR_NOTFINISHED;*/
}

mcBasicOpRes mcNumberHelpers::math_MakeReciprocal(mcElement *pp)
{
 mcRealValue tmp = data_Get();

 mcFraction f;
 f.data_SetNum(*mcPolynomialHelpers::smath_pOne);
 f.data_GetDen().math_WrapSimple(this);

 *pp = f;
 return mcBOR_REMOVE_OPERAND;
}

void mcNumberHelpers::math_RaiseBaseTo(mcRealValue n)
{
 data_Set(data_Get().pow(n));
}

void mcNumberHelpers::math_RaiseTo(const mcIntegerValue &n)
{
 mcRealValue res = data_Get().pow(mcRealValue(n));

 mcMATHLOG(wxT("mcNumberHelpers::math_RaiseTo - %s is being raised to %s; result is %s"),
  data_Get().GetStr().c_str(), n.GetStr().c_str(), res.GetStr().c_str());

 data_Set(res);
}

mcMonomial mcNumberHelpers::math_GetBaseLCM(const mcElement &p) const
{
 // just multiply ourselves with the given element
 if (this->data_Get().isInteger() && mcNumber(p).data_Get().isInteger()) {
 
  mcIntegerValue lcm = mcIntegerValue(data_Get()).LCM(mcIntegerValue(mcNumber(p).data_Get()));
  mcNumber res(lcm);
  return res;
 }

 return mcExpElementHelpers::math_GetBaseLCM(p);
}

mcMonomial mcNumberHelpers::math_GetGCD(const mcElement &p) const
{
 // leave the following cases to mcExpElementHelpers:
 // 1) we have the same base (and eventually an exponent) and it's not zero
 // 2) the given element is not a mcNumber
 if (data_GetType() != p.data_GetType())
  return mcExpElementHelpers::math_GetGCD(p);
 if (math_CompareThisOnly(p, FALSE) && 
  data_Get() != 0) // if CompareThisOnly returns TRUE p and *this are identic
  return mcExpElementHelpers::math_GetGCD(p);

 // anyway, we have specifically to handle the following case:
 // 1) the given element is a mcNumber and we have different bases
 // 2) we and the given element are mcNumber set to zero

 // setup some variables...
 mcRealValue n1 = mcNumber(p).math_Evaluate();
 mcRealValue n2 = this->math_Evaluate();

 // by definition GCD(0, 0) = 1
 // by definition GCD can be applied only on integer numbers
 if ((n1 == 0.0 && n2 == 0.0) ||
  (!n1.isInteger() || !n2.isInteger()))
  return *mcMonomialHelpers::smath_pOne; // GCD is 1.0 for non-integer numbers

 // build the result
 mcNumber gcd(mcIntegerValue(n1).GCD(mcIntegerValue(n2)));
 mcMATHLOG(wxT("mcNumberHelpers::math_GetBaseGCD - the gcd between [%s] and [%s] is [%s]"), 
   mcTXTTHIS, mcTXT(p), mcTXT(gcd));

 // and return it
 mcMonomial res;
 res.data_AddElements(&gcd, 1);
 return res;
}

---

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

[ Top ]