#ifndef __FRACTION_H
#define __FRACTION_H

#ifndef __STRINGS_H
#include <strings.h>
#endif

#ifndef __REAL_H
#include <real.h>
#endif

#ifndef __IOSTREAM_H
#include <iostream.h>
#endif

// @doc EXTERNAL

// @class fraction (per GREENLEAF) | Classe per la gestione dei numeri frazionari
//
// @base public | TObject

class fraction : public TObject

// @author:(INTERNAL) Guido
{
  // @access:(INTERNAL) Private Member
  // @cmember:(INTERNAL) Numero fractione
  friend fraction operator *(const fraction & a, __int64 b);
	friend fraction operator /(const fraction & a, __int64 b);
	friend fraction operator /(__int64 a, const fraction & b);
  
  __int64 _num;
	__int64 _den;

  // @access Protected Member
protected:
	// @cmember Duplica il numero frazionario (vedi classe <c TObject>)
  virtual TObject* dup() const;
	// @cmember assegna il numero frazionario (vedi classe <c TObject>)
	void simplify();
	void build_fraction(const char * s);
  
	// @access Public Member
public:
  // @cmember Controlla se si tratta di un fractione uguale 0 (TRUE se 0)
  bool is_zero() const  { return _num == 0;}
  // @cmember Ritorna il segno del fraction
  int sign() const ;
  // @cmember Trasforma il fractione in intero (operator int era troppo pericoloso)
  __int64 integer() const { return _num / _den;}

  // @cmember Assegna una frazione
  fraction& operator =(const fraction& b);
  // @cmember Aggiunge ad un frazione il valore passato
  fraction& operator +=(const fraction& b);
  // @cmember Sottrae ad un frazione il valore passato
  fraction& operator -=(const fraction& b);
  // @cmember Moltiplica un fractione per il valore passato (passato per indirizzo)
  fraction& operator *=(const fraction& b);
  // @cmember Divide un fractione per il valore passato (passato per indirizzo)
  fraction& operator /=(const fraction& b);
  // @cmember Ritorna la negazione di un frazione (TRUE se 0, altrimenti FALSE)
  bool operator !() const { return is_zero(); }
  // @cmember Ritorna il risultato della differenza tra due frazioni
  fraction operator -() const;

  // @cmember converte la frazione in reale
  operator real() const;

  // @cmember Costruttore
  fraction();
  // @cmember Costruttore
  fraction(const real & b)  { build_fraction(b.stringa()); }
  fraction(__int64 num, __int64 den = 1) : _num(num), _den(den) { simplify();}
  // @cmember Costruttore
  fraction(const fraction& b) ;
  // @cmember Costruttore
  fraction(const char* s) { build_fraction(s); }
  // @cmember Distruttore
  virtual ~fraction()
  {}
};

///////////////////////////////////////////////////////////
// Math operators
///////////////////////////////////////////////////////////

fraction operator +(const fraction& a, const fraction& b) ;
inline fraction operator +(const real& a, const fraction& b) { return ::operator +((fraction)a, b);}
inline fraction operator +(const fraction& a, const real& b) { return ::operator +(b, a);}
inline fraction operator +(const fraction& a, __int64 b) { return ::operator +(a, (fraction)b);}
inline fraction operator +(__int64 a, const fraction& b) { return ::operator +(b, a);}
fraction operator -(const fraction& a, const fraction& b) ;
inline fraction operator -(const real& a, const fraction& b) { return ::operator -((fraction)a, b);}
inline fraction operator -(const fraction& a, const real& b) { return ::operator -(a, (fraction)b);}
inline fraction operator -(const fraction& a, __int64 b) { return ::operator -(a, (fraction)b);}
inline fraction operator -(__int64 a, const fraction& b) { return ::operator -((fraction)a, b);}
fraction operator *(const fraction& a, const fraction& b) ;
inline fraction operator *(const real& a, const fraction& b) { return ::operator *((fraction)a, b);}
inline fraction operator *(const fraction& a, const real& b) { return ::operator *(b, a);}
fraction operator *(const fraction& a, __int64 b);
inline fraction operator *(__int64 a, const fraction& b) { return ::operator *(b, a);}
fraction operator /(const fraction& a, const fraction& b) ;
inline fraction operator /(const real& a, const fraction& b) { return ::operator /((fraction)a, b);}
inline fraction operator /(const fraction& a, const real& b) { return ::operator /(a, (fraction)b);}
fraction operator /(const fraction& a, __int64 b);
fraction operator /(__int64 a, const fraction& b);

bool operator <(const fraction& a, const fraction& b) ;
inline bool operator <(const real& a, const fraction& b) { return ::operator < (a, (real)b);}
inline bool operator <(const fraction& a, const real& b) { return ::operator <((real) a, b);}
bool operator >(const fraction& a, const fraction& b) ;
inline bool operator >(const real& a, const fraction& b)  { return ::operator > (a, (real)b);};
inline bool operator >(const fraction& a, const real& b) { return ::operator >((real) a, b);}
bool operator <=(const fraction& a, const fraction& b) ;
inline bool operator <=(const real& a, const fraction& b) { return ::operator <= (a, (real)b);}
inline bool operator <=(const fraction& a, const real& b) { return operator <=((real) a, b);}
bool operator >=(const fraction& a, const fraction& b) ;
inline bool operator >=(const real& a, const fraction& b) { return operator >=(a, (real) b);}
inline bool operator >=(const fraction& a, const real& b) { return operator >=((real) a, b);}
bool operator ==(const fraction& a, const fraction& b) ;
inline bool operator ==(const real& a, const fraction& b) { return operator ==(a, (real) b);}
inline bool operator ==(const fraction& a, const real& b) { return operator ==((real) a, b);}
bool operator !=(const fraction& a, const fraction& b) ;
inline bool operator !=(const real& a, const fraction& b) { return operator !=(a, (real) b);}
inline bool operator !=(const fraction& a, const real& b) { return operator !=((real) a, b);}

real operator %(const real& a, const real& b) ;
void swap(fraction& a, fraction& b) ;
const fraction& fnc_min(const fraction& a, const fraction& b);
const fraction& fnc_max(const fraction& a, const fraction& b);

#endif