campo-sirio/include/real.cpp

#include <ctype.h>
#include <stdlib.h>
#include <gm.h>
 
extern "C" { double pow(double, double); } // Should be #include <math.h>

#include <strings.h>
#include <real.h>

HIDDEN real __tmp_real;
HIDDEN char __string[80];
const real ZERO(0.0);

real::real()
{ dzero(ptr()); }

real::real(const real& b)
{ dcpy(ptr(), b.ptr()); }

real::real(double a)
{ 
  dftodr(ptr(), a, 9);      // Round the number (1.0 is NOT 0.999999999)
  deltrz(ptr(), ptr());      // Delete Trailing zeroes
}

char* real::eng2ita(char* s)
{
	if (s)
	{
		char* dot = strchr(s, '.');
		if (dot) *dot = ',';
	}
	return s;
}

char* real::ita2eng(const char* s)
{
	int j = 0;
	if (s) for (int i = 0; s[i]; i++)
	{
		switch(s[i])
		{
		case ' ':
		case '.':
			break;
		case ',':
			__string[j++] = '.';
			break;
		default :
			__string[j++] = s[i];
			break;
		}
	}
	__string[j] = '\0';
	return __string;
}

bool real::is_real(const char* s)
{ 
  bool ok = FALSE;
	if (s) 
	{
	  while(*s == ' ') s++;     // Remove leading spaces before atod
	  ok = atod(__tmp_real.ptr(), (char*)s) != GM_NULL;
	}  
	return ok;
}

real::real(const char* s)
{
	if (s) 
	  while(*s == ' ') s++;     // Remove leading spaces before atod

	if (s && *s)
		atod(ptr(), (char*)s);
	else
		dzero(ptr());
}

real& real::operator =(const real& b)
{
  dcpy(ptr(), b.ptr());
  return *this;
}

real& real::operator =(double a)
{
  const real n(a);
  operator =(n);
	return *this;
}

real& real::operator +=(const real& b)
{
	dadd(ptr(), ptr(), b.ptr());
	return *this;
}

real& real::operator +=(double a)
{
	__tmp_real = *this;
	adddfd(ptr(), __tmp_real.ptr(), a);
	return *this;
}

real& real::operator -=(const real& b)
{
	__tmp_real = *this;
	dsub( ptr(), __tmp_real.ptr(), b.ptr());
	return *this;
}

real& real::operator *=(const real& b)
{
	dmul( ptr(), ptr(), b.ptr());
	return *this;
}

real& real::operator /=(const real& b)
{                                     
	const DEC* dst = ddiv(ptr(), ptr(), b.ptr());

#ifdef DBG
  if (dst == GM_NULL) 
  {
    errname(__string, gmec());
    error_box("Division error: %s", __string);
  }  
#endif

	return *this;
}

TObject* real::dup() const
{ return new real(*this); }

bool real::is_zero() const
{
	return diszero(ptr());
}

int real::sign() const
{	return dsign(ptr()); }


real real::operator -() const
{
	real n;
	dchgs(n.ptr(), ptr());
	return n;
}


int real::integer() const
{	return dtoi(ptr()); }


// Certified 91%
char* real::string(int len, int dec, char pad) const
{
	__tmp_real = *this;
	if (dec != UNDEFINED) __tmp_real.round(dec);
	else deltrz(__tmp_real.ptr(), __tmp_real.ptr());

//	if (len == 0)
		dtoa(__string, __tmp_real.ptr());
/*		
	else
	{
		char f[16];
		if (dec == UNDEFINED) sprintf(f, "%%%dt", len);
		else
			sprintf(f, "%%%d.%dt", len, dec);
		dsprintf(__string, f, __tmp_real.ptr());
	}

	if (dec <= 0 || dec == UNDEFINED)	// Toglie una eventuale parte decimale .00
	{
		if (dot)
		{
			for (const char* z = dot + 1; *z; z++)
				if (*z != '0') break;
			if (!*z) *dot = '\0';
		}
	}
*/	             
  int lun = strlen(__string);
  
/*  
	char* dot = strchr(__string, '.');
	
	int d = dot ? strlen(dot+1) : 0; // Decimals already there

  if (d < dec)  
  {
    if (dot == NULL) __string[lun++] = '.'); 
	  for (;d < dec; d++) __string[lun++] = '0';   
	  __string[lun] = '\0';
	} else
  if (dec >= 0 && d > dec)
  {
	  *(dot+dec+(dec>0)) = '\0';
	  lun = strlen(__string);
  }                                 
*/                                   
  if (lun < len)
  { 
    const int delta = len - lun;
    for (int i = lun; i >= 0; i--) 
      __string[i+delta] = __string[i];
    for (i = 0; i < delta; i++) __string[i] = pad;  
  }

	return __string;
}

// Certified 99%
char* real::stringa(int len, int dec, char pad) const

{
	string(len, dec, pad);
	if (dec > 0 || dec == UNDEFINED)
		eng2ita(__string);
	return __string;
}


// Certified 75%
char* real::literals() const
{
	const char* primi20[] = { "", "uno","due","tre","quattro",
														"cinque","sei","sette","otto",
														"nove","dieci","undici","dodici",
														"tredici","quattordici","quindici","sedici"
														"diciassette","diciotto","diciannove" };
	const char* decine[] = { "zero", "dieci", "venti", "trenta", "quaranta",
													 "cinquanta", "sessanta", "settanta", "ottanta",
													 "novanta", "cento" };
	const char* uni[] =    { "uno", "mille", "unmilione", "unmiliardo" };

	const char* potenze[] = { "", "mila", "milioni", "miliardi" };

	__tmp_real = *this;
	__tmp_real.round(0);
	TString r(__tmp_real.string(0, 0));
	const bool negativo = r[0] == '-';
	if (negativo)	r.ltrim(1);

	TFixed_string risultato(__string, 80);
	risultato.cut(0);

	TString centinaia(16);

	for (int migliaia = 0; ; migliaia++)
	{
		int v = r.len()-3 ;
		if (v < -2) break;

		if (v < 0) v = 0;
		const int val = atoi(&r[v]);
		r.cut(v);										// Elimina ultimi 3 caratteri

		v = val;
		if (v >= 100)
		{
			const int c = v/100;
			if (c > 1) centinaia = primi20[c];
			else centinaia.cut(0);
			v -= c*100;
			centinaia << "cento";
		}
		const int d = v/10;
		if (d > 1)
		{
			centinaia << decine[d];
			v -= d*10;
		}
		if (v != 1)
		{
			centinaia << primi20[v] << potenze[migliaia];
		} else
		if (val > 1)
		{
			if (d > 1) centinaia.cut(centinaia.len()-1);
			centinaia << "un" << (migliaia ? potenze[migliaia] : "o");
		} else centinaia = uni[migliaia];

		risultato.insert(centinaia, 0);
	}

	if (negativo) risultato.insert("meno", 0);
	return __string;
}


// Certified 75%
char* real::points(int dec) const
{
	const char* str = stringa();
	const int neg = (*str == '-') ? 1 : 0;
	TFixed_string n((char*)str, 24);
	int i;

	int dot = n.find(',');
	if (dot < 0)  dot = n.len();
	  
	if (dec > 0)
	{
	  if (n[dot] == '\0') n << ',';
	  const int d = strlen(str+dot+1);     // Decimals already there
	  if (d <= dec)  
	    for (i = d; i < dec; i++) n << '0';
	  else 
	    n.cut(dot+dec+1);
	}

	for (i = dot-3; i > neg; i -= 3)
		n.insert(".", i);

	return __string;
}


HIDDEN int get_picture_decimals(const TString& picture)
{
	int decimali = 0;
	const int virgola = picture.find(',');
	if (virgola >= 0)
	{
		const int len = picture.len();
		for (int i = virgola+1; i < len; i++)
			if (strchr("#@~", picture[i])) decimali++;
	}
	return decimali;
}


char* real::string(const char* picture) const
{
	if (*picture == '\0') return string();
	if (*picture == '.') return points(atoi(picture+1));
	if (strcmp(picture, "LETTERE") == 0) return literals();

	TString v(string());
	TString f(picture);

	const int voluti = get_picture_decimals(f);
	const int virgola = v.find('.');
	int decimali = (virgola >= 0) ? v.len()-virgola-1 : 0;

	for ( ;voluti > decimali; decimali++) v << '@';
	if (voluti < decimali)
		v.cut(virgola + voluti + (voluti > 0));

	int j = v.len()-1;
	for (int i = f.len()-1; i >= 0 && j >= 0; i--)
	{
		char& z = f[i];
		if (strchr("#@~", z))
		{
			char c = v[j--];
			if (v[j] == '.') j--;
			if (z == '~') c = ' '; else
			if (c == '@') c = (z == '@') ? '0' : ' ';
			z = c;
		}
	}
	for (; i >= 0; i--)
	switch (f[i])
	{
		case '#':
		case '~':
		case '.': f[i] = ' '; break;
		case '@': f[i] = '0'; break;
		default :break;
	}
	return strcpy(__string, f);
}


ostream& operator <<(ostream& out, const real& a)

{
	return out << a.string();
}


istream& operator >>(istream& in, real& a)

{
	in >> __string;
	atod(a.ptr(), __string);
	return in;
}


int real::precision()
{
	return dprec(ptr());
}


real& real::round(int prec)
{
	if (prec < 0)
	{
		const double p = ::pow(10.0, -prec);
		divdfd(ptr(), ptr(), p);
		dround(ptr(), ptr(), 0);
		muldfd(ptr(), ptr(), p);
	}
	else 
	  dround(ptr(), ptr(), prec);
	return *this;
}


real& real::ceil(int prec)
{
	double p = 1.0;
	if (prec)
	{
		p = ::pow(10.0, -prec);
		divdfd(ptr(), ptr(), p);
	}

	DEC integer; dint(&integer, ptr());	// Extract the integer part
	if (disgt(ptr(), &integer))         // If different ...
		addid(ptr(), &integer, 1);        // add 1

	if (prec)
		muldfd(ptr(), ptr(), p);

	return *this;
}


real& real::trunc(int prec)
{
	dtrunc(ptr(), ptr(), prec);
	return *this;
}


real operator +(const real& a, const real& b)

{
	dadd(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real operator +(double a, const real& b)

{
	__tmp_real = a;
	return __tmp_real += b;
}


real operator +(const real& a, double b)

{
	__tmp_real = a;
	return __tmp_real += b;
}


real operator -(const real& a, const real& b)

{
	dsub(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real operator -(double a, const real& b)

{
	__tmp_real = a;
	dsub(__tmp_real.ptr(), __tmp_real.ptr(), b.ptr());
	return __tmp_real;
}


real operator -(const real& a, double b)

{
	__tmp_real = b;
	return __tmp_real -= a;
}


real operator *(const real& a, const real& b)

{
	dmul(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real operator *(double a, const real& b)

{
	muldfd(__tmp_real.ptr(), b.ptr(), a);
	return __tmp_real;
}


real operator *(const real& a, double b)

{
	muldfd(__tmp_real.ptr(), a.ptr(), b);
	return __tmp_real;
}


real operator /(const real& a, const real& b)

{
	ddiv(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real operator /(double a, const real& b)

{
	__tmp_real = a;
	ddiv(__tmp_real.ptr(), __tmp_real.ptr(), b.ptr());
	return __tmp_real;
}


real operator /(const real& a, double b)

{
	__tmp_real = b;
	ddiv(__tmp_real.ptr(), a.ptr(), __tmp_real.ptr());
	return __tmp_real;
}


bool operator >(const real& a, const real& b)
{
	return disgt(a.ptr(), b.ptr());
}


bool operator >(double a, const real& b)
{
//	dftod(__tmp_real.ptr(), a);
//	return disgt(__tmp_real.ptr(), b.ptr());
	const double n = dtodf(b.ptr());
	return a > n;
}


bool operator <(const real& a, const real& b)

{
	return dislt(a.ptr(), b.ptr());
}


bool operator <(double a, const real& b)

{
//	dftod(__tmp_real.ptr(), a);
//	return dislt(__tmp_real.ptr(), b.ptr());
	const double n = dtodf(b.ptr());
	return a < n;
}


bool operator >=(const real& a, const real& b)

{
	return disge(a.ptr(), b.ptr());
}


bool operator >=(double a, const real& b)

{
//	dftod(__tmp_real.ptr(), a);
//	return disge(__tmp_real.ptr(), b.ptr());
	const double n = dtodf(b.ptr());
	return a >= n;
}


bool operator <=(const real& a, const real& b)

{
	return disle(a.ptr(), b.ptr());
}


bool operator <=(double a, const real& b)

{
//	dftod(__tmp_real.ptr(), a);
//	return disle(__tmp_real.ptr(), b.ptr());
	const double n = dtodf(b.ptr());
	return a <= n;
}


bool operator ==(const real& a, const real& b)
{
	return diseq(a.ptr(), b.ptr());
}


bool operator ==(double a, const real& b)
{
	const double n = dtodf(b.ptr());
	return a == n;
}


bool operator !=(const real& a, const real& b)

{
	return !diseq(a.ptr(), b.ptr());
}


bool operator !=(double a, const real& b)

{
	const double n = dtodf(b.ptr());
	return a != n;
}


real operator %(const real& a, const long b)

{
	dmodl(__tmp_real.ptr(), a.ptr(), b);
	return __tmp_real;
}


void swap(real& a, real& b)

{
	SwapDecimal(a.ptr(), b.ptr());
}


real fnc_min(const real& a, const real& b)

{
	dmin(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real fnc_max(const real& a, const real& b)

{
	dmax(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real sqrt(const real& a)

{
	dsqrt(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real sqr(const real& a)

{
	dmul(__tmp_real.ptr(), a.ptr(), a.ptr());
	return __tmp_real;
}


real exp10(const real& a)

{
	dalog(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real pow(const real& a, const real& b)

{
	dpow(__tmp_real.ptr(), a.ptr(), b.ptr());
	return __tmp_real;
}


real exp(const real& a)

{
	dexp(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}

real log10(const real& a)

{
	dlog(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real log(const real& a)

{
	dln(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real sin(const real& a)

{
	dsin(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real cos(const real& a)

{
	dcos(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real tan(const real& a)

{
	dtan(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


real abs(const real& a)

{
	dabs(__tmp_real.ptr(), a.ptr());
	return __tmp_real;
}


///////////////////////////////////////////////////////////
// Distrib
// Oggetto per dividere un real in varie sue percentuali
// in modo che la loro somma dia sempre il real di partenza
///////////////////////////////////////////////////////////


void TDistrib::add(real slice)
{
	if (slice > real(1.0))
		slice /= 100.0;
	CHECK(!_ready,"TDistrib: les jeux sont faits");
	_slices.add(slice);
}

real TDistrib::get()
{
	_ready = TRUE;
	CHECK(_current < _slices.items(), "TDistrib: too many gets");
	real r = _tot*((real&)_slices[_current++]);
	r.round(_decs);
	if (r > _tot - _prog) { r = _tot-_prog; _prog = _tot; }
	else _prog += r;
	return r;
}

void TDistrib::init(const real& r)
{
	_current = 0; _prog = 0;
	_tot = r; _ready = FALSE;
}