Beispiel #1
0
void Pile<T>::DUP() const{
    if(*this->isEmpty()){
        throw CalculException("Operation impossible la pile est vide");
    }

    T * copy = *this->top().clone();
    addPile(copy);
}
Beispiel #2
0
void OperateurBinaire::afficher(std::ostream& f) const
{
    switch(typeoperation)
    {
        case(PLUS): f<<"+"; break;
        case(MINUS): f<<"-"; break;
        case(DIV): f<<"/"; break;
        case(MULT): f<<"*"; break;
        case(MODULO): f<<"MOD"; break;
        case(POW): f<<"^"; break;
        default : throw CalculException("Type d'operateur inconnu."); break;
    }
}
Beispiel #3
0
Donnee* Expression::defiler()
{
    if(taille>0)
    {
        Cellule* cell = tete;
        tete = cell->getSucc();
        Donnee* data = cell->getContent()->clone();
        cell->~Cellule();
        --taille;
        return data;
    }
    else
        throw CalculException("Expression vide.");
}
Beispiel #4
0
void Expression::afficher(std::ostream& f) const {
    Cellule* cell = tete;
    if(cell)
    {
        f<<"'";
        while(cell)
        {
            cell->getContent()->afficher(f);
            cell = cell->getSucc();
            if(cell) f<<" ";
        }
        f<<"'";
    }
    else
        throw CalculException("Expression vide.");
}
void Collection_Onglet::saveContexte() {
    std::ofstream fsave("save.dat");
    if(!fsave) {
        throw CalculException("Ouverture fichier impossible, sauvegarde non assuree");
    }
    Onglet *o=0;
    fsave << "<root>";
    for(int i=0; i<Collection_Onglet::GetInstance().size(); ++i) {
        o = Collection_Onglet::GetInstance().at(i);
        fsave << "<onglet>";
        fsave << o->sauverContexte();
        fsave << "</onglet>";
    }

    fsave << "</root>";
    fsave.close();
}
Beispiel #6
0
Reel::Reel(Donnee *d){
    Reel* test1 = dynamic_cast< Reel*>(d);
    Rationnel* test2 = dynamic_cast< Rationnel*>(d);
    Entier* test3 = dynamic_cast< Entier*>(d);

    if (test1){
               val=test1->getVal();
              }
    else if (test2){
                val=float(*test2);
              }
    else if (test3){
               val=test3->getVal();
              }

    else throw CalculException("Erreur inattendue au niveau de la formation d'un reel par une donne. Cf reel.cpp");
}
Beispiel #7
0
Donnee* Expression::clone() const {
    if(!tete)
    {
        throw CalculException("Expression vide.");
        return 0;
    }
    Cellule* cell = new Cellule(tete->getContent()->clone());
    Cellule* newhead = cell;
    Cellule* next = tete->getSucc();
    while(next)
    {
        cell->setSucc(new Cellule(next->getContent()->clone()));
        next = next->getSucc();
        cell = cell->getSucc();
    }
    return new Expression(newhead,taille);
}
Beispiel #8
0
T& Pile<T>::SUM(const unsigned int x) const{
    if(x==0 || x>this->size()) {
        throw CalculException("SUM impossible, mauvais x");
    }
    Pile<T>& p = this->pileResultat();
    Operation::Plus * plus = new Operation::Plus();
    T* res;
    int i =0;
    while(i<x) {
        res = plus->calcul(p);
        i++;
        i++;
        p.addPile(res);
    }
    delete p;
    delete plus;
    T& ref = *res;
    return ref;
}
Beispiel #9
0
void Expression::enfiler_fin(Donnee *elt)
{
    if(!tete)
        throw CalculException("Expression vide.");
    else
    {
        Cellule* cell = tete;
        while(cell->getSucc())
            cell = cell->getSucc();
        Expression* exp = dynamic_cast<Expression*>(elt);  //Si on enfile une expression
        if(exp)
        {
            taille += exp->longueur();
            cell->setSucc(exp->tete); //On la concatene
        }
        else
        {
            cell->setSucc(new Cellule(elt->clone()));
            ++taille;
        }
    }
}
Beispiel #10
0
void Pile<T>::DROP(){
    if(this->isEmpty()) {
        throw CalculException("Operation impossible, la pile est vide");
    }
    delete this->pop();
}
Beispiel #11
0
void OperateurBinaire::Calculer(Pile* stack){

    Donnee* dB= stack->depiler();                           // On commence par depiler les 2 dernieres donnees entrees. B est la derniere donne empile, donc le second membre de l'operation. La seconde donne empile est le premier membre, A.
    Donnee* dA= stack->depiler();

    Expression* testExA =dynamic_cast<Expression*>(dA);     // On verifie d'abord si l'une des 2 donnees n'est pas une expression. Il faudra alors cancatener l'expression avec l'autre donnee et l'operateur.
    Expression* testExB =dynamic_cast<Expression*>(dB);

    if (testExA) {
        testExA->enfiler_fin(dB);
        testExA->enfiler_fin(this);                           // Si le premier membre est une expression, il faut enfiler le second membre et l'operateur à la fin successivement.
        stack->empiler(testExA);
    }

    else if (testExB) {
           testExB->enfiler_debut(dA);
           testExB->enfiler_fin(this);                          // Si le second membre est une expression et que le premier ne l'est pas, il faut enfiler le premier membre au début de B, et l'operateur à la fin.
           stack->empiler(testExB);
         }
    else {

    Complexe* testC1 = dynamic_cast< Complexe*>(dA);
    Complexe* testC2 = dynamic_cast< Complexe*>(dB);
    Reel* test1 = dynamic_cast< Reel*>(dA);
    Reel* test2 = dynamic_cast< Reel*>(dB);
    Rationnel* test3 = dynamic_cast< Rationnel*>(dA);
    Rationnel* test4 = dynamic_cast< Rationnel*>(dB);
    Entier* testE1 = dynamic_cast< Entier*>(dA);
    Entier* testE2 = dynamic_cast< Entier*>(dB);


    if ( testC1 || testC2){                 //On a au moins un complexe. On travaille donc avec des complexes.

        Complexe A= Complexe(dA);           // constructeur de complexe a partir de donnee.
        Complexe B= Complexe(dB);

            switch (typeoperation) {        // Switch selon le type de l'operation, attribut de l'operateurBinaire.

                case (PLUS):
                {
                    Complexe *X= new Complexe(A+B);
                    stack->empiler(X);
                }

                    break;

                case(MINUS):
                {
                    Complexe *X= new Complexe(A-B);
                    stack->empiler(X);
                }
                    break;


                case(DIV):
                {
                if (B.CNull()){                                         // Cas ou une division par zero est tentée.
                                     stack->empiler(dA);
                                     stack->empiler(dB);
                                     throw CalculException("Division par zero impossible.");
                               }

                else {

                        Complexe *X= new Complexe(A/B);
                        stack->empiler(X);
                     }
                }
                    break;

                case (MULT):
                {
                    Complexe *X= new Complexe(A*B);
                    stack->empiler(X);
                }
                    break;

                case(MODULO):
                {
                    stack->empiler(dA);                         // Modulo inappliquable sur complexes. On re-empile donc les donnees dans le bon ordre.
                    stack->empiler(dB);
                    throw CalculException("Modulo inappliquable pour Complexe.\nFonction utilisable avec Entier uniquement.");
                }
                    break;

                case (POW):
                {
                    stack->empiler(dA);
                    stack->empiler(dB);
                    throw CalculException("POW inappliquable pour Complexe.");
                }

                    break;

            }
    }

    else if ( test1 || test2 ) {     //Au moins un reel

        Reel A=Reel(dA);
        Reel B=Reel(dB);

        Reel* dC = new Reel;

        switch (typeoperation) {
            case (PLUS):
                        {
                                    *dC=(A+B);
                                    stack->empiler(dC);
                        }
                break;

            case(MINUS):
                        {
                                    *dC=(A-B);
                                    stack->empiler(dC);
                        }

                break;

            case(DIV):
                        {

                            if (B.getVal()==0){                                         //Cas ou une division par zero est tentée.
                                                stack->empiler(dA);
                                                stack->empiler(dB);
                                                throw CalculException("Division par zero impossible.");
                                            }

                            else {
                                *dC=(A/B);
                                stack->empiler(dC);
                                }
                        }

                break;

            case (MULT):
                        {
                                    *dC=(A*B);
                                    stack->empiler(dC);
                        }

                break;

            case(MODULO):
        {
            stack->empiler(dA);
            stack->empiler(dB);
            throw CalculException("Modulo inappliquable pour Reel.\nFonction utilisable avec Entier uniquement.");
        }

                break;

            case (POW):
        {
                    *dC=(A*B);
                    *dC=Reel(pow(A.getVal(),B.getVal()));
                    stack->empiler(dC);
        }

                break;

        }
    }

    else if ( test3 || test4 ) {        //Au moins un rationnel

        Rationnel A=Rationnel(dA);
        Rationnel B=Rationnel(dB);

        Rationnel* dC = new Rationnel;

            switch (typeoperation) {
            case (PLUS):
                       {

                            *dC=(A+B);
                            stack->empiler(dC);
                       }
                break;
            case(MINUS):
                        {
                             *dC=(A-B);
                             stack->empiler(dC);
                        }

                break;

            case(DIV):
                        {

                             if (B.getNumerateur().getVal()==0){
                                                 stack->empiler(dA);
                                                 stack->empiler(dB);
                                                 throw CalculException("Division par zero impossible.");
                                             }

                             else {
                                 *dC=(A/B);
                                 stack->empiler(dC);
                                 }
                        }

                break;

            case (MULT):
                        {
                             *dC=(A*B);
                             stack->empiler(dC);
                        }

                break;

            case(MODULO):
                        {
                            stack->empiler(dA);
                            stack->empiler(dB);
                            throw CalculException("Modulo inappliquable pour Rationnel.\nFonction utilisable avec Entier uniquement.");
                        }
                break;

            case (POW):
                        {
                             *dC=Rationnel(pow(A.getNumerateur(),float(B)),pow(A.getDenumerateur(),float(B)));
                             stack->empiler(dC);
                        }

                break;

        }
    }

    else if ( testE1 || testE2){    //On a forcément deux entiers

                Entier* C = new Entier;

                // Il est inutile de creer des variables locales entieres et de proceder a une conversion a partir de donnee, puisque testE1 et testE2 sont tout les 2 forcéments des entiers. Nous pouvons donc les utiliser dans le calcul.

            switch (typeoperation) {

                case (PLUS):
                            {
                                *C = *testE1 + *testE2;
                                stack->empiler(C);
                            }

                    break;

                case(MINUS):
                            {
                                *C = *testE1 - *testE2;
                                stack->empiler(C);

                            }
                    break;


                case(DIV):

                            {
                            if (testE2->getVal()==0){
                                                stack->empiler(testE1);
                                                stack->empiler(testE2);
                                                throw CalculException("Division par zero impossible.");
                                            }

                            else {
                                    *C = *testE1 / *testE2;
                                    stack->empiler(C);
                                }



                            }
                    break;

                case (MULT):

                            {
                                *C = *testE1 * *testE2;
                                stack->empiler(C);
                            }
                    break;

                case(MODULO):

                            {
                                if (testE2->getVal()==0){
                                                            stack->empiler(testE1);
                                                            stack->empiler(testE2);
                                                            throw CalculException("Modulo: Division par zero impossible.");
                                                        }

                                else {
                                        *C = *testE1 % *testE2;
                                        stack->empiler(C);
                                     }

                            }
                    break;

                case (POW):
                            {
                                *C = Entier(pow(testE1->getVal(),testE2->getVal()));
                                stack->empiler(C);
                            }

                    break;

            }

    }

    else throw CalculException("Echec de la reconnaissance du type de 2 variables entrees.\nSource: Operateurbinaire.cpp. ");

    }
}