Discussion :

[leminipouce]

Bonjour à tous.

Je dois effectuer des calculs numériques, dont je récupère la formule de calcul, mais je ne vois pas du tout comment je peux interprétere cette formule pour obtenir son résultat.

Code :

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

1
2
String formule = "12/(2.5+3.5+0.5*8)*2";
double result = Double.parseDouble(formule);

Voilà, en gros je voudrais faire ce qu'il y a juste au dessus... sauf que, la méthode parseDouble(), dans mon cas me renvoie un NumberFormatException.
Bref au final je voudrais avoir (dans notre cas...) 2.4 dans mon attribut result.

[thibaut]

Salut,

Pas le choix il faut que tu écrive une fonction qui traite et interpréte ta chaîne...

[Baptiste Wicht]

salut,

à ma connaissance il n'y a rien que le fasse tout seul, tu seras obligé de faire les calculs toi meme à partir de la chaine. J'avais aussi du le faire dans une calculette ou l'utilisateur entrait le calcul sous la forme d'une chaine de caractères

[leminipouce]

OK, ben merci !!!!

Vu les timing, ça va être à voir avec le chef de projet.

Si jamais je l'a développe, je vous tiens au courant, et vous livrerai une petite méthode "toute faite".

Merci encore.

[adiGuba]

Salut,

Cela ne sert à rien de réinventer la roue tous les jours... et il ne faut pas forcément se limiter à l'API standard : Pensez à jeter un coups d'oeil à la page des API Java de Developpez.com, et à faire des recherches sur Google

JEP - Java Math Expression Parser


a++

[thibaut]

Sinon il y à le BeanSriptingFramework http://jakarta.apache.org/bsf/ et utiliser la fonction éval de JavaScript.

A+

[Baptiste Wicht]

Cool

dire que je m'étais fait chier à faire tout un truc pour le faire moi-meme ^^

[leminipouce]

dire que je m'étais fait chier à faire tout un truc pour le faire moi-meme ^^

Ben si ça ne te déranges pas de le partager, je veux bien y jeter un oeil.

JEP - Java Math Expression Parser

En effet, je ne l'avait pas regardé... désolé ! Par contre, c'est dans le cadre d'une application commerciale, il va donc falloir jouer serré pour pouvoir faire passer une extension du budget auprès du client.

Sinon il y a le BeanSriptingFramework

Je n'ai pas encore eu trop le temps de la regarder dans les moindres détails, je vais l'essayer de suite. Par contre, je n'ai pas encore trouvé la javadoc... donc si tu sais l'utiliser et que tu as la(les) ligne(s) de code pour utiliser la fonction eval de javaScript, je suis partant aussi (PS : Ne te prends pas la tête, si tu ne l'as pas sous la main, ne cherches pas pendant des heures, je n'ai, moi même, pas encore eu le temps de vraiment chercher...)

Cela ne sert à rien de réinventer la roue tous les jours...

Et m****, moi qui pensais devenir célèbre !!!!

[leminipouce]

En fait, je suis en train de regarder les méthodes eval() et toutes me prennent une foule de paramètres (bon d'accord des petites fouoles puisqu'elles en prennent 4 ou 5 suivant que je suis avec un BSFEngine ou un BSFManager) dont je ne connais pas le but exact... Comme quoi la javadoc ça sert.

[leminipouce]

Je viens d'essayer de faire ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
			Object o1 = new Object();
			Object o2 = new Object();
			JavaScriptEngine javaScriptEngine = new JavaScriptEngine();
			try{
				o2 = javaScriptEngine.eval("12/(5+3+2)",2, 2, o1);
			}catch(Exception e){
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
//			BSFManager bsfManager = new BSFManager();
 
			System.out.println("computationResult o1 = "+o1+" --- o2 = "+o2);

Et je me retrouve avec java.lang.NoClassDefFoundError: org/mozilla/javascript/JavaScriptException sur la ligne ou j'instancie mon JavaScriptEngine.

Je crois que je vais arrêter le carnage pou ce soir... j'y réfléchirais demain, à tête reposée.

[sylk974]

Ou alors tu la recodes
Arbre binaire, parcours infixe et c'est parti !

[Baptiste Wicht]

wichtounet a écrit:
dire que je m'étais fait chier à faire tout un truc pour le faire moi-meme ^^

Ben si ça ne te déranges pas de le partager, je veux bien y jeter un oeil.

non ca me dérange pas de le partager, mais c'est extrement basique, et ca peut etre beaucoup optimisé... Ca ne gérait que + - * / C'était un des premiers projets qu'on avait eu à faire à l'école, je ne pense pas que ca puisse te servir à quelque chose ^^

[leminipouce]

Bon ben finalement, d'un commun accord avec le chef de projet, on a trouvé une solution plutôt efficace : le RPN (pour Reverse Polish Notation).
Grâce à cette écriture, je me retrouve avec des formules du genre :

12 4 3 1 1.5 0.5 + + + + /

au lieu de

12 / ( 4 + 3 + 1 + 1.5 + 0.5 )

pour avoir comme résultat 1.2.

Dans cette optique là, le traitement devient simplissime avec les opérateurs binaires. Et on s'affranchit du problème des parenthèses... et nos calculs ne devaient pas aller chercher plus loin dans leur complexité .
Voici le code, libre à vous de lui ajouter les exposants, PI ou tout autre chose, mais vu d'ici je n'y vois pas trop de problèmes.

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
	/**
         * Performs the computations based on RPN (Reverse Polish Notation).
         * You should have one operand more than operators.
         * 
         * @param computationValues contains all the values for the computation
         * @param computationElements contains all the operator for the computation
         * 
         * @return result of the computation.
         */
	private float compute(Vector computationValues, Vector computationElements) {
		float computationResult = 0;
 
		try{
			if(computationElements.size()==0){	//No operator is defined... return only the first value
				computationResult = ((Float)(computationValues.get(0))).floatValue();
			}else{
				float operand = 0;
				int operator = 0;
 
				computationResult = ((Float)(computationValues.get(0))).floatValue();
				for(int i=0; i<computationElements.size();i++){
					operand = ((Float)(computationValues.get(i+1))).floatValue();
					operator = ((String)(computationElements.get(i))).charAt(0);
					switch(operator){
						/*BEWARE:
						 * For PLUS, and MULTIPLY, operand location (compared to operator)
						 * have no importance.
						 * Otherwise, for MINUS and DIVIDE, they are important.
						 */
						case PLUS:
							computationResult += operand;
							break;
 
						case MINUS:
							computationResult = operand - computationResult;
							break;
 
						case MULTIPLY:
							computationResult *= operand;
							break;
 
						case DIVIDE:
							computationResult = operand / computationResult;
							break;
 
						default:
							break;
					}
				}
			}
		}catch(Exception e){
			System.out.println("Numbers of operands and operators are different.");
			e.printStackTrace();
		}
 
		return computationResult;
	}

PS : Comme vous pouvez le voir, il faut au préalable séparer les opérandes et les opérateurs. Cela permet de pouvoir utiliser cette méthode même sur des formules de calcul traditionnelles, mais qui ne prennent comme opérateurs QUE des opérateurs BINAIRES, et qui n'attachent aucune importance aux priorités... bref il vaut mieux rester sur du RPN