d1852229ad
Files correlati : agalib Ricompilazione Demo : [ ] Commento : Implementato di meccanismo generico di blocco degli inserimenti, attivabile nelle singole applicazioni (cg2 e ve0) git-svn-id: svn://10.65.10.50/branches/R_10_00@22420 c028cbd2-c16b-5b4b-a496-9718f37d4682
528 lines
18 KiB
C++
Executable File
528 lines
18 KiB
C++
Executable File
#ifndef __REAL_H
|
|
#define __REAL_H
|
|
|
|
#ifndef __ARRAY_H
|
|
#include <array.h>
|
|
#endif
|
|
|
|
#define ALL_DECIMALS 883
|
|
#define AUTO_DECIMALS -883
|
|
#define AUTO_PRICES_DECIMALS -884
|
|
|
|
#ifdef __LONGDOUBLE__
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class real | Classe per la gestione dei numeri reali
|
|
//
|
|
// @base public | TObject
|
|
class real : public TObject
|
|
|
|
// @comm Questa classe utilizza i long double definiti per Visual C++. Esiste un'altra classe
|
|
// real: per accedere scegliere il tasto successivo (<gt><gt>) dalla barra dei bottoni
|
|
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Numero reale
|
|
long double _dec;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Permette di stampare l'oggetto
|
|
virtual void print_on(ostream& out) const;
|
|
|
|
// @cmember Duplica il numero reale (vedi classe <c TObject>)
|
|
virtual TObject* dup() const;
|
|
// @cmember Traduce in lettere il numero reale
|
|
const char* literals() const;
|
|
// @cmember Inserisce i punti separatori delle migliaia e riempe i decimali
|
|
// alla lunghezza passata (es: 3.000,20)
|
|
const char* points(int decimals = 0) const;
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember long double | operator long double | | Ritorna il numero reale
|
|
operator long double () const
|
|
{ return _dec; }
|
|
|
|
// @cmember Trasforma un numero dal formato inglese (decimali con punto) in
|
|
// formato italiano (decimali con virgola)
|
|
static const char* eng2ita(char* s);
|
|
// @cmember Trasforma un numero dal formato italiano (decimali con virgola) in
|
|
// formato inglese (decimali con punto)
|
|
static const char* ita2eng(const char* s);
|
|
// @cmember Controlla se si tratta di un numero reale (TRUE se vero)
|
|
static bool is_real(const char* n);
|
|
// @cmember Controlla se si tratta di un numero naturale (TRUE se vero)
|
|
static bool is_natural(const char* n);
|
|
// @cmember Controlla se si tratta di uno zero (TRUE se vero)
|
|
static bool is_null(const char* n);
|
|
// @cmember Trasforma un reale in stringa
|
|
const char* string(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Trasforma un reale in stringa (chiama <mf real::string>),
|
|
// ma ritorna il formato italiano
|
|
const char* stringa(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Trasforma un reale in stringa (chiama <mf real::string>),
|
|
// ma ritorna il formato atteso da Excel
|
|
const char* stringe(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Ritorna la stringa con il formato passato
|
|
const char* string(const char* picture) const;
|
|
// @cmember Ritorna la stringa con il formato passato
|
|
const char* format(const char *picture) const;
|
|
|
|
// @cmember Ritorna la precisione del reale (numero di decimali)
|
|
int precision() const;
|
|
// @cmember Controlla se si tratta di un reale uguale 0 (TRUE se 0)
|
|
bool is_zero() const
|
|
{ return _dec == 0.0; }
|
|
// @cmember Ritorna il segno del reale
|
|
int sign() const;
|
|
// @cmember Trasforma il reale in intero (operator int era troppo pericoloso)
|
|
long integer() const;
|
|
|
|
// @cmember Arrotonda al numero di decimali passati
|
|
real& round(int prec = 0) ;
|
|
// @cmember Tronca al numero di decimali passati (default 0)
|
|
real& trunc(int prec = 0) ;
|
|
// @cmember Arrotonda al numero successivo (della precisione passata)
|
|
real& ceil(int prec = 0);
|
|
// @cmember Arrotonda al numero precedente (della precisione passata)
|
|
real& floor(int prec = 0);
|
|
// @cmember Assegna un reale
|
|
real& operator = (const real& a);
|
|
// @cmember Assegna un reale
|
|
real& operator =(long double a);
|
|
// @cmember Assegna un __int64 ad un reale
|
|
void set_int64(__int64 b);
|
|
// @cmember Aggiunge ad un reale il valore passato (passato per indirizzo)
|
|
real& operator +=(long double a);
|
|
// @cmember Sottrae ad un reale il valore passato (passato per indirizzo)
|
|
real& operator -=(long double b);
|
|
// @cmember Moltiplica un reale per il valore passato (passato per indirizzo)
|
|
real& operator *=(long double b);
|
|
// @cmember Divide un reale per il valore passato (passato per indirizzo)
|
|
real& operator /=(long double b);
|
|
// @cmember Ritorna la negazione di un reale (TRUE se 0, altrimenti FALSE)
|
|
bool operator !() const
|
|
{ return _dec == 0.0; }
|
|
// @cmember Ritorna il risultato della differenza tra due reali
|
|
real operator -() const;
|
|
|
|
// @cmember Costruttore
|
|
real();
|
|
// @cmember Costruttore
|
|
real(const real& b);
|
|
// @cmember Costruttore
|
|
real(long double a);
|
|
// @cmember Costruttore
|
|
real(const char* s);
|
|
// @cmember Distruttore
|
|
virtual ~real()
|
|
{}
|
|
};
|
|
|
|
inline long double fnc_min(long double a, long double b){ return a < b ? a : b; }
|
|
inline long double fnc_max(long double a, long double b) { return a > b ? a : b; }
|
|
|
|
long double operator%(const real& a, const real& b);
|
|
void swap(real& a, real& b) ;
|
|
long double sqr(long double) ;
|
|
long double exp10(long double) ;
|
|
|
|
#if _MSC_VER < 1300
|
|
long double sqrt(long double) ;
|
|
long double pow(long double, long double) ;
|
|
long double exp(long double a) ;
|
|
long double log10(long double a) ;
|
|
long double log(long double a) ;
|
|
long double sin(long double a) ;
|
|
long double cos(long double a) ;
|
|
long double tan(long double a) ;
|
|
long double abs(long double a) ;
|
|
#else
|
|
#include <math.h>
|
|
#endif
|
|
|
|
#else
|
|
|
|
#ifndef INCSTR_H
|
|
#include <incstr.h>
|
|
#endif
|
|
|
|
#ifndef GMDOTH
|
|
#include "../gfm/gmsys1.h"
|
|
#include "../gfm/gfd.h"
|
|
#endif
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class real (per GREENLEAF) | Classe per la gestione dei numeri reali
|
|
//
|
|
// @base public | TObject
|
|
class real : public TObject
|
|
|
|
// @comm Questa classe utilizza i DEC definiti per GREENLEAF. Esiste un'altra classe
|
|
// real: per accedere scegliere il tasto precedente (<lt><lt>) dalla barra deo bottoni
|
|
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Numero reale
|
|
DEC _dec;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Permette di stampare l'oggetto
|
|
virtual void print_on(ostream& out) const;
|
|
|
|
// @cmember Duplica il numero reale (vedi classe <c TObject>)
|
|
virtual TObject* dup() const;
|
|
// @cmember Traduce in lettere il numero reale
|
|
const char* literals() const;
|
|
// @cmember Inserisce i punti separatori delle migliaia e riempe i decimali
|
|
// alla lunghezza passata (es: 3.000,20)
|
|
const char* points(int decimals = 0) const;
|
|
|
|
// @access Public Member
|
|
public:
|
|
|
|
|
|
// @cmember Rimuove gli zeri prima della virgola, aggiustando la precisione
|
|
void trail( );
|
|
|
|
// @cmember Trasforma un numero dal formato inglese (decimali con punto) in
|
|
// formato italiano (decimali con virgola)
|
|
static const char* eng2ita(char* s);
|
|
// @cmember Trasforma un numero dal formato italiano (decimali con virgola) in
|
|
// formato inglese (decimali con punto)
|
|
static const char* ita2eng(const char* s);
|
|
// @cmember Controlla se si tratta di un numero reale (TRUE se vero)
|
|
static bool is_real(const char* n);
|
|
// @cmember Controlla se si tratta di un numero naturale intero (TRUE se vero)
|
|
static bool is_natural(const char* n);
|
|
// @cmember Controlla se si tratta di uno zero (TRUE se vero)
|
|
static bool is_null(const char* n);
|
|
|
|
// @cmember Ritorna l'indirizzo del numero reale
|
|
DEC* ptr() const
|
|
{ return (DEC*)&_dec; }
|
|
// @cmember Trasforma un reale in stringa
|
|
const char* string(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Trasforma un reale in stringa (chiama <mf real::string>), ma
|
|
// ritorna il formato italiano
|
|
const char* stringa(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Trasforma un reale in stringa (chiama <mf real::string>),
|
|
//ma ritorna il formato atteso da Excel
|
|
const char* stringe(int len = 0, int dec = UNDEFINED, char pad = ' ') const;
|
|
// @cmember Ritorna la stringa con il formato passato
|
|
const char* string(const char* picture) const;
|
|
// @cmember Ritorna la stringa con il formato passato
|
|
const char* format(const char *picture) const;
|
|
|
|
// @cmember Ritorna la precisione del reale (numero di decimali)
|
|
int precision() const;
|
|
// @cmember Controlla se si tratta di un reale uguale 0 (TRUE se 0)
|
|
bool is_zero() const;
|
|
// @cmember Ritorna il segno del reale
|
|
int sign() const;
|
|
// @cmember Trasforma il reale in intero (operator int era troppo pericoloso)
|
|
long integer() const;
|
|
|
|
// @cmember Arrotonda al numero di decimali passati
|
|
real& round(int prec = 0) ;
|
|
// @cmember Tronca al numero di decimali passati (default 0)
|
|
real& trunc(int prec = 0) ;
|
|
// @cmember Arrotonda al numero successivo (della precisione passata)
|
|
real& ceil(int prec = 0);
|
|
// @cmember Arrotonda al numero precedente (della precisione passata)
|
|
real& floor(int prec = 0);
|
|
// @cmember Assegna un reale
|
|
real& operator =(double a);
|
|
// @cmember Assegna un __int64 ad un reale
|
|
void set_int64(__int64 b);
|
|
// @cmember Assegna un reale (passato per indirizzo)
|
|
real& operator =(const real& b);
|
|
// @cmember Aggiunge ad un reale il valore passato (passato per indirizzo)
|
|
real& operator +=(const real& b);
|
|
// @cmember Aggiunge ad un reale il valore passato
|
|
real& operator +=(double a);
|
|
// @cmember Sottrae ad un reale il valore passato (passato per indirizzo)
|
|
real& operator -=(const real& b);
|
|
// @cmember Moltiplica un reale per il valore passato (passato per indirizzo)
|
|
real& operator *=(const real& b);
|
|
// @cmember Divide un reale per il valore passato (passato per indirizzo)
|
|
real& operator /=(const real& b);
|
|
// @cmember Ritorna la negazione di un reale (TRUE se 0, altrimenti FALSE)
|
|
bool operator !() const
|
|
{ return is_zero(); }
|
|
// @cmember Ritorna il risultato della differenza tra due reali
|
|
real operator -() const;
|
|
|
|
// @cmember Costruttore
|
|
real();
|
|
// @cmember Costruttore
|
|
real(const real& b);
|
|
// @cmember Costruttore
|
|
real(double a);
|
|
// @cmember Costruttore
|
|
real(const char* s);
|
|
// @cmember Distruttore
|
|
virtual ~real()
|
|
{}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Math operators
|
|
///////////////////////////////////////////////////////////
|
|
|
|
ostream& operator <<(ostream& out, const real& a) ;
|
|
istream& operator >>(istream& in, real& a) ;
|
|
|
|
real operator +(const real& a, const real& b) ;
|
|
real operator +(double a, const real& b) ;
|
|
real operator +(const real& a, double b) ;
|
|
real operator -(const real& a, const real& b) ;
|
|
real operator -(double a, const real& b) ;
|
|
real operator -(const real& a, double b) ;
|
|
real operator *(const real& a, const real& b) ;
|
|
real operator *(double a, const real& b) ;
|
|
real operator *(const real& a, double b) ;
|
|
real operator /(const real& a, const real& b) ;
|
|
real operator /(double a, const real& b) ;
|
|
real operator /(const real& a, double b) ;
|
|
|
|
bool operator <(const real& a, const real& b) ;
|
|
bool operator <(double a, const real& b) ;
|
|
bool operator >(const real& a, const real& b) ;
|
|
bool operator >(double a, const real& b) ;
|
|
bool operator <=(const real& a, const real& b) ;
|
|
bool operator <=(double a, const real& b) ;
|
|
bool operator >=(const real& a, const real& b) ;
|
|
bool operator >=(double a, const real& b) ;
|
|
bool operator ==(const real& a, const real& b) ;
|
|
bool operator ==(double a, const real& b) ;
|
|
bool operator !=(const real& a, const real& b) ;
|
|
bool operator !=(double a, const real& b) ;
|
|
|
|
inline bool operator <(const real& a, double b) { return operator >(b, a); }
|
|
inline bool operator >(const real& a, double b) { return operator <(b, a); }
|
|
inline bool operator <=(const real& a, double b) { return operator >=(b, a); }
|
|
inline bool operator >=(const real& a, double b) { return operator <=(b, a); }
|
|
inline bool operator ==(const real& a, double b) { return operator ==(b, a); }
|
|
inline bool operator !=(const real& a, double b) { return operator !=(b, a); }
|
|
|
|
real operator %(const real& a, const real& b) ;
|
|
void swap(real& a, real& b) ;
|
|
const real& fnc_min(const real& a, const real& b) ;
|
|
const real& fnc_max(const real& a, const real& b) ;
|
|
real sqrt(const real& a) ;
|
|
real sqr(const real& a) ;
|
|
real exp10(const real& a) ;
|
|
real pow(const real& a, const real& b) ;
|
|
real exp(const real& a) ;
|
|
real log10(const real& a) ;
|
|
real log(const real& a) ;
|
|
real sin(const real& a) ;
|
|
real cos(const real& a) ;
|
|
real tan(const real& a) ;
|
|
real abs(const real& a) ;
|
|
|
|
#endif
|
|
|
|
// TReal implementato coi maledetti DEC
|
|
|
|
extern const real ZERO;
|
|
extern const real UNO;
|
|
extern const real CENTO;
|
|
|
|
class TDistrib : public TObject
|
|
|
|
// @author:(INTERNAL) Villa
|
|
{
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Totale da ripartire
|
|
real _tot;
|
|
// @cmember:(INTERNAL) Progressivo gia' distribuito
|
|
real _prog;
|
|
// @cmember:(INTERNAL) Pronto per essere usato (tutti gli <mf TDistrib::add> fatti)
|
|
bool _ready;
|
|
// @cmember:(INTERNAL) Percentuali da distribuire
|
|
TArray _slices;
|
|
// @cmember:(INTERNAL) Indice delle percentuali aggiunte o estratte
|
|
int _current;
|
|
// @cmember:(INTERNAL) Precisione
|
|
int _decs;
|
|
|
|
// @access Public Member
|
|
public:
|
|
|
|
// @cmember Aggiunge una percentuale per la ripartizione
|
|
void add(real slice);
|
|
// @cmember Ritorna il successivo degli importi suddivisi
|
|
real get();
|
|
|
|
// @cmember Inizializza il numero di decimali
|
|
void set_dec(int decs) { _decs = decs;}
|
|
|
|
// @cmember Inizializza l'oggetto
|
|
void init(const real& r, bool zap = FALSE);
|
|
|
|
// @cmember Assegnamento di un importo
|
|
void operator =(const real& r)
|
|
{ init(r); }
|
|
// @cmember Ritorna l'ultima percentuale aggiunta
|
|
const real& last_slice() const
|
|
{
|
|
CHECK(_current,"TDistrib: slices not set");
|
|
return (const real&)_slices[_current-1];
|
|
}
|
|
|
|
// @cmember Costruttore
|
|
TDistrib(const real& r,int round=UNDEFINED) : _tot(r), _prog(0.0), _ready(FALSE), _slices(4), _current(0), _decs(round)
|
|
{}
|
|
// @cmember Distruttore
|
|
virtual ~TDistrib()
|
|
{}
|
|
};
|
|
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TGeneric_distrib | Classe per dividere un real in parti fissate
|
|
// in modo che la loro somma dia sempre il real di partenza
|
|
//
|
|
// @base public | TObject
|
|
|
|
class TGeneric_distrib : public TObject
|
|
{
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Totale da ripartire
|
|
real _tot;
|
|
// @cmember:(INTERNAL) Totale parti da distribuire
|
|
real _totslices;
|
|
// @cmember:(INTERNAL) Pronto per essere usato (tutti gli add() fatti)
|
|
bool _ready;
|
|
// @cmember:(INTERNAL) Percentuali da distribuire
|
|
TArray _slices;
|
|
// @cmember:(INTERNAL) Indice delle percentuali aggiunte o estratte
|
|
int _current;
|
|
// @cmember:(INTERNAL) Precisione
|
|
int _decs;
|
|
|
|
// @access Public Member
|
|
public:
|
|
|
|
// @cmember Aggiunge una percentuale per la ripartizione
|
|
virtual void add(real slice);
|
|
// @cmember Ritorna il successivo degli importi suddivisi
|
|
virtual real get();
|
|
|
|
// @cmember Inizializza il numero di decimali
|
|
void set_dec(int decs)
|
|
{ _decs = decs;}
|
|
|
|
// @cmember Inizializza l'oggetto
|
|
void init(const real& r, bool zap = false);
|
|
|
|
// @cmember Copia di un TGeneric_distrib
|
|
void copy(const TGeneric_distrib & d);
|
|
|
|
// @cmember Assegnamento di un TGeneric_distrib
|
|
TGeneric_distrib & operator = (const TGeneric_distrib & d) { copy(d); return *this; }
|
|
// @cmember Assegnamento di un importo
|
|
void operator =(const real& r) { init(r); }
|
|
// @cmember Ritorna l'ultima percentuale aggiunta
|
|
const real& last_slice() const
|
|
{
|
|
CHECK(_current,"TGeneric_distrib: slices not set");
|
|
return (const real&)_slices[_current-1];
|
|
}
|
|
|
|
// @cmember Costruttore
|
|
TGeneric_distrib(const TGeneric_distrib & d) { copy(d); }
|
|
// @cmember Costruttore
|
|
TGeneric_distrib(const real& r = ZERO, int round = 0) : _tot(r), _totslices(0.0), _ready(FALSE), _slices(4), _current(0),_decs(round)
|
|
{}
|
|
// @cmember Distruttore
|
|
virtual ~TGeneric_distrib()
|
|
{}
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TImporto | Classe per la definizione di oggetti con sezione e importo
|
|
//
|
|
// @base public | TSortable
|
|
class TImporto : public TSortable
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Sezione alla quale apprtiene l'importo
|
|
char _sezione;
|
|
// @cmember:(INTERNAL) Valore dell'importo
|
|
real _valore;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Permette la comparazione degli importi (0 se uguali in valore
|
|
// ed importo)
|
|
virtual int compare(const TSortable& s) const;
|
|
// @cmember Duplicatore importi
|
|
virtual TObject* dup() const { return new TImporto(_sezione, _valore); }
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Ritorna la sezione dell'importo
|
|
char sezione() const
|
|
{ return _sezione; }
|
|
// @cmember Ritorna il valore dell'importo
|
|
const real& valore() const
|
|
{ return _valore; }
|
|
// @cmember Ritorna il valore dell'importo
|
|
real& valore()
|
|
{ return _valore; }
|
|
|
|
// @cmember Controlla se l'importo e' 0 (in qualsiasi sezione, TRUE se 0)
|
|
bool is_zero() const;
|
|
|
|
// @cmember Assegna l'importo passato
|
|
const TImporto& operator=(const TImporto& i)
|
|
{ return set(i.sezione(), i.valore()); }
|
|
// @cmember Assegna l'importo da una <c TToken string> (sezione ambigua se
|
|
// ZERO)
|
|
const TImporto& operator=(TToken_string& sv);
|
|
// @cmember Aggiunge all'importo l'oggetto passato
|
|
const TImporto& operator+=(const TImporto& i);
|
|
// @cmember Sottrae all'importo l'oggetto passato
|
|
const TImporto& operator-=(const TImporto& i);
|
|
// @cmember Normalizza il segno o la sezione in base al parametro s
|
|
const TImporto& normalize(char s = '\0');
|
|
// @cmember Inverte la sezione dell'importo
|
|
const TImporto& swap_section();
|
|
|
|
// @cmember Assegna sezione ed importo all'oggetto
|
|
const TImporto& set(char s, const real& v);
|
|
// @cmember Setta i due elementi pos e pos+1 della <c TToken_string>
|
|
// al valore dell'importo, lasciando bianco il dare (pos) o l'avere (pos+1)
|
|
const TImporto& add_to(TToken_string& s, int pos) const;
|
|
void reset() { set('D', ZERO); }
|
|
|
|
// @cmember Costruttore
|
|
TImporto(char s = 'D', const real& v = ZERO)
|
|
{ set(s, v); }
|
|
// @cmember Costruttore (copia l'oggetto)
|
|
TImporto(const TImporto& i) : _sezione(i._sezione), _valore(i._valore)
|
|
{}
|
|
};
|
|
|
|
#endif // __REAL_H
|