Nytrp

/*
    Nume: Popescu Ionut Gabriel
    Tema: Numere reale mari
    Continut: Definitia clasei pentru lucrul cu numere reale mari
*/

/*
    Observatie
        nr : 0.222 - double
        nr_prec : 0.2219999999999942 - reprezentarea sa (precizie 16)
    Sau:
        nr : 0.456
        nr_prec : 0.4560000000000031 - reprezentarea sa (precizie 16)
*/

// Prevenire multi-incluziune

#ifndef BIGREAL_H_INCLUDED
#define BIGREAL_H_INCLUDED

// Pentru supraincarcare << si >>

#include <iostream>
#include <fstream>

// O cifra ce foloseste 4 biti in loc de 8
// Mai putina memorie folosita (1/2)
// Pentru posibile implementari ulterioare

struct cifra_mica
{
    unsigned char c: 4;
};

// Macro, daca e cifra

#define e_cifra(x) (x >= '0' && x <= '9' ? 1 : 0)

// Modul de depanare

#define DEBUG 0

// Definitia clasei

class BigReal
{
    private:

        char *intreg, *zecimal;  // Vectori pentru cifre
        bool semn;               // Daca numarul e pozitiv sau negativ

        // Metode ajutatoare

        char* intreg_la_sir(int x);                              // Convertire de la intreg la sir de caractere
        char* zecimala_la_sir(double x);                         // Convertire parte zecimala la sir
        char* aduna_siruri(const char *sir1, const char *sir2);  // Adunare 2 siruri de caractere

    public:

        // Constructori si destructor

        BigReal();                 // Constructor fara parametri
        BigReal(int x);            // Constructor cu parametru int
        BigReal(double x);         // Constructor cu parametru double
        BigReal(const char *sir);  // Constructor cu parametru sir
        BigReal(BigReal &ob);      // Constructor de copiere
        ~BigReal();                // Destructor

        // Supraincarcare operator +

        BigReal& operator + (int x);                                // BigReal + int
        BigReal& operator + (double x);                             // BigReal + double
        BigReal& operator + (const char *sir);                      // BigReal + sir
        BigReal& operator + (BigReal &ob);                          // BigReal + BigReal
        friend BigReal& operator + (int x, BigReal &ob);            // int + BigReal
        friend BigReal& operator + (double x, BigReal &ob);         // double + BigReal
        friend BigReal& operator + (const char *sir, BigReal &ob);  // sir + BigReal

        // Supraincarcare operator binar -

        BigReal& operator - (int x);                                // BigReal - int
        BigReal& operator - (double x);                             // BigReal - double
        BigReal& operator - (const char *sir);                      // BigReal - sir
        BigReal& operator - (BigReal &ob);                          // BigReal - BigReal
        friend BigReal& operator - (int x, BigReal &ob);            // int - BigReal
        friend BigReal& operator - (double x, BigReal &ob);         // double - BigReal
        friend BigReal& operator - (const char *sir, BigReal &ob);  // sir - BigReal

        // Supraincarcare operatori unar - si +

        BigReal& operator - ();  // - BigReal
        BigReal& operator + ();  // + BigReal

        // Supraincarcare operator binar *

        BigReal& operator * (int x);                                // BigReal * int
        BigReal& operator * (double x);                             // BigReal * double
        BigReal& operator * (const char *sir);                      // BigReal * sir
        BigReal& operator * (BigReal &ob);                          // BigReal * BigReal
        friend BigReal& operator * (int x, BigReal &ob);            // int * BigReal
        friend BigReal& operator * (double x, BigReal &ob);         // double * BigReal
        friend BigReal& operator * (const char *sir, BigReal &ob);  // sir * BigReal

        // Supraincarcare operator /

        BigReal& operator / (int x);                                // BigReal / int
        BigReal& operator / (double x);                             // BigReal / double
        BigReal& operator / (const char *sir);                      // BigReal / sir
        BigReal& operator / (BigReal &ob);                          // BigReal / BigReal
        friend BigReal& operator / (int x, BigReal &ob);            // int / BigReal
        friend BigReal& operator / (double x, BigReal &ob);         // double / BigReal
        friend BigReal& operator / (const char *sir, BigReal &ob);  // sir / BigReal

        // Supraincarcare operator <

        BigReal& operator < (int x);                                // BigReal < int
        BigReal& operator < (double x);                             // BigReal < double
        BigReal& operator < (const char *sir);                      // BigReal < sir
        BigReal& operator < (BigReal &ob);                          // BigReal < BigReal
        friend BigReal& operator < (int x, BigReal &ob);            // int < BigReal
        friend BigReal& operator < (double x, BigReal &ob);         // double < BigReal
        friend BigReal& operator < (const char *sir, BigReal &ob);  // sir < BigReal

        // Supraincarcare operator <=

        BigReal& operator <= (int x);                                // BigReal <= int
        BigReal& operator <= (double x);                             // BigReal <= double
        BigReal& operator <= (const char *sir);                      // BigReal <= sir
        BigReal& operator <= (BigReal &ob);                          // BigReal <= BigReal
        friend BigReal& operator <= (int x, BigReal &ob);            // int <= BigReal
        friend BigReal& operator <= (double x, BigReal &ob);         // double <= BigReal
        friend BigReal& operator <= (const char *sir, BigReal &ob);  // sir <= BigReal

        // Supraincarcare operator >

        BigReal& operator > (int x);                                // BigReal > int
        BigReal& operator > (double x);                             // BigReal > double
        BigReal& operator > (const char *sir);                      // BigReal > sir
        BigReal& operator > (BigReal &ob);                          // BigReal > BigReal
        friend BigReal& operator > (int x, BigReal &ob);            // int > BigReal
        friend BigReal& operator > (double x, BigReal &ob);         // double > BigReal
        friend BigReal& operator > (const char *sir, BigReal &ob);  // sir > BigReal

        // Supraincarcare operator <=

        BigReal& operator >= (int x);                                // BigReal >= int
        BigReal& operator >= (double x);                             // BigReal >= double
        BigReal& operator >= (const char *sir);                      // BigReal >= sir
        BigReal& operator >= (BigReal &ob);                          // BigReal >= BigReal
        friend BigReal& operator >= (int x, BigReal &ob);            // int >= BigReal
        friend BigReal& operator >= (double x, BigReal &ob);         // double >= BigReal
        friend BigReal& operator >= (const char *sir, BigReal &ob);  // sir >= BigReal

        // Supraincarcare operator ==

        BigReal& operator == (int x);                                // BigReal == int
        BigReal& operator == (double x);                             // BigReal == double
        BigReal& operator == (const char *sir);                      // BigReal == sir
        BigReal& operator == (BigReal &ob);                          // BigReal == BigReal
        friend BigReal& operator == (int x, BigReal &ob);            // int == BigReal
        friend BigReal& operator == (double x, BigReal &ob);         // double == BigReal
        friend BigReal& operator == (const char *sir, BigReal &ob);  // sir == BigReal

        // Supraincarcare operator !=

        BigReal& operator != (int x);                                // BigReal != int
        BigReal& operator != (double x);                             // BigReal != double
        BigReal& operator != (const char *sir);                      // BigReal != sir
        BigReal& operator != (BigReal &ob);                          // BigReal != BigReal
        friend BigReal& operator != (int x, BigReal &ob);            // int != BigReal
        friend BigReal& operator != (double x, BigReal &ob);         // double != BigReal
        friend BigReal& operator != (const char *sir, BigReal &ob);  // sir != BigReal

        // Supraincarcare operator =

        BigReal& operator = (int x);                                // BigReal = int
        BigReal& operator = (double x);                             // BigReal = double
        BigReal& operator = (const char *sir);                      // BigReal = sir
        BigReal& operator = (BigReal &ob);                          // BigReal = BigReal

        // Supraincarcare operatori cast

        operator int ();     // int = BigReal
        operator double ();  // double = BigReal
        operator char* ();   // sir = BigReal

        // Supraincarcare << si >> pentru cout si cin

        friend std::ostream& operator << (std::ostream &flux, BigReal &ob);  // cout << BigReal
        friend std::istream& operator >> (std::istream &flux, BigReal &ob);  // cin >> BigReal

        // Supraincarcare operator ++

        BigReal& operator ++ ();       // ++ BigReal
        BigReal& operator ++ (int x);  // BigReal ++

        // Supraincarcare operator --

        BigReal& operator -- ();       // -- BigReal
        BigReal& operator -- (int x);  // BigReal --

        // Functii pentru acces la date, publice, inline

        char* intoarce_intreg() { return intreg; }    // Intoarce pointerul catre partea intreaga
        char* intoarce_zecimal() { return zecimal; }  // Intoarce pointerul catre partea zecimala

        // Atribuire de valori pentru datele private

        void atribuie_intreg(const char *sir);
        void atribuie_zecimal(const char *sir);

        // DE FACUT: Definitii supraincarcare:
        // - operator +=, -=, *=, /=
};

// Constructor fara parametri

BigReal::BigReal()
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::BigReal()"<<std::endl;

    // Alocare spatiu pentru intreg si zecimal si setare la 0.0

    intreg = new char[2];
    intreg[0] = '0';
    intreg[1] = '\0';

    zecimal = new char[2];
    zecimal[0] = '0';
    zecimal[1] = '\0';

    semn = true;
}

// Constructor cu parametru int

BigReal::BigReal(int x)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::BigReal(int)"<<std::endl;

    // Partea intreaga

    intreg = intreg_la_sir(x);

    // Partea zecimala e 0

    zecimal = new char[2];
    zecimal[0] = '0';
    zecimal[1] = '\0';
}

// Constructor cu parametru double

BigReal::BigReal(double x)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::BigReal(double)"<<std::endl;

    // Pentru partea intreaga, convertim pe aceasta la sir

    intreg = intreg_la_sir((int)x);

    // Pentru partea zecimala folosim functia

    zecimal = zecimala_la_sir(x);
}

// Constructorul pentru parametru sir de caractere

BigReal::BigReal(const char *sir)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::BigReal(const char*)"<<std::endl;

    int i, j, rest = 0;

    // Parcurgem sirul de caractere pana la "." sau ","

    for(i = 0; sir[i] && (sir[i] != '.') && (sir[i] != ','); i++) {}

    // Alocam spatiu (i) pentru partea intreaga si o copiem

    intreg = new char[i + 1];

    for(j = 0; j < i; j++) intreg[j] = sir[j];
    intreg[j] = '\0';

    // Parcurgem sa vedem cate cifre are partea zecimala

    for(j = i + 1; sir[j]; j++) rest++;

    // Copiem partea zecimala

    zecimal = new char[rest + 1];

    for(j = i + 1; j < i + rest + 1; j++) zecimal[j - i - 1] = sir[j];
    zecimal[j - i - 1] = '\0';
}

// Constructorul de copiere

BigReal::BigReal(BigReal &ob)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::BigReal(BigReal&)"<<std::endl;

    char *ps;
    int i, j;

    // Citim partea intreaga si preluam marimea

    ps = ob.intoarce_intreg();
    for(i = 0; ps[i]; i++) {}

    // Alocam spatiu pentru partea intreaga si copiem din ob

    intreg = new char[i + 1];
    for(j = 0; j < i; j++) intreg[j] = ps[j];
    intreg[j] = '\0';

    // Citim partea zecimala si preluam marimea

    ps = ob.intoarce_zecimal();
    for(i = 0; ps[i]; i++) {}

    // Alocam spatiu pentru partea intreaga si copiem din ob

    zecimal = new char[i + 1];
    for(j = 0; j < i; j++) zecimal[j] = ps[j];
    zecimal[j] = '\0';
}

// Supraincarcare operator + pentru adunare BigReal + int

BigReal& BigReal::operator + (int x)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::operator + (int)"<<std::endl;

    BigReal *tmp = new BigReal();

    // Atribuim valorile adunate pointerului pe care il vom returna

    tmp -> atribuie_intreg(aduna_siruri(this -> intreg, intreg_la_sir(x)));
    tmp -> atribuie_zecimal(this -> zecimal);

    return *tmp;
}

// Supraincarcare operator + pentru adunare BigReal + double

BigReal& BigReal::operator + (double x)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::operator + (double)"<<std::endl;

    BigReal *tmp = new BigReal();

    // Atribuim valorile adunate pointerului pe care il vom returna

    tmp -> atribuie_intreg(aduna_siruri(this -> intreg, intreg_la_sir(x)));
    tmp -> atribuie_zecimal(aduna_siruri(this -> zecimal, zecimala_la_sir(x)));

    return *tmp;
}

// Supraincarcare operator + pentru adunare BigReal + BigReal

BigReal& BigReal::operator + (BigReal &ob)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::operator + (BigReal)"<<std::endl;

    BigReal *tmp = new BigReal();

    // Atribuim valorile adunate pointerului pe care il vom returna

    tmp -> atribuie_intreg(aduna_siruri(this -> intreg, ob.intoarce_intreg()));
    tmp -> atribuie_zecimal(aduna_siruri(this -> zecimal, ob.intoarce_zecimal()));

    return *tmp;
}

// Supraincarcare operator + pentru adunare BigReal + const char *

BigReal& BigReal::operator + (const char *sirx)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::operator + (const char *)"<<std::endl;

    BigReal *tmp = new BigReal();

    // Copiem sirul din parametru intr-un alt sir pentru ca trebuie sa il modificam

    int l = 0, k;
    while(sirx[l++]);

    char *sir = new char[l];
    for(k = 0; k < l - 1; k++) sir[k] = sirx[k];
    sir[k] = '\0';

    // Obtinem lungimea

    int i = 0;
    for(i = 0; sir[i] && sir[i] != '.' && sir[i] != ','; i++) {}

    // Daca contine "," sau "."

    if(sir[i] == ',' || sir[i] == '.') tmp -> atribuie_zecimal(&sir[i + 1]);
    else tmp -> atribuie_zecimal("0");

    // Partea ntreaga

    if(i == 0) tmp -> atribuie_intreg("0");
    else
    {
        // Un mic truc pentru viteza mai mare, la partea zecimala plecam de unde incepe
        // Punem NULL unde e virgula (pozitia i) ca sa putem folosi partea intreaga ca sir, direct

        sir[i] = '\0';

        tmp -> atribuie_intreg(sir);
    }

    // Atribuim valorile adunate pointerului pe care il vom returna

    tmp -> atribuie_intreg(aduna_siruri(this -> intreg, tmp -> intoarce_intreg()));
    tmp -> atribuie_zecimal(aduna_siruri(this -> zecimal, tmp -> intoarce_zecimal()));

    return *tmp;
}

// Supraincarcare operator + pentru adunare int + BigReal

BigReal& operator + (int x, BigReal &ob)
{
    return ob + x;
}

// Supraincarcare operator + pentru adunare double + BigReal

BigReal& operator + (double x, BigReal &ob)
{
    return ob + x;
}

// Supraincarcare operator + pentru adunare const char* + BigReal

BigReal& operator + (const char *x, BigReal &ob)
{
    return ob + x;
}

// Supraincarcare operator * pentru BigReal * int

BigReal& BigReal::operator * (int x)
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::operator * (int)"<<std::endl;

    BigReal *tmp = new BigReal();

    // Adunam de x ori si partea intreaga si partea zecimala

    for(int i = 1; i <= x; i++)
    {
        tmp -> atribuie_intreg(aduna_siruri(tmp -> intoarce_intreg(), this -> intreg));
        tmp -> atribuie_zecimal(aduna_siruri(tmp -> intoarce_zecimal(), this -> zecimal));
    }

    return *tmp;
}

// Supraincarcare operator * pentru int * BigReal

BigReal& operator * (int x, BigReal &ob)
{
    return ob * x;
}

// Destructorul

BigReal::~BigReal()
{
    if(DEBUG) std::cout<<"DEBUG: BigReal::~BigReal()"<<std::endl;

    // Eliberare memorie

    delete[] intreg;
    delete[] zecimal;
}

// Conversie manuala a partii zecimale a unui double la sir de caractere

char* BigReal::zecimala_la_sir(double x)
{
    if(DEBUG == 2) std::cout<<"DEBUG: zecimala_la_sir(double)"<<std::endl;

    double nr;
    // int cif, contor0 = 0, contor9 = 0, cifre = 0;
    int lungime_cif = 0, i;
    char cifrute[19];

    char *parte_zecimala;

    // Partea zecimala a parametrului

    nr = x - (int)x;

    // Stupid: scriem in fisier

    std::fstream f("F:/test.txt", std::ios::out);
    f<<nr;
    f.close();

    // Citim ca sir din fisier

    std::fstream g("F:/test.txt", std::ios::in);
    g>>cifrute;
    g.close();

    // Copiem partea zecimala si o returnam

    while(cifrute[lungime_cif++]);

    parte_zecimala = new char[lungime_cif - 2];
    for(i = 0; i < lungime_cif - 3; i++) parte_zecimala[i] = cifrute[i + 2];
    parte_zecimala[i] = '\0';

/*
    // Parcurgem partea zecimala pana intalnim 000000

    while(nr != (double)(int)nr && contor0 <= 6 && contor9 <= 6)
    {
        cif = (int)(nr * 10);

        // Verificam daca suntem la secventa de 000000 sau 999999

        if(cif == 0) contor0++;
        else contor0 = 0;

        if(cif == 9) contor9++;
        else contor0 = 9;

        // Punem cifra in vector si incrementam numarul cifrei

        cifrute[cifre] = cif + 48;
        cifre++;

        nr = double(nr * 10) - (double)(int)(nr * 10);
    }

    // Alocam spatiu pentru partea zecimala

    parte_zecimala = new char[cifre - 6];

    // Copiem cifrele din sirul temporar in partea zecimala

    for(i = 0; i < cifre - 7; i++) parte_zecimala[i] = cifrute[i];
    parte_zecimala[i] = '\0';

    // Returnam pointerul
*/
    return parte_zecimala;
}

// Conversie manuala de la int la sir de caractere

char* BigReal::intreg_la_sir(int x)
{
    if(DEBUG == 2) std::cout<<"DEBUG: intreg_la_sir(int)"<<std::endl;

    char sir[11];  // Maxim 10 cifre (+ \0)
    int i = 0, j;

    // Daca x == 0

    if(x == 0)
    {
        // Partea intreaga va fi 0

        intreg = new char[2];
        intreg[0] = '0';
        intreg[1] = '\0';
    }

    // Daca nu, il transformam in sir

    else
    {
        while(x)
        {
            sir[i++] = x % 10 + 48;  // Codul ASCII al cifrei
            x = x / 10;
        }
        sir[i] = '\0';

        // Alocam spatiu pentru intreg

        intreg = new char[i];

        // Copiem din sirul local in sirul "intreg", ordine inversa

        for(j = 0; j < i; j++) intreg[j] = sir[i - j - 1];

        intreg[i] = '\0';
    }

    return intreg;
}

// Functie pentru setarea valorii intregi a obiectului

void BigReal::atribuie_intreg(const char *sir)
{
    if(DEBUG == 2) std::cout<<"DEBUG: atribuie_intreg(const char *)"<<std::endl;

    int i, j;

    // Daca e deja alocat, eliberam memoria si o alocam din nou, apoi copiem sirul

    if(intreg) delete[] intreg;

    for(i = 0; sir[i] && e_cifra(sir[i]); i++) {}

    intreg = new char[i + 1];

    for(j = 0; j < i; j++) intreg[j] = sir[j];
    intreg[j] = '\0';
}

// Functie pentru setarea valorii zecimale a obiectului

void BigReal::atribuie_zecimal(const char *sir)
{
    if(DEBUG == 2) std::cout<<"DEBUG: atribuie_zecimal(const char *)"<<std::endl;

    int i, j;

    // Daca e deja alocat, eliberam memoria si o alocam din nou, apoi copiem sirul

    if(zecimal) delete[] zecimal;

    for(i = 0; sir[i] && e_cifra(sir[i]); i++) {}

    zecimal = new char[i + 1];

    for(j = 0; j < i; j++) zecimal[j] = sir[j];
    zecimal[j] = '\0';
}

// Functie ce preia ca parametri 2 siruri de caractere, NUMERE si returneaza suma lor ca sir

char* BigReal::aduna_siruri(const char *sir1, const char *sir2)
{
    if(DEBUG == 2) std::cout<<"DEBUG: aduna_siruri(const char *, const char *)"<<std::endl;

    // Determinam rapid lungimile sirurilor

    int lun_1 = 0, lun_2 = 0, ultim;
    while(sir1[lun_1++]);
    while(sir2[lun_2++]);

    // Pozitia ultimei cifre

    ultim = lun_1 > lun_2 ? lun_1 : lun_2;
    ultim++;

    // Alocam spatiu pentru noul sir

    char *suma_s = new char[ultim];
    suma_s[(--ultim)--] = '\0';

    int transport = 0, i, j;
    i = lun_1 - 1;
    j = lun_2 - 1;

    // Facem adunarea cat timp avem acelasi nr. de cifre

    int mic = i < j ? i : j;
    i--;
    j--;

    while(mic--)
    {
        // Daca suma e 0-9

        if(sir1[i] + sir2[j] + transport < 106)
        {
            suma_s[ultim--] = sir1[i] + sir2[j] + transport - 48;  // Cifra din suma celor 2 cifre
            transport = 0;
        }

        // Daca depaseste 9

        else
        {
            suma_s[ultim--] = sir1[i] + sir2[j] + transport - 58;  // Cifra din suma celor 2 cifre
            transport = 1;
        }

        i--;
        j--;
    }

    i++;
    j++;

    // Pentru numar egal de cifre, daca avem sau nu transport

    if(i == 0 && j == 0)
    {
        if(transport) suma_s[0] = '1';
        else
        {
            // Daca nu, cream un nou sir, fara prima cifra (pentru transport)

            char *final;
            int k, lungime = lun_1 > lun_2 ? lun_1 : lun_2;
            final = new char[lungime];
            for(k = 1; k < lungime; k++) final[k - 1] = suma_s[k];
            final[k - 1] = '\0';
            return final;
        }
    }

    //Completam cu cifrele numarului cu mai multe cifre

    if(i)
    {
        // Parcurgem sirul ` si nu uitam de transport

        while(i)
        {
            i--;

            // Daca e 0

            if(sir1[i] + transport == 58)
            {
                suma_s[ultim--] = sir1[i] + transport - 10;
                transport = 1;
            }
            else
            {
                suma_s[ultim--] = sir1[i] + transport;
                transport = 0;
            }
        }

        // Daca avem transport, pe prima pozitie avem 1

        if(transport) suma_s[0] = '1';
        else
        {
            // Daca nu, cream un nou sir, fara prima cifra (pentru transport)

            char *final;
            int k, lungime = lun_1 > lun_2 ? lun_1 : lun_2;
            final = new char[lungime];
            for(k = 1; k < lungime; k++) final[k - 1] = suma_s[k];
            final[k - 1] = '\0';
            return final;
        }
    }
    else if(j)
    {
        // Parcurgem sirul 2 si nu uitam de transport

        while(j)
        {
            j--;

            // Daca e 0

            if(sir2[j] + transport == 58)
            {
                suma_s[ultim--] = sir2[j] + transport - 10;
                transport = 1;
            }
            else
            {
                suma_s[ultim--] = sir2[j] + transport;
                transport = 0;
            }
        }

        // Daca avem transport, pe prima pozitie avem 1

        if(transport) suma_s[0] = '1';
        else
        {
            // Daca nu, cream un nou sir, fara prima cifra (pentru transport)

            char *final;
            int k, lungime = lun_1 > lun_2 ? lun_1 : lun_2;
            final = new char[lungime];
            for(k = 1; k < lungime; k++) final[k - 1] = suma_s[k];
            final[k - 1] = '\0';
            return final;
        }
    }

    // Returnam suma

    return suma_s;
}

// Supraincarcare oeprator << pentru afisare

std::ostream& operator << (std::ostream& flux, BigReal& ob)
{
    if(DEBUG == 2) std::cout<<"DEBUG: operator << (std::ostream&, BigReal&)"<<std::endl;

    // Afisam partea intreaga si partea zecimala

    flux << ob.intoarce_intreg();
    flux << '.';
    flux << ob.intoarce_zecimal();

    // Returnam fluxu, pentru operatii imbricate

    return flux;
}

// Supraincarcare oeprator >> pentru citire (cu ".", "," si filtrare non-cifre)

std::istream& operator >> (std::istream& flux, BigReal& ob)
{
    if(DEBUG == 2) std::cout<<"DEBUG: operator >> (std::istream&, BigReal&)"<<std::endl;

    char sir[1000];
    int i;

    // Atribuim valorile: intreaga si zecimala obiectului ob, dupa citire

    flux >> sir;
    for(i = 0; sir[i] && sir[i] != '.' && sir[i] != ','; i++) {}

    // Daca contine "," sau "."

    if(sir[i] == ',' || sir[i] == '.') ob.atribuie_zecimal(&sir[i + 1]);
    else ob.atribuie_zecimal("0");

    // Partea ntreaga

    if(i == 0) ob.atribuie_intreg("0");
    else
    {
        // Un mic truc pentru viteza mai mare, la partea zecimala plecam de unde incepe
        // Punem NULL unde e virgula (pozitia i) ca sa putem folosi partea intreaga ca sir, direct

        sir[i] = '\0';

        ob.atribuie_intreg(sir);
    }

    // Returnam fluxu, pentru operatii imbricate

    return flux;
}

#endif // BIGREAL_H_INCLUDED