Main page

---

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

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

#ifndef mcPRECOMP
    #include <wx/string.h>

 #include "mc/MathUtils.h"
 #include "mc/Value.h"
#endif


// setup STATIC
int mcValue::m_nMaxValueSharing = -1;

mcIntegerValue *mcIntegerValue::pOne = NULL;
mcIntegerValue *mcIntegerValue::pZero = NULL;
mcIntegerValue *mcIntegerValue::pNAN = NULL;
mcIntegerValue *mcIntegerValue::pPosInf = NULL;
mcIntegerValue *mcIntegerValue::pNegInf = NULL;

mcRealValue *mcRealValue::pOne = NULL;
mcRealValue *mcRealValue::pZero = NULL;
mcRealValue *mcRealValue::pNAN = NULL;
mcRealValue *mcRealValue::pPosInf = NULL;
mcRealValue *mcRealValue::pNegInf = NULL;






// -----------------------------------------------
// GMP alloc/free functions provided by MathCore
// -----------------------------------------------

void *mcGMPAlloc(size_t n)     { return new char[n]; }
void mcGMPFree(void *mem, size_t)   { delete [] ((char *)mem); }

void *mcGMPRealloc(void *mem, size_t oldsize, size_t newsize)   
{
 void *newp = mcGMPAlloc(newsize);

 // copy from old to new and destroy old
 memcpy(newp, mem, mcMIN(oldsize, newsize));
 mcGMPFree(mem, oldsize);

 return newp;
}




// --------------
// mcVALUE
// --------------

void mcValue::Init()  // this one is static
{
 // install our alloc/free functions
 mp_set_memory_functions(mcGMPAlloc, mcGMPRealloc, mcGMPFree);

 // init STATICS
 mcIntegerValue::pNAN = new mcIntegerValue();
 mcIntegerValue::pNAN->math_AddFlag(mcVALUE_NAN_FLAG);
 mcIntegerValue::pPosInf = new mcIntegerValue();
 mcIntegerValue::pPosInf->math_AddFlag(mcVALUE_POSINF_FLAG);
 mcIntegerValue::pNegInf = new mcIntegerValue();
 mcIntegerValue::pNegInf->math_AddFlag(mcVALUE_NEGINF_FLAG);

 mcIntegerValue::pZero = new mcIntegerValue(0);
 mcIntegerValue::pOne = new mcIntegerValue(1);


 mcRealValue::pNAN = new mcRealValue(*mcIntegerValue::pNAN);
 mcRealValue::pPosInf = new mcRealValue(*mcIntegerValue::pPosInf);
 mcRealValue::pNegInf = new mcRealValue(*mcIntegerValue::pNegInf);
 mcRealValue::pZero = new mcRealValue(0.0);
 mcRealValue::pOne = new mcRealValue(1.0);
}

void mcValue::Cleanup()  // this one is static
{
 // delete STATICs
 delete mcIntegerValue::pZero;
 delete mcIntegerValue::pOne;
 delete mcIntegerValue::pNAN;
 delete mcIntegerValue::pPosInf;
 delete mcIntegerValue::pNegInf;

 delete mcRealValue::pZero;
 delete mcRealValue::pOne;
 delete mcRealValue::pNAN;
 delete mcRealValue::pPosInf;
 delete mcRealValue::pNegInf;
}





// ----------------
// mcINTEGERVALUE
// ----------------

mcIntegerValue::mcIntegerValue(const mcRationalValue &m)
{ InternalInit(m.GetFlags()); mpz_set_q(MP(), m.cMP()); }

mcIntegerValue::mcIntegerValue(const mcRealValue &m)
{ InternalInit(m.GetFlags()); mpz_set_f(MP(), m.cMP()); }

wxString mcIntegerValue::GetStr() const
{
 // conversion GMP -> string
 char *buf = new char[mpz_sizeinbase(cMP(), 10)+5];
 mpz_get_str(buf, 10, cMP()); 
 wxString str(GMP2WX(buf));
 delete [] buf;

 // when this is a null value, GMP does not return anything...
 if (str.IsEmpty()) str = wxT("0");

 return str;
}




// ----------------
// mcRATIONALVALUE
// ----------------

mcRationalValue::mcRationalValue(const mcIntegerValue &m)
{ InternalInit(m.GetFlags()); mpq_set_z(MP(), m.cMP()); }

mcRationalValue::mcRationalValue(const mcRealValue &m)
{ InternalInit(m.GetFlags()); mpq_set_f(MP(), m.cMP()); }

mcRationalValue::mcRationalValue(const mcIntegerValue &num, const mcIntegerValue &den)
{ InternalInit(); mpq_set_si(MP(), num.GetLong(), den.GetLong()); }

wxString mcRationalValue::GetStr() const
{
 // conversion GMP . string
 //wxString str;
 
 // in this way we would get something like: num/den
 /*int n = mpz_sizeinbase (mpq_numref(cMP()), 10)
   + mpz_sizeinbase (mpq_denref(cMP()), 10) + 3;
 mpq_get_str(str.GetWriteBuf(n), 10, cMP());*/

 // convert us to a mcRealValue...
 mcRealValue r(*this);
 return r.GetStr();
/*
 str.UngetWriteBuf();
 return str;*/
}

int mcRationalValue::GetFractionalDigitCount(int max) const
{
 mcRealValue n = *this;
 int count = 0;

 // just multiply by 10 the number until we get an integer...
 while (!n.isInteger()) {

  // avoid problems with numbers with infinite fractional digits...
  if (count == max)
   break;

  n *= 10.0;
  count++;
 }

 // check if we still have fractional digits in "n"
 if (!n.isInteger())
  return -1;  // more than "max" digits

 return count;
}

mcIntegerValue mcRationalValue::MakeInteger(int max) const
{
 int count = GetFractionalDigitCount(max);
 mcRealValue n(*this);

 if (count > 0) {

  // if the given number has a valid number of fractional digits,
  // we can make it integer without problems...
  //mcRealValue multiplier(10);, count);
  mcRealValue res = n * mcRealValue(10).pow(count);
  mcASSERT(res.isInteger(), wxT("Something wrong in the algorithm"));

  return mcIntegerValue(res);

 } else if (count == 0) {

  // the given number should be an integer stored in a double...
  mcASSERT(isInteger(), wxT("Fractional digit count should not be zero then !!!"));
  return *this;
 } 

 // count is less than zero;
 // the given number has more fractional digits than "max"; approx
 // it anyway...
 mcRealValue res = n * mcRealValue(10).pow(max);
 return mcIntegerValue(res.floor());
}




// ----------------
// mcREALVALUE
// ----------------

wxString mcRealValue::GetBaseStr(int *p, int digits, int *n) const
{
 // conversion GMP -> string
 mp_exp_t exp;
 char *buf = new char[digits+5];
 mpf_get_str(buf, &exp, 10, digits, cMP());
 wxString str(GMP2WX(buf));
 delete [] buf;

 // when this is a null value, GMP does not return anything...
 if (str.IsEmpty()) { str = wxT("0"); exp=1; }
 if (p) *p = (int)exp;
 if (n) *n = exp - str.Len() + (str.GetChar(0) == wxT('-') ? 1 : 0);

 return str;
}

wxString mcRealValue::GetStr(int digits) const
{
 int exp, n;
 wxString str = GetBaseStr(&exp, digits, &n);

 // Since in the string returned by GMP a dot is implicit before
 // the first digit, numbers are returned in the format:
 //
 // 5      .    0.5*10^1    (str = 5, exp = 1)
 // 43     .    0.43*10^2   (str = 43, exp = 2)
 //
 // and for numbers with trailing zeros:
 //
 // 1000   .    0.1*10^4      (str = 1, exp = 4)
 // 45000  .    0.45*10^5     (str = 45, exp = 5)
 //
 // So, to make the string clearer, we will append E followed by the
 // exponent only for those numbers whose str's lenght does not coincide
 // the exponent... 
 if (n > 0) str += wxString::Format(wxT("E%d"), exp-1);

 return str;
}

wxString mcRealValue::GetSmartStr(int threshold, int digits) const
{
 int exp, n;
 wxString str = GetBaseStr(&exp, digits, &n);

 // see the comments in #GetStr
 if (n < 0) {
  // we need a decimal point
  wxString left = str.Left(exp);
  if (left.IsEmpty()) left = wxT("0");

  str = left + wxT(".") + str.Right(-n);  
  
 } else if (n == 0) {
  
  // the string is already okay
  return str;
  
 } else {
  
  if (n < threshold)  // exp is small enough ?
   str += wxString(wxT('0'), n);  // like in GetExtStr
  else
   str += wxString::Format(wxT("E%d"), exp-1);  // like in GetStr
 }
 
 return str;
}

wxString mcRealValue::GetExtStr(int digits) const
{
 int exp, n;
 wxString str = GetBaseStr(&exp, digits, &n);

 // unroll all the exponent digits... see #GetStr
 if (n > 0) str += wxString(wxT('0'), n);

 return str;
}

mcRealValue mcRealValue::GetFromDigitRange(int begin, int end, int digits) const
{
 wxString str = GetSmartStr(digits);

 // if not specified, the end is the last digit
 if (end == -1) end = str.Len();

 // extract the string from the number string
 str = str.Mid(begin, end-begin);

 return mcRealValue(str);
}

int mcRealValue::GetNumOfDigits(int digits) const
{
 // just use this simple function
 wxString tmp = GetSmartStr(digits);
 return tmp.Len(); // num of digits = lenght of the string
}

mcRealValue mcRealValue::InsertDigit(wxChar digittoadd, int pos, int digits) const
{
 // add a digit using strings
 wxString str = GetSmartStr(digits);

 // if this is the string expression of this number:
 //                   
 //        ABCD|EF     where | is the "digits" variable (= 4 in this case)
 // #digit 0123445
 //
 if (pos == -1) pos = str.Len();
 str = str.Left(pos) + digittoadd + str.Right(str.Len()-pos);

 // reconvert the string to a number 
 return mcRealValue(str);
}

mcRealValue mcRealValue::DeleteDigit(int n, int digits) const
{
 wxString str = GetSmartStr(digits);
 mcASSERT(n > 0, wxT("The digit to delete must not be zero-based"));

 // remove the n-th digit
 str.Remove(n-1, 1);

 // reconvert the string to a number
 return mcRealValue(str);
}
/*
bool mcRealValue::isInteger() const
{
 unsigned long f = floor();
 unsigned long c = ceil();
 unsigned long t = trunc();
 return (f == c) && (c == t);
}
*/

---

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

[ Top ]