791 lines
14 KiB
C++
Executable File
791 lines
14 KiB
C++
Executable File
#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;
|
|
}
|
|
|
|
bool real::is_natural (const char *s)
|
|
{
|
|
bool ok = s && *s != '\0';
|
|
if (ok)
|
|
{
|
|
while (*s == ' ')
|
|
s++; // Remove leading spaces before
|
|
|
|
if (*s)
|
|
{
|
|
while (isdigit(*s))
|
|
s++;
|
|
ok = *s == '\0';
|
|
}
|
|
else ok = FALSE;
|
|
|
|
}
|
|
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)
|
|
{
|
|
adddfd (ptr (), ptr (), a);
|
|
return *this;
|
|
}
|
|
|
|
real & real::operator -= (const real & b)
|
|
{
|
|
dsub (ptr (), 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;
|
|
}
|
|
|
|
long real::integer () const
|
|
{
|
|
return (long)dtodf(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 ());
|
|
|
|
dtoa (__string, __tmp_real.ptr ());
|
|
int 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);
|
|
TString80 r (__tmp_real.string (0, 0));
|
|
const bool negativo = r[0] == '-';
|
|
if (negativo)
|
|
r.ltrim (1);
|
|
|
|
TFixed_string risultato (__string, 80);
|
|
risultato.cut (0);
|
|
|
|
TString80 centinaia;
|
|
|
|
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";
|
|
} else centinaia.cut(0);
|
|
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 (0, dec);
|
|
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 ();
|
|
|
|
TString80 v (string());
|
|
TString80 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 (j >= 0 && v[j] == '.')
|
|
j--;
|
|
if (z == '~')
|
|
c = ' ';
|
|
else
|
|
{
|
|
if (c == '@')
|
|
c = (z == '@') ? '0' : ' ';
|
|
else
|
|
if (c == '-' && f[i+1] == '.')
|
|
{
|
|
f[i+1] = '-';
|
|
c = ' ';
|
|
}
|
|
}
|
|
|
|
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 != 0)
|
|
{
|
|
p = ::pow (10.0, -prec);
|
|
divdfd (ptr (), ptr (), p);
|
|
}
|
|
|
|
DEC integer;
|
|
dint (&integer, ptr ()); // Extract the integer part
|
|
|
|
if (disgt (ptr (), &integer)) // If positive ...
|
|
addid (ptr (), &integer, 1); // ... add 1
|
|
else
|
|
dcpy(ptr(), &integer); // If negative
|
|
|
|
if (prec != 0)
|
|
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, bool zap)
|
|
{
|
|
_current = 0; _prog = 0;
|
|
_tot = r; _ready = FALSE;
|
|
if (zap) _slices.destroy();
|
|
}
|