Discussion :

[steph_ntic]

Bonsoir, espérant que vous allez bien !
voilà j'aimerai programmer l'intégrale d'une fonction par la méthode des rectangle, comme l'indique la pièce jointe.
je veux pour ça que le programme fasse :
- rappeler sa syntaxe s'il est appelé avec un nombre d'argument inférieur à 4
- afficher un message d'erreur si l'argument a ou b n'est pas un nombre.
- afficher le message d'erreur "ERREUR : Tous les argument (f0, f1, ..., fn-1) doivent être des nombres" si au moins l'un de ces argumet de la ligne de commande n'est pas un nombre.

Pour ce fait j'ai essayé de réaliser quelque chose qui fonction plutôt bien.
Mais j'aimerai entrer la fonction en paramètre dans la ligne de commande
ou entrer les nombre f0, f1, ..., fn-1.

J'ai donc besoin de votre coup de main, Merci bien.

//classe fonction

Code :

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

1
2
3
4
5
6
public class Fonction {
        public double f(double x){
            return x*x*x;
        }
 
}

//classe rectangle, pour le calcule de l'intégrale

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
public class Rectangle {
 
    public double calcule(double a, double b, int n, Fonction cube){
        double xi;
        double sum = 0;
        double h;
        h = (b-a)/n;
        for (int i = 0; i<=n-1; i++){
            xi = (a+i*h);
            sum += cube.f(xi);
        }
            return h*sum;
    }
 
}

//classe main

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
public class IntegraleMain {
    public static void main(String[] args){
        if(args.length<3){
            System.err.println("Syntaxe : java integrale a b f0 f1 [f2 fn-2 fn-1]");
            return;
        }
        Rectangle carre = new Rectangle();
        Fonction F = new Fonction();
        double a = Double.parseDouble(args[0]);
        double b = Double.parseDouble(args[1]);
        int n = Integer.parseInt(args[2]);
        try
        {
            System.out.println("l'integrale " + carre.calcule(a, b, n, F));
        } 
        catch(NumberFormatException e){
            System.err.println(e.getMessage());
        }
    }
}

[joel.drigo]

Salut,

1. Saisir les valeurs de la fonction (de f0 à fn-1)
   C'est plutôt simple pour la saisie. Le tableau args[] des paramètres du programme va être divisé en deux parties : une pour les paramètres que tu lis déjà (a,b) et les autres. Il y a juste à déterminer comment l'alternative se décide entre la saisie de a, b, n, f(x) (dont je parlerai aprèsà, ou a, b et f0 à fn-1. Cela pourrait être juste un paramètre spécial, par exemple :
   
   • a b n f(x) traitement que tu fais actuellement plus un argument pour la fonction
   • a b -v f0 f1 [f2...fn-1] : si le paramètre args[2] est -v, alors on teste s'il y a au moins 5 arguments, et on lit les valeurs :
     

     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
      
     if ( args.length<3 ) {
        // afficher la syntaxe...
     }
     else {
      
     if ( !args[2].equals("-v") ) {
     // traitement de la lecture des paramètres avec expression de la fonction
     //...
     }
     else {
     // traitement de la syntaxe avec liste de valeurs
     if ( args.length<5 ) {
        // afficher la syntaxe...
     }
     else {
        // exécuter le programme
        // lire a et b
        try {
            double a = Double.parseDouble(args[0]);
            double b = Double.parseDouble(args[1]);
            // lire les valeur de f0 à fn-1
            int n = args.length-3;
            double[] values = new double[n]; 
            for(int i=3; i<args.length; i++) {
                  values[i-3]=Double.parseDouble(args[i]);
            } 
      
             // calcul de l'intégrale...
      
        }
        catch(NumberFormatException e) {
                   // je te laisse traiter ce cas (afficher l'erreur, la syntaxe (rappeler qu'on veut que des nombres), arrêter le programme...
        }
     }

2. Pour la fonction exprimée sous forme de formule, on va considérer que le paramètre args[2] est n (comme actuellement dans ton programme) et le paramètres args[3] est une String qui contient l'expression. Il faudra juste passer l'argument entouré de "" :
   
   • java integrale 12 37 150 "1 / x"
   • java integrale 12 37 150 "2 * ( x ^ 2 )"
   • ...
   
   Ensuite il faut parser l'expression pour obtenir quelque chose d'évaluable en Java.
   
   1. se reposer sur JavaScript (actuellement Nashorn, déprécié, qui sera remplacé par on ne sait pas quoi encore). Il faudrait éventuellement vérifier l'expression (vérifier qu'on a bien une fonction, et pas un programme JavaScript). Si on se limite aux opérateurs arithmétiques, c'est relativement simple avec une expression régulière (ne contient que des chiffres, le point, les opérateurs, des parenthèses, et x par exemple). Si on veut pouvoir mettre des fonctions (sin, cos, ln...) on peut éventuellement fermer la liste et donc utiliser aussi une expression régulière. Avec l'heuristique "un point ne peut être que dans un nombre" on pourrait éliminer ce qui n'est pas une fonction mathématique. Ensuite par remplacement on "convertit" les fonctions en fonctions js (remplacer sin par Math.sin par exemple)
   2. écrire ton propre parser (voir algorithme shunting-yard par exemple)
   3. utiliser une bibliothèque qui fournit un parser d'expression
   
   
   

[steph_ntic]

Bonjour joel.drigo et merci pour ta reponse, cependant etant un débutant en java je ne comprend pas certain point de ton programme ou du moins je veux être mieux éclaircir sur certain point.
1 - Pourquoi avons nous utilisé un "-v" sachant que le args[2] est le n ?
2 - pourquoi ça int n = args.length-3 au lieux de Integer n = Integer.parseInt(args[2]) ?
3 - que se passerai t-il si on ignorait le "-v" ?
4 - a quoi me servirai l'objet value et cette instruction values[i-3]=Double.parseDouble(args[i]) dans le calcule de l'intégrale ?
5 - enfin ayant déjà crée une méthode calcule dans la classe intégrale qui calcule l'intégrale, devrais-je juste faire appel a cette méthode ou la redéfinir dans une même classe que les instructions précédente et supprimer la classe intégrale ?
Merci encore pour ton aide

[joel.drigo]

1 - Pourquoi avons nous utilisé un "-v" sachant que le args[2] est le n ?

Si tu veux pouvoir entrer comme paramètres soit une liste de valeurs soit une expression mathématique (c'est ce que tu décris dans ta question), tu vas avoir en commande deux formes possibles de liste de paramètres :

1. ce qui ne change pas par rapport à ce que tu as déjà fait, donc
   
   1. le paramètre a
   2. le paramètre b
2. ce qui change pour gérer soit une liste de valeurs, soit une expression, il faut un moyen de distinguer les deux. Ou alors il faut faire deux programmes (deux méthodes main, dans deux classes différentes).
   Donc après a et b, on a :
   
   1. soit une liste de valeurs (au moins 2)
   2. soit un nombre de valeurs (n) et une expression (genre par exemple)
   
   Dans les deux cas, ça fait au moins 4 paramètres. Alors on peut partir sur l'idée que si le 4^ième paramètre est un nombre on est dans le premier cas, sinon on est dans le second. Mais 4 c'est aussi une fonction f(x)=4 donc. On pourrait aussi partir sur l'idée que s'il y a 4 paramètres, alors on est forcément dans le deuxième cas, sinon on est dans le premier.
   Moi je suis parti sur l'idée d'un switch comme le fait de nombreuses autres applications (à commencer par java.exe avec le switch -jar).
   Après, tu fais comme tu veux.

2 - pourquoi ça int n = args.length-3 au lieux de Integer n = Integer.parseInt(args[2]) ?

Pourquoi saisir le nombre de valeurs lorsqu'on donne une liste de valeurs ? Si on a 1 14 2 53 et 4, on sait qu'on a 5 valeurs. Et si on a en paramètres a, b, 1, 14, 2, 53, et 4, et bien ça fait 7 paramètres, dont 5 comme valeurs de fonction (7 - les deux premiers).

4 - a quoi me servirai l'objet value et cette instruction values[i-3]=Double.parseDouble(args[i]) dans le calcule de l'intégrale ?

Hum, tu demandes un truc, j'y réponds.

ou entrer les nombre f0, f1, ..., fn-1.

S'il faut rentrer les nombres f(0)à f(n-1), c'est bien pour s'en servir, non ? Donc, il faut bien une variable pour les stocker, n'est-ce pas ? Un tableau pour stocker n nombres donc. Ensuite, le parseDouble c'est parce que les arguments c'est des String, or pour faire des calculs on veut l'équivalent en double.
Ensuite pour l'utilisation du tableau, ta fonction au lieu d'être :

Code :

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

1
2
3
public double f(double x) {
return x*x*x;
}

elle va trouver la valeur dans le tableau en fonction de x (sachant que pour la méthode de calcul de l'intégrale par rectangle, normalement on calcule f(x_i), ou xi est le "centre" du côté horizontal du rectangle, et f(x_i) la i^ème valeur (dans le tableau en l'occurence).

5 - enfin ayant déjà crée une méthode calcule dans la classe intégrale qui calcule l'intégrale, devrais-je juste faire appel a cette méthode ou la redéfinir dans une même classe que les instructions précédente et supprimer la classe intégrale ?
Merci encore pour ton aide

Ta classe Rectangle fait le calcul en prenant une instance de classe Fonction en paramètre. Celle classe ne devrait pas changer, sauf que tu vas devoir pouvoir passer autre chose que ta fonction Fonction. Donc au lieu d'une classe, passe par une interface (soit tu remplaces ta classe Fonction, par une interface Fonction, soit tu utilises comme je l'ai déjà écrit dans mon autre réponse une interface que Java fournit en standard, java.util.function.Function.
Ensuite, ta classe Integrale, il faut la modifier pour qu'elle traite les nouvelles formes de passage d'argument, le traitement de la transformation des paramètres en fonction f(x), et l'appel de la méthode de calcul. Il y a quelques changements à faire, pas la peine de supprimer la classe entière. D'ailleurs, même si ça n'a pas beaucoup de sens, tu pourrais même conserver le mode de fonctionnement actuel (où tu sais trois paramètres, a, b et n et que ça calcule l'intégral de la fonction "cube"), donc conserver quasiment tout ton code actuel.

[steph_ntic]

Merci infiniment et désolé pour tout ce temps. Je crois avoir compris, je vais me mettre à la pratique

[steph_ntic]

Bonsoir avant quand même de marquer résolu au sujet je voulais partager ce que j'ai trouvé finalement grâce à ton aide.
J'ai ignoré le fait qu'on entre une expression mathématique pour simplifier les choses.

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
public class Intergrale {
    public static void main (String[] args){
        float a=0, b=0;
        if(args.length<4){
            System.out.println("Syntaxe java Integrale a b f0, f1 [f2 fn-2 fn-1] non respecter");
        }
        try{
          a = Float.parseFloat(args[0]);
          b = Float.parseFloat(args[1]);
        }
        catch(NumberFormatException e){
            System.err.println("a et b doivent être des nombres" + e.getMessage());
        }
        try{
            float som = 0f;
            for(int i = 2; i<args.length; ++i){
                som += Float.parseFloat(args[i]);            
            }
            int n = args.length;
            float h =(b - a)/n;
            float I = h*som;
            System.err.println("l'integrale de f est " + I);
        }
        catch(NumberFormatException e){
            System.err.println("Erreur : tous les arguments (f0, f1, ... fn-1 doivent etre des nombres)");
        }
    }
}

Merci bien.