Discussion :

[fe801]

Bonjour à tous,

Je suis un peu débutant en Java mais je ne manque pas du tout de motivation, pour preuve, je vais apprendrer à maitriser le mieux possible ce langage.

Actuellement, je me penche sur un programme dont le rôle serait d'interpreter une formule mathématique saisie par l'utilisateur (formule composée de diverses fonctions appliquées à des variables), en utilisant des valeurs également saisies par l'utilisateur.

Exemple :

L'utilisateur entre la formule y = 5x + 3 ou y = ax + b (sachant qu'il connait les valeurs de a et b)
Il veut la valeur de y pour x = 3.
Donc il indique au programme la valeur des variables contenues ds sa formule.
Enfin, le programme "reconnait" la formule mathématique et y applique les valeurs des variables netrées par l'utilisateur.

Je ne sais pas comment élaborer ce prog, peut être qqn a t il déjà réalisé un tel projet ou connait il un outil de synthèse ?
Pour la reconnaissance de formules mathématiques, n'y a t il pas une classe pouvant "reconnaitre" une formule mathématique ou des "morceaux" de formule ?

Je vous remercie.

[dingoth]

Ton prof ne t'a pas donné plus d'indications ? L'emploi de classes spéciales de Java est-il autorisé ou faut-il partir de zéro, avec des objets créés par toi-même, des String et des nombres ?

[fe801]

Non je n'ai pas plus d'indications, je peux faire la chose comme je le désire donc pourquoi pas, et je préfererais utiliser des classes spéciales.
De quelle(s) classe(s) veux tu parler ? (étant débutant je n'en connais pas)

[CyberChouan]

Il existe des parseurs de langages (mathématiques entre autres).

Regarde par exemple du côté de la librairie Antlr. Attention : c'est puissant, mais pas évident à appréhender.

Dans le cadre de ton exercice, le but est peut-être de recoder toi-même un "parseur minimaliste" répondant uniquement au besoin de l'énoncé.

[fe801]

Merci, je vais regarder le parseur Antlr et j'aurais surement pas mal de question à poser.

Merci

[fe801]

Quoi qu'il en soit, cela me parait la meilleure méthode ces parseurs car si je recode un parseur minimaliste, cela va être énorme car l'utilisateur ne doit avoir aucune limites quant aux fonctions qu'il est succeptible de saisir.

Par exemple, il doit pouvoir faire l'exponentielle de la racine du log de la division de deux variables.

Ce que je veux dire c'est que niveau reconnaissance de formules, mon prog doit pouvoir en reconnaître le plus possible si ce n'est toutes.

Le parseur ne serait il pas le plus approprié ?

Je n'ai pas encore regardé Antlr (je me familiarise avec Java )

Merci

[CyberChouan]

Les deux solutions restent possibles.

Si tu veux coder toi-même un parseur, rien ne t'empêche de prendre en compte le cas que tu cites : il suffit de le coder en objet de manière récursive.

Voici une idée de l'algorithme de la methode "eval" devant une telle formule :
eval("exp(racine(log(a/b)))")
on détecte que ce qu'il faut calculer est une exponentielle (sans regarder plus près) : on applique le calcul de l'exponentielle au résultat de la méthode eval interne.
exp(eval("racine(log(a/b))"))
etc.

En objet, avec des classes et des interfaces "Literal", "Operation", "Variable", etc. ce genre de choses se code assez bien de manière générique. C'est d'ailleurs le genre d'exercice qui permet de bien comprendre les mécanismes d'héritage (les classes "Addition", "Multiplication", etc. implémentant par l'interface "OperationBinaire", par exemple).

[fe801]

Je dois clairement utiliser un parseur et non le refaire moi même.
Il s'agit de monter ce mini projet le plus rapidement possible.

Je me suis donc renseigné au sujet de Antlr mais je ne vois pas vraiment comment tout cela fonctionne !

Comment fait on pour faire un programme avec Antlr ?
A quoi servent parseur lexeur grammaire ?

Peut on intégrer le bout de code fait avec Antlr à un programme Java et ce comment ?

Je suis un peu perdu. Je n'ai pas trouvé de tutos non plus donc si qqn en connait un mis a part celui du site officiel de ANTLR.

Merci

[dingoth]

Oriente-toi plutôt vers des parseurs minimalistes, genre JEP et sa doc. Bien plus facile !

[fe801]

J'ai un pb débile mais je ne vois pas comment le résoudre.
J'ai téléchargé les bibliothèques JEP, crée un projet eclipse pour tester ce qu'avait JEP dans le ventre : j'ai recopié le code présent ici :http://www.singularsys.com/jep/doc/html/usage.html

Mais il me manque visiblement des bibliothèques et je ne vois pas ce qu'est com.singularsys.jep.Jep

J'ai pourtant bien ajouté au projet, les jars qui sont dans le dossier d'install de jep.
( ext-1.1.1 ; jep-2.4.1 ; Jama-1.0.2 ; junit )

Enfin, JEP est payant !
Je dois réaliser un programme utilisant un parseur gratuit et ce pour une durée non déterminée ( i.e longue)
Connaissez vous d'autres parseur mathématiques ??

Je vous remercie pour votre aide.

[dingoth]

JEP est payant à partir de la version 3 ; je m'en suis rendu compte par la suite et les bibliothèques disponibles gratuitement ne sont qu'en version 2.xx.

Soit tu utilises la version 2.xx que tu as téléchargée, soit tu trouves une autre API. Google peut très certainement t'aider avec des termes genre "math parser library java"...

[fe801]

Ok je ne savais pas. Dans ce cas, je veux bien utiliser JEP 2.

Peux tu me dire dans ce cas pourquoi mon prog de test ne fonctionne pas ?

il me manque visiblement cette bibliothèque : com.singularsys.jep.Jep.
Est ce normal ?
Ais je fais quelquechose de travers ?

[dingoth]

JEP 2 utilise d'autres classes que JEP 3. Donc la doc que tu vois là n'est pas valide.

Dans le fichier que tu as téléchargé, il y a un répertoire de documentation doc/html qui t'aidera à commencer à l'utiliser.

Typiquement, c'est le genre de chose qu'il faut regarder quand on télécharge une API : le répertoire de documentation (généralement doc).

[fe801]

ok merci du coup de main j'y jette un coup d'oeil.

Sinon connais tu Jflex et Yacc ?
J'ai lu que c'était des analyseurs syntaxiques donc parseurs mais peuvent ils reconnaitre des formules mathématiques ?
Les as tu déjà utilisé ?

[dingoth]

Yacc est un analyseur syntaxique, mais pas pour Java.

JFlex est un autre analyseur syntaxique mais pour Java, cette fois. Honnêtement, je l'ai utilisé il y 8-9 ans, mais je ne me rappelle plus du fonctionnement, désolé.

[gronono]

Bonjour,

J'utilise aussi JEP (en version 2.4.1) et ça marche très bien.

Si ça peut aider, voici ma classe permettant son utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
import java.math.BigDecimal;
import java.util.Collections;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
import java.util.Stack;
import java.util.Map.Entry;
 
import org.apache.log4j.Logger;
import org.nfunk.jep.JEP;
import org.nfunk.jep.Node;
import org.nfunk.jep.ParseException;
import org.nfunk.jep.Variable;
import org.nfunk.jep.SymbolTable.StObservable;
import org.nfunk.jep.function.PostfixMathCommand;
 
/**
 * Classe permettant de calculer une expression.
 *
 * @author Arnaud Brunet
 */
public class ExpressionComputer {
 
    /** logger */
    @SuppressWarnings("unused")
    private static final Logger logger = Logger.getLogger(ExpressionComputer.class);
 
    /**
     * Fonction JEP donnant le maximum entre deux nombres.
     * 
     * @author Arnaud Brunet
     */
    private static class MaxFunction extends PostfixMathCommand {
        /**
         * Construit la fonction.
         */
        public MaxFunction() {
            super();
            numberOfParameters = 2;
        }
 
        @Override
        @SuppressWarnings("unchecked")
        public void run(Stack stack) throws ParseException {
            checkStack(stack);
            Number param1 = (Number) stack.pop();
            Number param2 = (Number) stack.pop();
            if (param1.doubleValue() > param2.doubleValue()) {
                stack.push(param1);
            } else {
                stack.push(param2);
            }
        }
    }
 
    /**
     * Fonction JEP donnant le minmum entre deux nombres.
     * 
     * @author Arnaud Brunet
     */
    private static class MinFunction extends PostfixMathCommand {
        /**
         * Construit la fonction.
         */
        public MinFunction() {
            super();
            numberOfParameters = 2;
        }
 
        @Override
        @SuppressWarnings("unchecked")
        public void run(Stack stack) throws ParseException {
            checkStack(stack);
            Number param1 = (Number) stack.pop();
            Number param2 = (Number) stack.pop();
            if (param1.doubleValue() < param2.doubleValue()) {
                stack.push(param1);
            } else {
                stack.push(param2);
            }
        }
    }
 
    /**
     * Observateur des évènements sur JEP.
     * S'assure que les variables non initialisés le sont avec {@link BigDecimal#ZERO}
     * 
     * @author Arnaud Brunet
     */
    private static final class JEPObserver implements Observer {
        public void update(Observable o, Object arg) {
            if (o instanceof StObservable) {
                // Initialise les variables non initialisée
                Variable variable = (Variable) arg;
                variable.addObserver(this);
                if (variable.getValue() == null) {
                    variable.setValue(BigDecimal.ZERO);
                }
            } 
        }
    }
 
    /**
     * Calcul l'expression en remplaçant les variables par leur valeur.
     * @param expression L'expression à calculer.
     * @param variables Les variables sous la forme nom/valeur.
     * 
     * @return Le résultat de l'expression.
     */
    public Number compute(String expression, Map<String, Object> variables) {
        // Initialisation du moteur JEP
        JEP jep = initJep(variables);
        // Parse l'expression
        Node node = parseExpression(jep, expression);
        // Calcul
        return compute(jep, node, expression);
    }
 
    /**
     * Initialise le moteur JEP.
     * 
     * @param variables Les variables à inserer dans le moteur.
     * 
     * @return Le moteur JEP.
     */
    private JEP initJep(Map<String, Object> variables) {
        // Initialise le moteur
        JEP jep = new JEP();
        // Multiplication implicite 2x => 2 * x
        jep.setImplicitMul(true);
        // Ajout des fonctions standards
        jep.addStandardFunctions();
        // Ajout des fonctions perso
        jep.addFunction("max", new MaxFunction());
        jep.addFunction("min", new MinFunction());
        // Autorise les variables non initialisées
        // Elles le sont via l'observateur (voir ci-dessous)
        jep.setAllowUndeclared(true);
        // Ajout d'un observateur sur JEP
        // Permet d'initialiser les variables non déclarées.
        JEPObserver jepObserver = new JEPObserver();
        jep.getSymbolTable().addObserver(jepObserver);
        jep.getSymbolTable().addObserverToExistingVariables(jepObserver);
 
        // Ajout des variables connues
        Map<String, Object> notNullVariables = ensureIsNotNull(variables);
        for (Entry<String, Object> entry : notNullVariables.entrySet()) {
            // On ignore les variables qui ne sont pas des nombres
            if (entry.getValue() instanceof Number) {
                jep.addVariable(entry.getKey(), entry.getValue());
            }
        }
 
        return jep;
    }
 
    /**
     * Parse l'expression donnée avec le moteur spécifié.
     * 
     * @param jep Le moteur JEP.
     * @param expression L'expression à parser.
     * 
     * @return Le {@link Node} racine.
     */
    private Node parseExpression(JEP jep, String expression) {
        Node node = null;
        try {
            node = jep.parse(expression);
        } catch (ParseException e) {
            throw new IllegalArgumentException("Impossible de parser : " + expression, e);
        }
        return node;
    }
 
    /**
     * Effectue le calcul.
     * 
     * @param jep Le moteur JEP.
     * @param node Le noeud à calculer.
     * @param expression L'expression (juste pour la trace).
     * 
     * @return Le résultat du calcul.
     */
    private Number compute(JEP jep, Node node, String expression) {
        Object result = null;
        try {
            result = jep.evaluate(node);
        } catch (ParseException e) {
            throw new IllegalArgumentException("Impossible de calculer : " + expression, e);
        }
        if (result instanceof Number) {
            return NumberUtil.convertToBigDecimal((Number) result);
        }
 
        throw new IllegalStateException("Le résultat de " + expression + " n'est pas un nombre : " + result);
    }
 
    /**
     * S'assure que la map spécifié n'est pas <code>null</code>.
     * 
     * @param map La map à tester.
     * 
     * @return La map donnée ou si elle est <code>null</code>, une map vide.
     */
    private Map<String, Object> ensureIsNotNull(Map<String, Object> map) {
        if (map == null) {
            return Collections.emptyMap();
        }
        return map;
    }
}

Et voici la classe TU associé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
 
import org.junit.Assert;
import org.junit.Test;
 
/**
 * Tests unitaires sur {@link ExpressionComputer}.
 * 
 * @author Arnaud Brunet
 */
public class ExpressionComputerTest {
    private ExpressionComputer computer = new ExpressionComputer();
 
    /**
     * Vérifie le bon fonctionnement du calcul.
     */
    @Test
    public void testSimple() {
        // Opérations 'standard'
        calculer("5 + 3", 8);
        calculer("5 * 5 + 5", 30);
        calculer("5 + 5 * 5", 30);
        calculer("5 / 2", 2.5);
        calculer("(5 + 3) * 2", 16);
        calculer("floor(5.1)", 5);
        calculer("floor(5.6)", 5);
        calculer("if(5>3, 3, 5)", 3);
        // Vérifie que l'on ne calcule pas le coté faux
        calculer("if(5>3, 3, 5 / 0)", 3);
 
        // Fonctions personnalisées
        calculer("max(5, 2)", 5);
        calculer("min(5, 2)", 2);
 
        // Formules complexes
        calculer("if(max(5, 2) == 2, 5, min(4, 7))", 4);
    }
 
    /**
     * Test avec des variables
     */
    @Test
    public void testVariables() {
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("var1", new BigDecimal(5));
        // On vérifie que la variable est bien utilisé
        calculer("max(var1, 2)", variables, 5);
        // On vérifie que la variable var1 ne faut plus rien
        calculer("min(var1, -1)", new HashMap<String, Object>(), -1);
    }
 
    /**
     * Test que l'expression est bien calculée. 
     * @param expression L'expression à calculer.
     * @param expectedResult Le résultat attendu.
     */
    private void calculer(String expression, Number expectedResult) {
        calculer(expression, null, expectedResult);
    }
 
    /**
     * Test que l'expression est bien calculée. 
     * @param expression L'expression à calculer.
     * @param variables Les valeurs des variables dans l'expression.
     * @param expectedResult Le résultat attendu.
     */
    private void calculer(String expression, Map<String, Object> variables, Number expectedResult) {
        Object result = computer.compute(expression, variables);
        Assert.assertTrue(result.getClass().getName(), result instanceof BigDecimal);
        Assert.assertEquals(NumberUtil.convertToBigDecimal(expectedResult), result);
    }
}

A adapter selon tes besoins.

Note la version opensource de JEP est sur sourceforge : http://sourceforge.net/projects/jep/

[fe801]

Salut ,
Merci beaucoup pour ton aide, ton code m'éclaire sur pas mal de trucs mais je me pose de nouvelles questions.
En fait je ne comprends pas bien à quoi peut servir un Observer ?
Qu'est ce que Observable ?
De plus, je ne connais pas cette manière de déclarer ni a quoi ca sert :
Map<String
ou Object> map

Peut tu m'expliquer ?

Je cherche en fait à traiter une formule du style x+y+z saisie par un utilisateur.
Ensuite, le prog doit demander les valeurs respectives de toutes les variables contenues dans la formule.
En l'occurrence, le prog demande : "Veuillez saisir les valeurs de vos variables"


Merci d'avance

[gronono]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Map<String, Object> map = ...

permet de déclarer une Map contenant des chaines en clé et des Object en valeur.
Cette Map contient toutes les variables. Dans l'idéal, il faudrait que la Map contienne uniquement des Number. Mais dans mon cas ce n'est pas forcement le cas. Donc je filtre les variables de types Number avant de les passer à JEP. En interne les Number sont en faites des BigDecimal mais ça pourrait être autre chose.

L'Observer et l'Observable sont là pour éviter que JEP lève une exception si la variable n'existe pas. Dans mon si elle n'existe pas, elle est considérée à 0. L'Observer permet aussi d'ajouter un traitement lorsqu'une variable change (par exemple un log).

Dans ton cas, si tu veux que ton interface propose à l'utilisateur de saisir les variables, tu peux utiliser le couple Observer/Observable pour afficher une boîte de dialogue à l'utilisateur.
Pour cela dans mon code, je supprimerai la map puisqu'elle sert à rien. Et dans le JEPObserver à la place d'initialiser la variable à 0, j'afficherai une interface de saisie de la variable.

Je te conseille de lire à la documentation (dans le répertoire doc) de JEP; notamment le fichier doc/html/variables.html.

[fe801]

Salut,
Ok pour map et objet ...
J'ai de suite après t'avior écrit fait ce que tu dis dans ton msg.
Maintenant je me trouve confronté à 2 autres pb :

1)
Lorsqu'on saisit la formule ex : x+ y+2.5z
Tu remarquera que si on veut écrire un nombre à virgule, on doit utiliser le symbole . (point).
Alors que lorsque je demande à l'utilisateur la saisie de chacune des variables, ce n'est pas un point mais une virgule qu'il faut utiliser pour un nombre à virgule !
Cela ne fait pas vraiment propre donc saurais tu comment éviter ça ?
Faut il aller bidouiller dans la grammaire qu'utilise JEP ? Si oui, comment faire ?

2)
Maintenant, je ne veux pas que le prog demande pour chaque variable de saisir la valeur, mais je voudrais qu'il demande à l'utilisateur de remplir un champ texte dans lequel il mettrait les valeurs de chaque variables de sa formule, séparées par un ; (point virgule).
Y a t'il une fonction (dans JEP ou Java) capable de séparer des valeurs lorsqu'elle rencontre un caractère/symbole particulier ou dois je la créer ?

Merci d'avance Gronono !

[tromaltsec]

bonjour,
alors pour le 1) tu récupères la saisie de l'utilisateur dans un String et tu remplaces la "," par le "." et hop le tour est joué (reste plus qu'à transformer ton String en float ou double selon ton besoin ^^)

pour le 2) soit tu le fais à la main soit tu peux utiliser des expressions régulières (là aussi c'est toi qui voit ^^) mais bon parser une ligne sur un séparateur connu c'est facilement trouvable sur le Web (google est ton ami ^^)

bon courage