Forum TI-Planet.org

Hello !

Je me suis dit que ce serait cool d'écrire un programme pour que la calculette fasse de l'algèbre à notre place ! Bah oui, elle est là pour ça... On rentrerait une loi, et puis elle nous dirait si elle est associative, commutative... Bref, comme une bonne calculette, elle ferait le boulot à notre place ! Par contre il faut lui dire comment faire une fois...
Quelques questions sont soulevées :

- Comment faire définir une loi par l'utilisateur ?
- Comment la calculette va-t-elle ingérer cette expression ?
- Y a-t-il une limite d'arguments pour une loi ?
- Et si on veut tester une loi qui n'est pas valable pour des arguments réels ?

Après si on peut faire ça avec un autre langage, ça faciliterait l'édition sur ordinateur...
Bref, comme je suis un peu perdu, je soumets ces questions... merci d'avance pour vos réponses !

A priori, pour faire des maths, le langage le plus adapté est le Basic.
Mais dans ce cas précis, tu ne pourras pas tout faire !

Tout d'abord, il est extrêmement difficile de définir des ensembles sur calculette, encore plus s'ils sont infinis, donc il ne sera en général pas possible de déterminer si une loi est interne par exemple.

Ensuite, même dans les cas où cette vérification est inutile car simplissime, il n'est pas simple de passer "une loi" en argument à une fonction.

Enfin, il est possible que la commutativité obligatoire sur calculette pose problème parfois.

En revanche, une fois ces défis dépassés, tu peux sans problème lui demander la commutativité, l'associativité, voire plus.

Voici une façon de passer une loi comme argument avec un exemple de fonction :

Code: Select all

Define isassoc(loi, variables)=Func
Local f_loi,i,n,vars
if gettype(variables)!="LIST"
   variables:={variables}
n:=dim(variables)
vars:=string(variables)
expr("Define f_loi("&mid(vars,2,dim(vars)-2)&"="&string(loi))

....
EndFunc

Les variables sont passées dans une liste (pour que ça fonctionne, il faut qu'elles ne soient pas affectées, bien sûr !).
J'ai ajouté la possibilité de ne passer qu'une variable sans mettre de liste.
La loi est passée sous la forme d'une expression en fonction des variables.
Ensuite, je crée une fonction "f_loi" en récupérant la liste de variables et en les utilisant pour créer la fonction.
Dans la suite, tu peux utiliser la fonction "f_loi" dans ton programme, en faisant attention de lui donner le même nombre d'arguments qu'il y avait de variables.
Pour cela, tu peux créer des variables en grand nombre, en utilisant l'indirection. Par exemple, ceci donne la liste des variables {x1,x2,...,xn}

Code: Select all

seq(#("x"&string(i)),i,1,n)

Merci !
Comme quoi, une idée c'est bien, mais ça devient vite très compliqué...

Et heu, avec ça, comment on fait pour manipuler la loi ?
Est-ce que une syntaxe du genre [f_loi(x,y)]-[f_loi(y,x)]=0 fonctionne ? (en mettant tout ça dans une boucle If par exemple)
Et du coup pour étudier la commutativité avec n arguments, ça devient plus compliqué...

A moins que lui donner un nombre indéfini d'arguments ne soit proscrit...

EDIT : où est-ce qu'il y aurait une liste des grandes fonctions de TI-Basic avec leurs effets ? Ça me permettrait au moins de comprendre à quoi correspond chaque ligne de ton code...

Pour la liste des fonctions, rien ne vaut le "Manuel"

Mais je peux commenter le code (d'ailleurs, à ce propos, Feature Request pour le forum : une coloration syntaxique avec indentation serait vraiment top !!)

"gettype" sert à connaître le "type" d'une variable. Ici, on regarde si le 2nd argument est une liste, et si ce n'est pas le cas, on rajoute les accolades nécessaires pour en faire une liste.

"dim" récupère le nombre d'éléments de cette liste (qui contient les variables)

"string" convertit la liste en chaîne de caractères.

"mid" récupère une partie de cette chaîne de caractères. Ici, cela me sert à me débarrasser des accolades de début et de fin, mais tout en gardant les virgules qui séparent les variables.

"&" sert à concaténer (c'est-à-dire coller bout-à-bout) 2 chaînes de caractères. Avec cela, je fabrique la chaîne de caractères qui va décrire ma fonction "f_loi".

Enfin, "expr" sert à convertir la chaîne de caractères en expression... et donc ici à exécuter la fonction "Define" qui crée la fonction "f_loi".

"f_loi" devient alors au sein de ce programme une fonction qui prend "n" arguments où "n" est le nombre de variables présentes dans ta chaîne de caractères. Comme je l'ai dit, tu peux fabriquer "n" variables avec "string" et "&" pour ensuite tester ce que tu veux sur cette loi.