private static Expression ObtenierOperation(char p_operation,  Expression p_operande1,  Expression p_operande2)
                 {
                        Expression operation  =  null;
                        switch (p_operation)
                         {
                                case  '+' :
                                    operation  =  new Addition(p_operande1,  p_operande2);
                                    break;
                                case  '-' :
                                    operation  =  new Soustraction(p_operande1,  p_operande2);
                                    break;
                                case  '*' :
                                    operation  =  new Multiplication(p_operande1,  p_operande2);
                                    break;
                                case  '/' :
                                    operation  =  new Division(p_operande1,  p_operande2);
                                    break;
                default:
                                    break;
                            
            }

                        return operation;
                    
        }
Exemplo n.º 2
0
        public Operation Clone()
        {
            Operation op;
            if (this is Addition)
            {
                op = new Addition();

            } else if (this is Soustraction)
            {
                op = new Soustraction();

            }else if (this is Multiplication)
            {
                op = new Multiplication();

            }
            else if (this is Division)
            {
                op = new Division();
            }
            else
            {
                op = new sqrt();
            }

            op.setOperandeA(this.operandeA);
            op.setOperandeB(this.operandeB);
            return op;
        }
Exemplo n.º 3
0
        static void Main(string[] args)
        {
            Expression exp1 = new Addition(new Nombre(1), new Addition(new Nombre(1), new Soustraction(new Nombre(4), new Nombre(2))));

            // double resultat = exp1.SEvaluer();
            Console.WriteLine(exp1.Formate());
            Console.ReadLine();

            Expression exp2 = new Soustraction(new Nombre(8), new Nombre(4));

            //   double resultatS = exp2.SEvaluer();
            Console.WriteLine(exp2.Formate());
            Console.ReadLine();
        }
Exemplo n.º 4
0
        static void Main(string[] args)
        {
            Expression exp1      = new Addition(new Nombre(33), new Addition(new Nombre(33), new Nombre(11)));
            int        resultat1 = exp1.Evalue();

            Expression exp2      = new Soustraction(new Nombre(33), new Nombre(33));
            int        resultat2 = exp2.Evalue();


            Expression exp3      = new Addition(new Nombre(7), new Soustraction(new Nombre(3), new Nombre(6)));
            int        resultat3 = exp3.Evalue();

            exp3.Formate();
        }
Exemplo n.º 5
0
        static void Main(string[] args)
        {
            Expression expNb       = new Nombre(33);
            int        resultatNb  = expNb.Evalue();
            string     strResultNb = expNb.Formate();

            Expression exp1       = new Addition(new Nombre(33), new Nombre(33));
            int        resultat1  = exp1.Evalue();
            string     strResult1 = exp1.Formate();

            Expression exp2       = new Addition(new Nombre(33), new Addition(new Nombre(33), new Nombre(11)));
            int        resultat2  = exp2.Evalue();
            string     strResult2 = exp2.Formate();

            Expression exp3       = new Soustraction(new Nombre(3), new Nombre(6));
            int        resultat3  = exp3.Evalue();
            string     strResult3 = exp3.Formate();

            Expression exp4       = new Addition(new Soustraction(new Nombre(3), new Nombre(6)), new Nombre(7));
            int        resultat4  = exp4.Evalue();
            string     strResult4 = exp4.Formate();

            Expression exp5       = new Soustraction(new Nombre(3), new Addition(new Nombre(6), new Nombre(7)));
            int        resultat5  = exp5.Evalue();
            string     strResult5 = exp5.Formate();

            Expression exp6       = new Soustraction(new Addition(new Nombre(6), new Nombre(7)), new Nombre(3));
            int        resultat6  = exp6.Evalue();
            string     strResult6 = exp6.Formate();

            Expression exp7       = new Soustraction(new Soustraction(new Nombre(3), new Nombre(9)), new Nombre(6));
            int        resultat7  = exp7.Evalue();
            string     strResult7 = exp7.Formate();

            Expression exp8 = new Soustraction(new Soustraction(new Soustraction(new Nombre(65), new Nombre(13)),
                                                                new Soustraction(new Nombre(3), new Nombre(6))), new Soustraction(new Nombre(74), new Nombre(22)));
            int    resultat8  = exp8.Evalue();
            string strResult8 = exp8.Formate();
        }
Exemplo n.º 6
0
        private void clic_operateur(object sender, EventArgs e)
        {
            if (enterPressed)   //SI on a appuyé sur entrée avant de taper sur un opérateur, on veut travailler sur le résultat d'une opération précédente
            {
                labelOperation.Text = "";
                enterPressed        = false;
            }

            String text = ((Button)sender).Text;              //On récupère le texte de l'opérateur

            if (text != "(" && text != ")" && text != "sqrt") //Si ce n'est pas une parenthèses ou une racine, alors on ajoute dans le libellé de l'opération la valeur saisie dans le champ résultat
            {
                labelOperation.Text += resultat.Text;

                if (text != "=") //Si c'est un opérateur de type + - * /, on l'ajoute également pour avoir "XVal+"
                {
                    if (racineEnCours)
                    {
                        labelOperation.Text += ")";
                        racineEnCours        = false;
                        nbParentheses--;
                    }
                    labelOperation.Text += text;
                }
            }

            //if (resultat.Text != "" && resultat.Text != "(" && resultat.Text != ")")
            //{
            //    try
            //    {
            //        val.valeur = Decimal.Parse(resultat.Text, System.Globalization.CultureInfo.InvariantCulture);
            //    }
            //    catch (FormatException)
            //    {
            //    }
            //}

            if (resultat.Text != "")
            {
                try
                {
                    val.valeur = Decimal.Parse(resultat.Text, System.Globalization.CultureInfo.InvariantCulture); //On ajoute la valeur saisie dans la variable val, en convertissant la virgule selon la langue du système
                    //Pour éviter les problèmes avec les "." et les ","
                }
                catch (FormatException)
                {
                    resultat.Text = "Erreur format saisie!";
                }
            }

            if (!val.valeur.HasValue)
            {
                //Si malgré les tests précédents, val n'est pas initialisée, alors elle est nulle
                val.valeur = 0;
            }

            switch (text)                       //On commence le traitement de l'opérateur
            {
            case "+":                           //Si c'est une addition
                Operation add = new Addition(); //On crée notre operation tampon

                if (nbParentheses != 0)         //Si on a une parenthèse ouverte
                {
                    if (OpParentheses != null)  //Si une opération est en cours dans les parenthèses
                    {
                        if (OpParentheses is Soustraction)
                        {
                            add.setOperandeA((decimal)val.valeur);
                            OpParentheses = add;
                        }
                        else
                        {
                            if (OpParentheses.getOperandeB() == null)
                            {
                                OpParentheses.setOperandeB((decimal)val.valeur);        //On ajoute seulement si notre opération n'est pas complète (si on vient de fermer une parenthèse, l'opération est déjà remplie)
                            }
                            if (OpParentheses != troncParentheses)
                            {
                                troncParentheses.setOperandeB(OpParentheses.Clone());
                                OpParentheses = troncParentheses;
                            }
                            add.setOperandeA(troncParentheses.Clone());
                            OpParentheses    = add;
                            troncParentheses = OpParentheses;
                        }
                    }
                    else
                    {
                        add.setOperandeA((decimal)val.valeur);
                        troncParentheses = add;
                        OpParentheses    = troncParentheses;
                    }
                }
                else                                                            //Si on a pas de parenthèse ouverte
                {
                    if (OperationEnCours != null)                               //Si une opération est en cours
                    {
                        if (OperationEnCours.getOperandeB() == null)            //Si l'opérandeB n'a pas été remplie (cas d'un calcul sans parenthèses)
                        {
                            OperationEnCours.setOperandeB((decimal)val.valeur); //on ajoute a l'opération en cours l'opérande tapée
                        }
                        if (OperationEnCours != tronc)                          //Si l'opération en cours est avancée dans l'arbre des opérations
                        {
                            tronc.setOperandeB(OperationEnCours.Clone());       //On ajoute l'opération en cours dans l'arbre
                        }
                        add.setOperandeA(tronc.Clone());                        //On ajoute a l'opération tampon l'arbre
                        OperationEnCours = add;                                 //L'opération en cours devient la dernière opération de l'arbre
                        tronc            = OperationEnCours;                    //On avance l'opération dans le tronc pour le calcul final
                    }
                    else
                    {
                        add.setOperandeA((decimal)val.valeur); //Si l'opération est null, on est dans une nouvelle opération
                        OperationEnCours = add;                //L'opération en cours devient l'opération tampon
                        tronc            = OperationEnCours;   //On avance l'opération dans l'arbre
                    }
                }

                break;

            case "-":
                Operation sub = new Soustraction();

                if (nbParentheses != 0)        //Si on a une parenthèse ouverte
                {
                    if (OpParentheses != null) //Si une opération est en cours dans les parenthèses
                    {
                        if (OpParentheses is Soustraction)
                        {
                            sub.setOperandeA((decimal)val.valeur);
                            OpParentheses = sub;
                        }
                        else
                        {
                            if (OpParentheses.getOperandeB() == null)
                            {
                                OpParentheses.setOperandeB((decimal)val.valeur);        //On ajoute seulement si notre opération n'est pas complète (si on vient de fermer une parenthèse, l'opération est déjà remplie)
                            }
                            if (OpParentheses != troncParentheses)
                            {
                                troncParentheses.setOperandeB(OpParentheses.Clone());
                                OpParentheses = troncParentheses;
                            }
                            sub.setOperandeA(troncParentheses.Clone());
                            OpParentheses    = sub;
                            troncParentheses = OpParentheses;
                        }
                    }
                    else
                    {
                        sub.setOperandeA((decimal)val.valeur);
                        troncParentheses = sub;
                        OpParentheses    = troncParentheses;
                    }
                }
                else                                                            //Si on a pas de parenthèse ouverte
                {
                    if (OperationEnCours != null)                               //Si une opération est en cours
                    {
                        if (OperationEnCours.getOperandeB() == null)            //Si l'opérandeB n'a pas été remplie (cas d'un calcul sans parenthèses)
                        {
                            OperationEnCours.setOperandeB((decimal)val.valeur); //on ajoute a l'opération en cours l'opérande tapée
                        }
                        if (OperationEnCours != tronc)                          //Si l'opération en cours est avancée dans l'arbre des opérations
                        {
                            tronc.setOperandeB(OperationEnCours.Clone());       //On ajoute l'opération en cours dans l'arbre
                        }
                        sub.setOperandeA(tronc.Clone());                        //On ajoute a l'opération tampon l'arbre
                        OperationEnCours = sub;                                 //L'opération en cours devient la dernière opération de l'arbre
                        tronc            = OperationEnCours;                    //On avance l'opération dans le tronc pour le calcul final
                    }
                    else
                    {
                        sub.setOperandeA((decimal)val.valeur); //Si l'opération est null, on est dans une nouvelle opération
                        OperationEnCours = sub;                //L'opération en cours devient l'opération tampon
                        tronc            = OperationEnCours;   //On avance l'opération dans l'arbre
                    }
                }

                break;

            case "*":
                Operation mul = new Multiplication();

                if (nbParentheses != 0)
                {
                    if (OpParentheses != null)
                    {
                        if (OpParentheses is Addition || OpParentheses is Soustraction)
                        {
                            mul.setOperandeA((decimal)val.valeur);
                            OpParentheses = mul;
                        }
                        else
                        {
                            if (OperationEnCours.getOperandeB() == null)                //Si l'opérandeB n'a pas été remplie (cas d'un calcul sans parenthèses)
                            {
                                OperationEnCours.setOperandeB((decimal)val.valeur);     //on ajoute a l'opération en cours l'opérande tapée
                            }
                            if (OpParentheses != troncParentheses)
                            {
                                troncParentheses.setOperandeB(OpParentheses.Clone());
                                OpParentheses = troncParentheses;
                            }
                            mul.setOperandeA(troncParentheses.Clone());
                            OpParentheses    = mul;
                            troncParentheses = OpParentheses;
                        }
                    }
                    else
                    {
                        mul.setOperandeA((decimal)val.valeur);
                        troncParentheses = mul;
                        OpParentheses    = troncParentheses;
                    }
                }
                else
                {
                    if (OperationEnCours != null)
                    {
                        if (OperationEnCours is Addition || OperationEnCours is Soustraction)
                        {
                            mul.setOperandeA((decimal)val.valeur);
                            OperationEnCours = mul;
                        }
                        else
                        {
                            if (OperationEnCours.getOperandeB() == null)                //Si l'opérandeB n'a pas été remplie (cas d'un calcul sans parenthèses)
                            {
                                OperationEnCours.setOperandeB((decimal)val.valeur);     //on ajoute a l'opération en cours l'opérande tapée
                            }
                            if (OperationEnCours != tronc)
                            {
                                tronc.setOperandeB(OperationEnCours.Clone());
                                OperationEnCours = tronc;
                            }
                            mul.setOperandeA(tronc.Clone());
                            OperationEnCours = mul;
                            tronc            = OperationEnCours;
                        }
                    }
                    else
                    {
                        mul.setOperandeA((decimal)val.valeur);
                        tronc            = mul;
                        OperationEnCours = tronc;
                    }
                }

                break;

            case "/":
                Operation div = new Division();


                if (nbParentheses != 0)                                                 //Une parenthèse est ouverte
                {
                    if (OpParentheses != null)                                          //Une opération est en cours dans les parenthèses
                    {
                        if (OpParentheses is Addition || OpParentheses is Soustraction) //si l'opération présente dans les parenthèses est une Addition ou Soustraction
                        {
                            div.setOperandeA((decimal)val.valeur);                      //On ajoute la division avant, pour qu'elle soit prioritaire
                            OpParentheses = div;                                        //
                        }
                        else
                        {
                            OpParentheses.setOperandeB((decimal)val.valeur);
                            if (OpParentheses != troncParentheses)
                            {
                                troncParentheses.setOperandeB(OpParentheses.Clone());
                                OpParentheses = troncParentheses;
                            }
                            div.setOperandeA(troncParentheses.Clone());
                            OpParentheses    = div;
                            troncParentheses = OpParentheses;
                        }
                    }
                    else
                    {
                        div.setOperandeA((decimal)val.valeur);
                        troncParentheses = div;
                        OpParentheses    = troncParentheses;
                    }
                }
                else
                {
                    if (OperationEnCours != null)
                    {
                        if (OperationEnCours is Addition || OperationEnCours is Soustraction)
                        {
                            div.setOperandeA((decimal)val.valeur);
                            OperationEnCours = div;
                        }
                        else
                        {
                            OperationEnCours.setOperandeB((decimal)val.valeur);
                            if (OperationEnCours != tronc)
                            {
                                tronc.setOperandeB(OperationEnCours.Clone());
                                OperationEnCours = tronc;
                            }
                            div.setOperandeA(tronc.Clone());
                            OperationEnCours = div;
                            tronc            = OperationEnCours;
                        }
                    }
                    else
                    {
                        div.setOperandeA((decimal)val.valeur);
                        tronc            = div;
                        OperationEnCours = tronc;
                    }
                }

                break;

            case "(":
                if (racineEnCours)
                {
                    return;
                }
                nbParentheses++;
                labelOperation.Text += "(";

                break;

            case ")":

                if (nbParentheses > 0)      //Si on a une parenthèse ouverte
                {
                    nbParentheses--;        //On peut la fermer
                    if (racineEnCours)
                    {
                        racineEnCours = false;
                    }

                    if (OpParentheses != null)                                                       //Si l'opération entre parenthèses n'est pas null
                    {
                        if (labelOperation.Text[labelOperation.Text.Length - 1].CompareTo(')') == 0) //Si on a saisie une parenthèse fermante juste après une autre parenthèse fermante
                        {
                            Addition tmp = new Addition(); tmp.setOperandeA(OpParentheses.Clone()); tmp.setOperandeB(new Valeur(0)); OpParentheses = tmp; val.valeur = null;
                        }
                        if ((val != null && val.valeur.HasValue))       //Si on a une valeur en cours de saisie
                        {
                            if (OpParentheses.getOperandeB() == null)
                            {
                                OpParentheses.setOperandeB((decimal)val.valeur); //alors on peut la stocker dans l'opérandeB de l'opération en cours
                            }
                            labelOperation.Text += resultat.Text;                //Et on l'ajoute au libellé de l'opération
                        }

                        if (troncParentheses != null)   //Si l'arbre existe
                        {
                            if (nbParentheses == 0)     //Si on vient de fermer la dernière parenthèse
                            {
                                //if (troncParentheses.getOperandeB() == null)    //Si l'OperandeB de l'arbre n'est pas définie
                                //    troncParentheses.setOperandeB(OpParentheses.Clone());   //On y stock l'opération en cours
                                if (OpParentheses != troncParentheses)
                                {
                                    if (troncParentheses.getOperandeB() == null)
                                    {
                                        troncParentheses.setOperandeB(OpParentheses.Clone());
                                        OpParentheses = troncParentheses;
                                    }
                                    else
                                    {
                                        troncParentheses = OpParentheses;
                                    }
                                }

                                if (OperationEnCours != null)     //Il faut remettre l'arbre des parenthèses dans l'arbre global
                                {
                                    if (OperationEnCours.getOperandeB() == null)
                                    {
                                        OperationEnCours.setOperandeB(troncParentheses.Clone());
                                    }
                                }
                                else
                                {
                                    OperationEnCours = troncParentheses.Clone();
                                    if (tronc == null)
                                    {
                                        tronc = OperationEnCours;
                                    }
                                }
                                troncParentheses = null;
                                OpParentheses    = null;
                            }
                        }
                        else
                        {
                            if (nbParentheses == 0)
                            {
                                OperationEnCours = OpParentheses.Clone();
                                if (tronc == null)
                                {
                                    tronc = OperationEnCours;
                                }
                            }
                        }
                    }
                    else
                    {
                        OperationEnCours = troncParentheses.Clone();
                        if (tronc == null)
                        {
                            tronc = OperationEnCours;
                        }
                    }
                    //OpParentheses = null;

                    labelOperation.Text += ")";
                }

                break;

            case "sqrt":
                Operation sqrt = new sqrt();

                if (val != null && val.valeur.HasValue)
                {
                    labelOperation.Text += "sqrt(" + val.valeur;
                    nbParentheses++;
                    racineEnCours = true;

                    if (nbParentheses != 0)     //Si on a une parenthèse ouverte
                    {
                        sqrt.setOperandeA((decimal)val.valeur);
                        if (OpParentheses != null)      //Si une opération est en cours dans les parenthèses
                        {
                            if (OpParentheses.getOperandeB() == null)
                            {
                                OpParentheses.setOperandeB(sqrt);        //On ajoute seulement si notre opération n'est pas complète (si on vient de fermer une parenthèse, l'opération est déjà remplie)
                            }
                            if (OpParentheses != troncParentheses)
                            {
                                troncParentheses.setOperandeB(OpParentheses.Clone());
                                OpParentheses = troncParentheses;
                            }
                        }
                        else
                        {
                            troncParentheses = sqrt;
                            OpParentheses    = troncParentheses;
                        }
                    }
                }

                break;

            case "=":
                if (nbParentheses != 0)
                {
                    resultat.Text = "Parenthesis!";
                    return;
                }
                if (tronc != null)
                {
                    if (OperationEnCours != null && tronc.getOperandeA() != null)
                    {
                        if (OperationEnCours.getOperandeB() == null)
                        {
                            OperationEnCours.setOperandeB((decimal)val.valeur);
                        }

                        if (OperationEnCours != tronc)
                        {
                            tronc.setOperandeB(OperationEnCours.Clone());
                            OperationEnCours = tronc;
                        }
                        resultat.Text = tronc.calculerOperation().ToString(System.Globalization.CultureInfo.InvariantCulture);
                        val.valeur    = null;
                        tronc.setOperandeA(tronc.Clone());
                    }
                    else
                    {
                        if (val.valeur.HasValue)
                        {
                            resultat.Text = val.valeur.ToString();
                        }
                    }

                    OperationEnCours = null;
                    enterPressed     = true;
                    if (racineEnCours)
                    {
                        racineEnCours = false;
                    }

                    return;
                }

                break;
            }
            resultat.Clear();
            val.valeur = null;
        }