Discussion :

[zarnac]

Bonjour,

je suis actuellement en deuxième année de MASS, et j'ai un rapport à rendre dans le cadre de la programmation. Ayant vraiment peu d'expérience dans ce domaine là j'aurai besoin de votre avis par rapport à ce que j'ai fait et si possible éventuellement une ouverture pour me permettre de débloquer mes problèmes et d'avancer.

Le sujet est le suivant :

Écrire un programme opmath qui permet de réaliser diverses opérations de traitement sur une fonction mathématique dont l'expression f(x) est entrée par l'utilisateur. Le principe de fonctionnement est similaire à celui du programme stat dans lequel l'opération de traitement était spécifiée sous la forme d'un mot-clé dans la commande saisie par l'utilisateur. Néanmoins, à la différence de stat, le programme doit pouvoir correctement gérer un nombre variable d'arguments pour les différentes opérations. Voici les opérations qui doivent être réalisables :

* def expression : définir expression comme la fonction mathématique à utiliser pour les opérations suivantes (cf. exemple ci-dessous). La même fonction mathématique sera utilisée tant que l'utilisateur n'aura pas défini une nouvelle fonction avec la commande def
* val x : évaluer la fonction courante f(x) pour la valeur x
* root xmin xmax : déterminer toutes les racines de la fonction courante f(x) sur l'intervalle [xmin, xmax]. Pour cela, le plus simple est d'utiliser la technique de la dichotomie jusqu'à obtenir une précision donnée (généralement 10e-6 est largement suffisant). Le programme doit être capable de gérer le cas des racines multiples sur l'intervalle.
* min xmin xmax : déterminer toutes les valeurs de x qui fournissent la valeur minimale de la fonction courante f(x) sur l'intervalle [xmin, xmax]
* max xmin xmax : déterminer toutes les valeurs de x qui fournissent la valeur maximale de la fonction courante f(x) sur l'intervalle [xmin, xmax]
* area xmin xmax : déterminer l'aire comprise sous la fonction courante f(x) pour l'intervalle [xmin, xmax]. Pour cela, le plus simple est d'utiliser la méthode des trapèzes avec un pas d'échantillonnage donné (généralement, utiliser 10e6 échantillons sur l'intervalle est largement suffisant)

Exemple d'exécution :

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
================================================================================
OPMATH : perform miscellaneous processing on a mathematical function
================================================================================
Note : enter an empty line to stop the interaction loop
<> Enter command : def x*x - 1
f(x) = x*x - 1
<> Enter command : val 2.0
f(2.0) = 3.0
<> Enter command : min -2.0 3.0
min in [-2.0,3.0] : f(0.0) = -1.0
<> Enter command : max -2.0 3.0
max in [-2.0,3.0] : f(3.0) = 8.0
<> Enter command : root -2.0 3.0
root in [-2.0,3.0] : f(-1.0) = f(1.0) = 0.0
<> Enter command : area 0.0 3.0
area under [0.0,3.0] : 6.0
<> Enter command : def cos(x)
f(x) = cos(x)
<> Enter command :

Mon programme est le suivant: ( sachant que je ne me suis arrêté que à "val x"):

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
f=none
 
while 1:
    command = raw_input("Enter command: ")
    if not command:
        print "End of program."
        break
    if command.startswith('def '):
        f = command.lstrip('def ')
        print "f(x)=%s" % f
    elif command.startswith('val '):
        x = float(command.lstrip('val '))
        try:
            print "f(%f)=%f" % (x,eval(f))
        except TypeError:
            print "No function defined.
    else:
         print "Unknown command."

J'ai plusieurs problèmes:
-le programme fonctionne trés bien pour le premier exemple: x*x-1
- je ne sais pas comment faire pour implanter plusieurs fonctions , c'est à dire mettre une fonction au hasard et calculer ses images.
- la seconde chose , je ne sais pas comment calculer le min et le max sur un intervalle donné.

Merci de bien vouloir me répondre si possible, et de m'apporter une aide qui me permettrait d'avancer dans mon programme.

Cordialement

[wiztricks]

Salut,

Excepté la fonction qui construit val(x) en fonction de l'expression entrée par l'utilisateur, toutes les autres fonctions utilisent val(x) pour effectuer des calculs pas à pas ou en dichotomie - un min ou un max peut se trouver comme une racine.

Je vous suggèrerai de séparer la partie IHM - saisie, interprétation affichage du résultat - des fonctions de calcul proprement dites.

Vous aurez donc une fonction globale val(x) qui retourne le résultat de l'évaluation de l'expression pour x. Pour commencer, vous pourriez déclarer

Code :

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

1
2
def val(x):
     return x*x - 1

On verra plus bas comment remplacer çà à la volée.
Note: "globale" n'est pas obligatoire, mais restons simple.

puis vous avez les fonctions root, min, max et area qui prennent toutes les bornes de l'intervalle xmin, xmax en paramètre. Exemple, pour la fonction root:

Code :

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

1
2
3
4
5
def root(f, xmin, xmax):
     zeros = [] # la liste des x tels que f(x) = 0
     # le boulot pour calculer les zéros de f sur [xmin, xmax]
     # ajoutés à zeros
     return zeros

Notez que la fonction est paramètre de 'root'
Vous faites pareil pour les autres en faisant attention à min et max. Ce sont des fonctions déjà existantes, choisissez d'autres noms, çà aidera plus tard.

Vous pourrez testez vos fonctions:

Code :

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

1
2
3
4
def test1():
     f = val # on récupère le val global
     print root(f, 1.0, 2.0)
     #....

Vous pouvez remplacer la définition de "val":

Code :

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

1
2
3
4
5
def test2():
     def tval(x):
          return x + 3
     f = tval
     print root(f, ...)

Cela étant fait, vous aurez testé vos fonctions et il sera temps de s'attaquer à l'IHM.
Réglons le cas de val(x).

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
val_fmt = """
def val(x):
    return %s
"""
 
def make_val(expr):
    try:
        exec(val_fmt % expr, globals())
    except:
        return False
    return True
 
expr = "x*x - 1"
make_val (expr)
print val(2)

- val_fmt définit un "string" qui va nous permettre de redéfinir val en fonction de l'expression entrée.
- make_val contruit la fonction 'val' dans le dictionnaire "globals" histoire que vous puissiez y accéder via le nom 'val'.
- j'ai mis l'exec entre try/catch car avec trop pleins de doigts on fait des choses bizarre. Mais pour les tests on entre de "bonnes" expressions.

Que reste-t-il a faire?
La saisie de l'entrée et les actions en fonction du premier mot clé dans
[ 'def', 'val', 'root', 'min', 'max', 'area' ]
La première action étant de récupérer le bon nombre de paramètres et de valider leur type puis afficher le résultat de ce qui est retourné par la fonction correspondante.

Voilà pour le plan.
Pour le reste, courage
- W

[zarnac]

Bonsoir,

je vous remercie de m'avoir répondu aussi rapidement ,

j'étudierai ce plan plus en détail demain , merci en tout cas de m'avoir fait quelque chose de complet de compréhensible.

Arnaud.

[zarnac]

Bonjour,

Je voudrais savoir cependant si le programme que j'ai inscrit en première page est juste ou pas.

[wiztricks]

Bonjour,

Je voudrais savoir cependant si le programme que j'ai inscrit en première page est juste ou pas.

Ben s'il fonctionne, il est "juste".
Après ce sont:
- une question d'organisation i.e. comment décomposer l'ensemble en petits bouts qu'on puisse construire indépendamment les uns des autres et faire en sorte que leur assemblage produise le résultat attendu.
- du savoir faire "Python" pour réaliser les différents bouts.
- des questions de goûts qui vous feront préférez telle construction plutôt qu'une autre.
Exemple.
Les commandes sont de la forme: motclé arg1[' 'args2]
Vous pouvez dire:
1 - si la ligne commence par alors.... sinon si elle commence par alors...
2 - récupérons le début et voyons de quel mot clé il s'agit,
3 - analysons le contenu de la ligne et retournons commande et arguments
Les trois démarches sont "justes", mais elles aboutissent à l'écriture d'un code différent.
Personnellement, j'aime bien séparer les opérations pour pouvoir construire les actions indépendamment les unes des autres - l'option 3 -. Ce qui permet:
- de construire un mini-langage qui permet de traduire de façon résumée les enchainements des différentes opérations,
- ces opérations étant des appels de fonctions/méthodes, il n'est pas utile qu'elles soient achevées pour avoir un programme qui "fonctionne". Il "suffit" de se conformer aux interfaces.
- W