P:/wx_LIB/Dcml/DecFloat.hpp

Aller à la documentation de ce fichier.

/* Split into .h and a .cpp files later. RK
  http://www.rkaiser.de/rkaiser/DecFPClass/test_rk_cpp.html
  auteur de Decimal floating-point class
Decimal floating-point class


cela ma beaucoup aidé a comprendre les définitions de class avec opérateur,
de plus je fais un mémoire  (document)  ce rapportant  sur  la  donnée  (field)
a l'interieur  d'un programme
les problèmes rencontrés, via disque / écran / liste / interne programme.
comment véhiculer cette zone et comment accéder d'une manière simple.
pour une validation d'acquis (diplôme)

je vous remercie encore pour tout le travail que vous avez fais
je mentionnerai sauf si vous n'êtes pas d'accord votre site et nom comme référence.
translat....
that my helped much has to include/understand the definitions of class with operator,
moreover I make a report (document) this paying on the data (field) has the interior
of a program the encountered problems, via disc/screen/list/intern programs how
to convey this zone and how to reach in a simple way for a validation
of asset (diploma) I still thank you for all the work which you have
make I will mention except if you do not agree your site and name like reference.
*/

//=============================================================================
//=============================================================================
//=============================================================================

#ifndef __DecFloat_hpp__
#define __DecFloat_hpp__

#include <cstring>
#include <stdlib.h>
#include <iostream>
#include <sstream>
 using namespace std;
#define  DECNUMDIGITS 128            // work with up to 128 digits
#define  DEC_English  56             // English wxLANGUAGE_ENGLISH wxwidgets "."
#define  DEC_French   78             // French  wxLANGUAGE_FRENCH  wxwidgets ","
int _EnFr_ = DEC_English;            // constant 0 = English  1 = French

#include <Dcml/decNumber.c>
#include <Dcml/decContext.c>


class DecFloatContext // context wrapper class
{
  decContext set;
 public:

  DecFloatContext(int kind=DEC_INIT_BASE)  // see decContext.c
  {
  decContextDefault(&set, kind);
  set.traps=0; // no traps, thank you
  set.digits=DECNUMDIGITS; // set precision
  }

  // set-functions with parameters and get-functions without ???

  void Precision(int digits) // set precision
  {
  set.digits=digits;
  }

  int Precision()            // get precision
  {
  return set.digits;
  }

  void setClamp(int x)
  {
  set.clamp=x;
  }

#if DECSUBSET
  void setExtended(int e)
  {
  set.extended=e;
  }
#endif

  void setRoundMode(rounding m)
  {
  set.round=m;         // set precision
  }

  void setMaxExponent(int e)
  {
  set.emax=e;
  }

  void setMinExponent(int e)
  {
  set.emin=e;
  }

  decContext* get()
  {
  return &set;
  }

  uint32_t status()
  {
  return set.status;
  }

  string StatusToString() // is the global function from below better???
  {
const  char* s = decContextStatusToString(&set);
  return s;
  }

  bool Conversion_syntax_status()
  {
  return set.status&DEC_Conversion_syntax;
  }
  void Clear_Conversion_syntax_status()
  {
  set.status&=(~(set.status&DEC_Conversion_syntax));
  }
  void ClearStatus()
  {
  set.status=0; // to do: allow only to clear permitted flags, see p. 18
  }             //        get individual status flags
};


DecFloatContext Context(DEC_INIT_DECIMAL128);


string DecContextStatusString()
{
int status=Context.status();
string result;
if (status&DEC_Conversion_syntax    ) result+=string(DEC_Condition_CS)+"; ";
if (status&DEC_Division_by_zero     ) result+=string(DEC_Condition_DZ)+"; ";
if (status&DEC_Division_impossible  ) result+=string(DEC_Condition_DI)+"; ";
if (status&DEC_Division_undefined   ) result+=string(DEC_Condition_DU)+"; ";
if (status&DEC_Inexact              ) result+=string(DEC_Condition_IE)+"; ";
if (status&DEC_Insufficient_storage ) result+=string(DEC_Condition_IS)+"; ";
if (status&DEC_Invalid_context      ) result+=string(DEC_Condition_IC)+"; ";
if (status&DEC_Invalid_operation    ) result+=string(DEC_Condition_IO)+"; ";
#if DECSUBSET
if (status&DEC_Lost_digits          ) result+=string(DEC_Condition_LD)+"; ";
#endif
if (status&DEC_Overflow             ) result+=string(DEC_Condition_OV)+"; ";
if (status&DEC_Clamped              ) result+=string(DEC_Condition_PA)+"; ";
if (status&DEC_Rounded              ) result+=string(DEC_Condition_RO)+"; ";
if (status&DEC_Subnormal            ) result+=string(DEC_Condition_SU)+"; ";
if (status&DEC_Underflow            ) result+=string(DEC_Condition_UN)+"; ";
//if (status&0                        ) result+=string(DEC_Condition_ZE)+";;
return result;
}

//******* rtv_status   true = err      false = ok

bool DecErrStatus()
{
int status=Context.status();
bool err = false;
if (status&DEC_Conversion_syntax    ) err = true;
if (status&DEC_Division_by_zero     ) err = true;
if (status&DEC_Division_impossible  ) err = true;
if (status&DEC_Division_undefined   ) err = true;
if (status&DEC_Inexact              ) err = true;
if (status&DEC_Insufficient_storage ) err = true;
if (status&DEC_Invalid_context      ) err = true;
if (status&DEC_Invalid_operation    ) err = true;

#if DECSUBSET
if (status&DEC_Lost_digits          ) err = true;
#endif
if (status&DEC_Overflow             ) err = true;
if (status&DEC_Clamped              ) err = true;
if (status&DEC_Rounded              ) err = true;
if (status&DEC_Subnormal            ) err = true;
if (status&DEC_Underflow            ) err = true;
//if (status&0                        ) result+=string(DEC_Condition_ZE)+";;
return err;
}
//*** Jean-Pierre  Laroche *********************************************

class DecFloat_ {     // decimal floating-point wrapper class
  decNumber d;

 public:

 // constructors and destructors
  DecFloat_()

  {
  decNumberZero(&d);
  }

  DecFloat_(const char* _X_)
  {
    string Str;
    Str.assign(_X_);
    int loc ;
    loc = Str.rfind( ".", Str.length());
         if(loc < 0) loc = Str.rfind( ",", Str.length());
     if(loc > 0) {
    if ( _EnFr_ == DEC_English ) Str.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) Str.replace(loc, 1, ",");
     }
  decNumberFromString(&d, (char*)Str.c_str(), Context.get()); // cast -- nicht gut ???
  }

  DecFloat_(const string& _X_)
  {
          int loc ;
   string Str = _X_;
    loc = Str.rfind( ".", Str.length());
         if(loc < 0) loc = Str.rfind( ",", Str.length());
     if(loc > 0) {
    if ( _EnFr_ == DEC_English ) Str.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) Str.replace(loc, 1, ",");
     }

  decNumberFromString(&d, (char*)Str.c_str(), Context.get()); // cast -- nicht gut ???
  }

  ~DecFloat_()   { }

 // assignments
  DecFloat_& operator=(const DecFloat_& _X_)
  { // is this necessary ???
  if (this!=&_X_)
    {
      DecFloat_ a=_X_; // nur notwendig, weil Parameter nicht const
      decNumberCopy(&d,&(a.d));

    }
  return *this;
  }
// chg basique fonction original
  DecFloat_& operator=(int _X_)
  {
  char *ps = (char*) malloc(10);
  sprintf( ps, "%d", _X_);

  decNumberFromString(&d, ps, Context.get()); // cast -- nicht gut ???

  return *this;
  }

  DecFloat_& operator=(double _X_)
  {
  char *ps = (char*) malloc(30);
  sprintf( ps, "%f", _X_);
    string Str;
    Str.assign(ps);
    int loc ;
    loc = Str.rfind( ".", Str.length());
         if(loc < 0) loc = Str.rfind( ",", Str.length());
     if(loc > 0) {
    if ( _EnFr_ == DEC_English ) Str.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) Str.replace(loc, 1, ",");
     }

  decNumberFromString(&d, ps, Context.get()); // cast -- nicht gut ???

  return *this;
  }
  DecFloat_& operator=(const char* _X_)
  {
          string Str;
    Str.assign(_X_);
    int loc ;
    loc = Str.rfind( ".", Str.length());
         if(loc < 0) loc = Str.rfind( ",", Str.length());
     if(loc > 0) {
    if ( _EnFr_ == DEC_English ) Str.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) Str.replace(loc, 1, ",");
     }

  decNumberFromString(&d, (char*)Str.c_str(), Context.get()); // cast -- nicht gut ???
  return *this;
  }
  DecFloat_& operator=(const string _X_)
  {
          int loc ;
   string Str = _X_;
    loc = Str.rfind( ".", Str.length());
         if(loc < 0) loc = Str.rfind( ",", Str.length());
     if(loc > 0) {
    if ( _EnFr_ == DEC_English ) Str.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) Str.replace(loc, 1, ",");
     }

  decNumberFromString(&d, (char*)Str.c_str(), Context.get()); // cast -- nicht gut ???
  return *this;
  }
//*********************************************************************
//***************** BEGIN JPL *****************************************
// JPL ------------- avec arrondi ----- // Tronc avec -1---------------
 char *  ToChar(int dec) const
  {

  char * value ;
  char chn[DECNUMDIGITS+14]; // conversion buffer
  decNumber p=d; // only necessary because of non const parameter
 /* rescale */

 if(dec >0) {
   DecFloat_  pp ;

   char * s ;
   s = (char*) malloc(dec+1);
   sprintf(s,"%d",(dec*-1));
  decNumberFromString(&pp.d,s , Context.get()); // cast
  decNumberRescale(&p, &d, &pp.d,Context.get());
 }
 if(dec ==0) {
   DecFloat_  pp ;
   char * s ;
   s = (char*) malloc(dec+1);
   sprintf(s,"%d",dec);
  decNumberFromString(&pp.d,s , Context.get()); // cast
decNumberRescale(&p, &d, &pp.d,Context.get());
 }
 /* end rescale */

decNumberToEngString(&p, chn);

   string x  =chn;
      int loc;
 loc = x.rfind( ".", strlen(chn) );


value = (char*) malloc( strlen(chn) );
 if(dec >0 and loc > 0) {
    if ( _EnFr_ == DEC_English ) x.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) x.replace(loc, 1, ",");
 x.erase(loc+dec+1, x.length()-(loc+dec));
 sprintf(value,"%s",x.data());
 } else {
  if( loc > 0) {
    if ( _EnFr_ == DEC_English ) x.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French ) x.replace(loc, 1, ",");
  }
   if( dec == -1)   x.erase(loc+dec+1, x.length()-(loc+dec)); // Tronc avec -1

    strcpy(value, x.data());
 }
  return value;
  }


// JPL ------------- idem string -------------------------------
   char *  ToChar() const
  {
  char * value ;
  string x ;
  x  = ToStr();
  value = (char*) malloc( x.length());
   sprintf(value,"%s",x.data());
    return value;
  }


// JPL --------------------------------------------
  string ToStr() const
  {
  char str[DECNUMDIGITS+14]; // conversion buffer
  decNumber p=d; // only necessary because of non const parameter
  decNumberToEngString(&p, str);
  string value  =str;
  int loc;
  loc = value.rfind( ".", strlen(str) );
    if( loc > 0) {
    if ( _EnFr_ == DEC_English )  value.replace(loc, 1, ".");
    if ( _EnFr_ == DEC_French )  value.replace(loc, 1, ",");
  }
    return  value;
  }
// JPL --------------------------------------------
  string ToStr(int dec) const
  {
    string  value  ;
     value.append(ToChar(dec));
 return value;

  }
//********************** END JPL *******************************
//**************************************************************

  DecFloat_& operator+=(const DecFloat_& a)
  {

  DecFloat_ x=a;
  decNumberAdd(&d, &d, &(x.d), Context.get());            // a=a+b
  return *this;
  }

  DecFloat_& operator-=(const DecFloat_& a)
  {
  DecFloat_ x=a;
  decNumberSubtract(&d, &d, &(x.d), Context.get());       // a=a-b
  return *this;
  }

  DecFloat_& operator*=(const DecFloat_& a)
  {
  DecFloat_ x=a;
  decNumberMultiply(&d, &d, &(x.d), Context.get());            // a=a+b
  return *this;
  }

  DecFloat_& operator/=(const DecFloat_& a)
  {
  DecFloat_ x=a;
  decNumberDivide(&d, &d, &(x.d), Context.get());            // a=a/b
  return *this;
  }

  DecFloat_& operator%=(const DecFloat_& a)
  {
  DecFloat_ x=a;
  decNumberRemainder(&d, &d, &(x.d), Context.get());            // a=a%b
  return *this;
  }

  DecFloat_& operator-()
  { //??? member function or global function or both
  decNumber x=d;
  decNumberMinus(&d, &x, Context.get());            // -a
  return *this;
  }

  DecFloat_& operator+()
  { //??? member function or global function or both
  decNumber x=d;
  decNumberPlus(&d, &x, Context.get());            // +a
  return *this;
  }

  void Normalize()
  { // ??? member function or global function or both
  decNumber x=d; // necessary ???
  decNumberNormalize(&d, &x, Context.get());
  }

  void Quantize(const DecFloat_& a)
  { // ??? member function or global function or both
  decNumber x=d;
  decNumber y=a.d;
  decNumberQuantize(&d, &x, &y,Context.get());
  }

  void Rescale( int a)
  {
  decNumber x=d;
  DecFloat_  y ;
  y = a;
  decNumberRescale(&d, &x, &y.d,Context.get());
  }

  bool SameQuantum(const DecFloat_& a)
  { // ??? member function or global function or both
  decNumber x=d;
  decNumber y=a.d, z;
  decNumberSameQuantum(&z, &x, &y);
  return !decNumberIsZero(&z);
  }

  DecFloat_ ToIntegralValue()
  { // ??? member function or global function or both
  decNumber x=d; // necessary ???
  decNumberToIntegralValue(&d, &x, Context.get());
  return *this;
  }

  void Trim()
  {
  decNumberTrim(&d);
  }

  friend bool operator==(const DecFloat_& q1, const DecFloat_& q2);
  friend bool operator< (const DecFloat_& q1, const DecFloat_& q2);
  friend istream& operator>>(istream& f, DecFloat_& b);
// ??? besser als Elementfunktion, bzw. auf Basis einer EF
  friend DecFloat_ abs(const DecFloat_& a);
  friend DecFloat_ pow(const DecFloat_& x, const DecFloat_& y); // x^y
  friend DecFloat_ sqrt(const DecFloat_& x);
  friend DecFloat_ min(const DecFloat_& x, const DecFloat_& y);
  friend DecFloat_ max(const DecFloat_& x, const DecFloat_& y);
  friend DecFloat_ DivideInteger(const DecFloat_& x, const DecFloat_& y);
  friend DecFloat_ RemainderNear(const DecFloat_& x, const DecFloat_& y); // x^y

};

// ??? Diese Funktionen entweder als inline (dann sollten sie Einzeiler sein, was
// konstante Referenzparameter vorausssetzt, oder in eine .h und eine .cpp Datei
// aufteilen

inline bool operator==(const DecFloat_& lhs, const DecFloat_& rhs)
{
decNumber d, a=lhs.d, b=rhs.d; // // nur notwendig, weil Parameter nicht const
// Is decNumberCopy necessary here?
decNumberCopy_(&a,&(lhs.d));
decNumberCopy_(&b,&(rhs.d));
// Must lhs and rhs have the same context???
decNumberCompare(&d, &a, &b, Context.get());
// returns 0, if a==b
return decNumberIsZero(&d)==1; // returns 1 if d==0


}

inline bool operator<(const DecFloat_& lhs, const DecFloat_& rhs)
{

decNumber d, a=lhs.d, b=rhs.d; // // nur notwendig, weil Parameter nicht const
// Is decNumberCopy necessary here?
decNumberCopy_(&a,&(lhs.d));
decNumberCopy_(&b,&(rhs.d));
// decNumberCompare(&d, &a, &b, lhs.context.get());
decNumberCompare(&d, &a, &b, Context.get());
// returns 0, if a==b
return (decNumberIsNegative(&d)==1) && (decNumberIsZero(&d)!=1); // returns 1 if d==0
}

// !=, <=, >, >= derived operators

inline bool operator!=(const DecFloat_& x, const DecFloat_& y)
{
return !(x == y);
}

inline bool operator>(const DecFloat_& x, const DecFloat_& y)
{
return y < x;
}

inline bool operator<=(const DecFloat_& x, const DecFloat_& y)
{
return !(y < x);
}

inline bool operator>=(const DecFloat_& x, const DecFloat_& y)
{
return !(x < y);
}



inline DecFloat_ operator+(const DecFloat_& a,const DecFloat_& b)
{
DecFloat_ x=a;
return x+=b;
}

inline DecFloat_ operator*(const DecFloat_& a,const DecFloat_& b)
{
DecFloat_ x=a;
return x*=b;
}

inline DecFloat_ operator-(const DecFloat_& a,const DecFloat_& b)
{
DecFloat_ x=a;
return x-=b;
}

inline DecFloat_ operator/(const DecFloat_& a,const DecFloat_& b)
{
DecFloat_ x=a;
return x/=b;
}

inline DecFloat_ operator%(const DecFloat_& a,const DecFloat_& b)
{
DecFloat_ x=a;
return x%=b;
}

inline DecFloat_ abs(const DecFloat_& a)
{
DecFloat_ result, x=a;
decNumberAbs(&(result.d), &(x.d), Context.get());
return result;
}

inline DecFloat_ pow(const DecFloat_& x, const DecFloat_& y) // x^y
{
DecFloat_ result, a=x, b=y;
decNumberPower(&(result.d), &(a.d), &(b.d), Context.get());
return result;
}

inline DecFloat_ DivideInteger(const DecFloat_& x, const DecFloat_& y) // x^y
{
DecFloat_ result, a=x, b=y;
decNumberDivideInteger(&(result.d), &(a.d), &(b.d), Context.get());
return result;
}

inline DecFloat_ RemainderNear(const DecFloat_& x, const DecFloat_& y) // x^y
{
DecFloat_ result, a=x, b=y;
decNumberRemainderNear(&(result.d), &(a.d), &(b.d), Context.get());
return result;
}

inline DecFloat_ min(const DecFloat_& x, const DecFloat_& y) // x^y
{
DecFloat_ result, a=x, b=y;
decNumberMin(&(result.d), &(a.d), &(b.d), Context.get());
return result;
}

inline DecFloat_ max(const DecFloat_& x, const DecFloat_& y) // x^y
{
DecFloat_ result, a=x, b=y;
decNumberMax(&(result.d), &(a.d), &(b.d), Context.get());
return result;
}

inline DecFloat_ sqrt(const DecFloat_& x)
{
DecFloat_ result, a=x;
decNumberSquareRoot(&(result.d), &(a.d), Context.get());
return result;
}

inline ostream& operator<<(ostream& f, const DecFloat_& b)
{

return f<<b.ToStr();
}

inline istream& operator>>(istream& f, DecFloat_& b)
{
string s;
f>>s;
char* ps=(char*)s.c_str(); // nur notwendig, weil Parameter nicht const
decNumberFromString(&(b.d), ps, Context.get()); // cast -- nicht gut ???
return f;
}

  typedef DecFloat_ DCML;    // I would prefer this name -- Richard


#endif

---