Répondre

yoshi · 25-05-2009 09:28:31

Bonjour à tous,

Voilà, clap de fin : via le chat, il a été possible de faire fonctionner ce prog. L'erreur venait du return final de xeuklid : enlever les accolades autour du résultat...
Puisque ce prg d'illustration du théorème des restes chinois fonctionne, autant le réécrire de façon plus fonctionnelle.
Maintenant que je sais qu'on peut utilise plusieurs listes à la fois, je ne vais pas m'en priver : ça va simplifier les choses.
D'abord xeuklid :

: xeuklid(a,b)

: @ calcul de l'inverse de b modulo a

: Func

: Local q,r,x,y,s,xs0,xs1,ys0,ys1

: 1->xs0:0->xs1:0->ys0:1->ys1:1->s

: While b≠0

: mod(a,b)->r

: floor(a/b)->q

: b->a

: r->b

: xs1->x

: ys1->y

: q*xs1+xs0->xs1

: q*ys1+ys0->ys1

: x->xs0

: y ->ys0

: -s ->s

: Endwhile

: Return -s*ys0

: EndFunc

: Rst_chin()

: Prgm

: Local div_prod,i,inverses,modulos,nbequa,prd_part,restes,Som_prd

: 1 -> div_prod

: 0 -> Som_prd

: Input "Combien d'équations sont-elles utilisées ? ",nbequa

: newList(nbequa) -> inverses,modulos,prd_part,restes

: For i,1,nbequa

: Input "Entrer le reste",r

: r -> restes[i]

: Input "Entrer le modulo correspondant", m

: m -> modulos[i]

: div_prod*m -> div_prod

: EndFor

: For i,1,nbequa

: div_prod/modulos[i] -> prd_part[i]

: xeuklid(modulos[i],prd_part[i]) ->  inverses[i]

: Som_prod+restes[i]*prd_part[i]*inverses[i] -> Som_prd

: EndFor

: Disp "Le résultat est : ",Mod(Som_prd,div_prod)

: EndPrgm

Remarque : il n'est pas indispensable de stocke ni les inverses, ni les produits partiels (les Mi de BibM@th) dans une liste.
On peut écrire :
: div_prod/modulos[i] -> pp_i
: xeuklid(prd_part[i],modulos[i]) -> inv_i
: Som_prod+restes[i]*pp_i*inv_i -> Som_prd

Et dans ce cas, modifier la ligne : NewList (nbequa) ->... et supprimer les deux listes correspondantes.

@+

matro25 · 24-05-2009 20:53:46

Pour ton idée, je suis sur le chat Bibm@th

yoshi · 24-05-2009 20:50:24

RE,

Code rectifié sans fautes de frappe :

: 

: Rst_chin()

: Prgm

: Input "Combien d'équations à entrer",nbequa

: newList(4*nbequa) -> Donnees

: 2*nbequa-1 -> fin_bcl

: For i,1,fin_bcl,2

: Input "Entrer la valeur du modulo",d

: d -> Donnees[i]

: Input "Entrer la valeur du reste", r

: r -> Donnees[i+1]

: EndFor

: @ Début de la phase de calculs

: 1 -> div_prod

: For i,1,fin_bcl,2

: div_prod*Donnees[i] ->div_prod

: EndFor

: For i,1,nbequa

: 2*i-1 ->indice

: fin_bcl+1+i -> j

: div_prod/Donnees[indice] -> Donnees[j]

: EndFor 

: For i,1,nbequa

: 2*i-1 -> indice

: fin_bcl+1+i ->j

: fin_bcl+nbequa+1+i ->k

: xeuklid(Données[indice],Donnees[j]) -> Donnees(k)

: EndFor

: 0 -> Som_prd

: For i,1, nbequa:

: 2*i -> indice

: fin_bcl+1+i -> j

: fin_bcl+nbequa+1+i -> k

: Som_prd+Donnees[indice]*Donnees[j]*Donnees[k] -> Som_prd

: EndFor

: Mod(Som_prd,div_prod) --> Resultat

: Disp "Solution ",Resultat

: EndPrgm

Vérifie ligne à ligne avec ce que tu as écrit : il me restait 4/5 fautes de frappe...

Ensuite, je ne sais pas comment fonctionne ton xeuklid, donc cette ligne est sujette à caution :
xeuklid(Données[j],Donnees[indice]),nn

@+

matro25 · 24-05-2009 20:41:54

J'ai remarqué l'erreur que j'ai fait...No Comment j'ai pas mis "Input" mais "Inputstr" ...

Mais maintenant, j'ai mon programme qui tourne dans le vide, pour je ne sais pas quelle raison. Lorsque je le "break" et "go to" j'arrive dans ma fonction "xeuklid" que je copie ci dessous :

:xeuklid(a,b)
:Func
:Local q,r,x,y,s,xs0,xs1,ys0,ys1
:1->xs0:0->xs1:0->ys0:1->ys1:1->s
While b≠0
mod(a,b)->r
floor(a/b)->q
b->a
r->b
xs1->x
ys1->y
q*xs1+xs0->xs1
q*ys1+ys0->ys1
x->xs0
y->ys0
-s->s
Endwhile
Return {-s*ys0} // j'ai juste modifier pour que ça ne rende que ce dont j'ai besoin, et hors du programme ça fonctionne sans problème. J'ai vérifié en entrant xeuklid(17,66) = 8
EndFunc

Qu'est ce que t'en pense. Surtout que chaque fois que je mets break, ça me désigne "q*ys1+ys0->ys1"

yoshi · 24-05-2009 20:28:30

Salut,

Bon, le pb vient de ce que je n'ai pas la calculatrice, donc je tatonne...
Une remarque générale trouvée sur le Net :

remarque : s’il y a un souci avec un programme, vériﬁer que la TI est dans la bonne langue, et que
les listes sont bien créées (on le vériﬁe manuellement dans Apps/Stats List
Editor) ; le cas échéant créer ces listes.

Cela au passage me dit que je peux avoir plusieurs listes : quand ce prog marchera, on l'affinera...

Peut-être cela vient-il du INPUT : les prg que j'ai trouvés sur le Net sont peut-être faux...
Les as-tu essayés ?
Ce message d'erreur veut dire qu'il y a erreur sur le type de données entrées : il attend un nombre entier et il reçoît une chaîne, essaie avec Prompt d et Prompt r (possible d'écrire Prompt "Nombre d'équations ?",nbequa ?)
Regarde aussi comment est écrite ta fct xeuklid...

Pourtant, encore un début de prog trouvé :

: Résolution d’une équation du second degré

: second2()

: Prgm

: ClrIO

: Local delta,a,b,c,x1,x2

: Disp ”ax2 + bx + c = 0”

: Input ”a=?”,a

: Input ”b=?”,b

: Input ”c=?”,b

: b*b-4*a*c → delta

: If delta > 0 Then

...

...

....

Et le manuel dit bien :

Note. Cette instruction permet de saisir tous les types de variables : nombres, expressions,
chaînes...

Encore un essai :
Dans petit prg de Test, regarde voir
Essai n° 1
: Input "Entrer un nombre",nbequa
: Disp nbequa+1

Essai n°2
: Input "Entrer un nombre : ",a
: Disp a+1

Essai n°3
: Input "a = ?",a
: Disp a+1

En principe les trois marchent : on a droit à 8 caractères pour les noms de variables...

Tu peux aussi essayer d'initialiser la liste à une dimension de 20 (correspond à 5 equations) :
newList(20) -> Donnees

Tu auras alors un élément de réponse..

Essaie aussi de déclarer au début :
Local Donnees,i,indice,j,k,fin_bcl,nbequa,prod_div,Som_prd

Le % c'est, en principe modulo...
Je vérifie...
Bin non, j'ai cru voir ça sur le Net
A remplacer par Mod(Som_prd,div_prod) -> Resultat

@+

Attention après
@ Début de la phase des calculs
écrire 1 -> div_prod et non 1 -> prod_div
Remplace aussi newList par Newlist, puis aussi NewList des fois que...

Fais-moi part de tous tes essais...

Idée: Le + rapide serait de convenir d'une heure pour se brancher tous les 2 sur le chat de Bibm@th
Ainsi, j'aurais réponse à une question que je me (te) pose quelques secondes après...

matro25 · 24-05-2009 19:30:03

Alors, déjà, merci beaucoup pour tout le temps que t'y a passé.

J'aurais par contre des questions par rapport au programme. (non, il ne fonctionne pas tout a fait, lorsque je réponds à la première question (combien d'équations) il me met "error Data Type" et me redirect vers
: newList(4*nbequa) -> Donnees

Ensuite à la dernière ligne ": Som_prd%prod_div --> Resultat" le %????

yoshi · 24-05-2009 15:41:24

Bonjour,

Alors, pas de réponse sur ilemath ? Pas de bol !
Mon code définitif (j'ai changé qq noms de variables) :

: 

: Rst_chin()

: Prgm

: Input "Combien d'équations à entrer",nbequa

: newList(4*nbequa) -> Donnees

: 2*nbequa+1 -> fin_bcl

: For i,1,fin_bcl,2

: Input "Entrer la valeur du modulo",d

: d -> Donnees[i]

: Input "Entrer la valeur du reste", r

: r -> Donnees[i+1]

: EndFor

: @ Début de la phase de calculs

: 1 -> prod_div

: For i,1,fin_bcl,2

: div_prod*Donnees[i] ->div_prod

: EndFor

: For i,1,nbequa

: 2*i-1 ->indice

: fin_bcl+1+i -> j

: prod_div/Donnees[indice] -> Donnees[j]

: EndFor 

: For i,1,nb_equa

: 2*i-1 -> indice

: fin+1+i ->j

: xeuklid(Données[j],Donnees[indice]),nn

: fin_bcl+nbequa+1+i ->k

: nn -> Donnees[k]

: EndFor

: 0 -> Som_prd

: For i,1, nbequa:

: 2*i -> indice

: fin_bcl+1+i -> j

: fin_bcl+nbequa+1i -> k

: Som_prd+Donnees[indice]*Donnees[j]*Donnees[k] -> Som_prd

: EndFor

: Som_prd%prod_div --> Resultat

: Disp "Solution ",Resultat

: EndPrgm

Ca doit marcher...
J'ai traduit ce script en Python en le serrant au plus près, pour les entrées et les calculs. J'ai développé l'affichage à fin d'utilisation en simulation du fonctionnement de la calculatrice.
xeuklid (calcul de l'inverse modulo n) n'existant pas dans les mots-clés de la calculatrice (fabriqué en cours, j'ai vu) et n'ayant pas le code, je Bien évidemment le code python que voici, est horriblement moche :

#!/usr/bin/python

# -*- coding: cp1252 -*-

def bezout(a, b):

    ''' Calcule (u, v, p) tels que a*u + b*v = p et p = pgcd(a, b) '''

    if a == 0 and b == 0: return (0, 0, 0)

    if b == 0: return (a/abs(a), 0, abs(a))

    (u, v, p) = bezout(b, a%b)

    return (v, (u - v*(a/b)), p)

def inv_modulo(x, m):

    ''' Calcule y dans [[0, m-1]] tel que x*y % abs(m) = 1 '''

    (u, _, p) = bezout(x, m)

    if p == 1: return u%abs(m)

    else: raise Exception("%s et %s ne sont pas premiers entre eux" % (x, m))

print

print

print "***   Théorème des restes chinois    ***"

print

print

nbequa =int(raw_input("Combien d'équations avez-vous à entrer : "))

Donnees=[0]                    # J'initialise ma liste avec un 0 : les boucles commencent à 0 en Python et la TI à 1

fin_bcl=2*nbequa              # d'où la correction

print"                 **********"

for i in range(1,fin_bcl,2):

    d=int(raw_input("Entrer la valeur du modulo : "))

    Donnees.append(d)

    r=int(raw_input("Entrer la valeur du reste : "))

    Donnees.append(r)                    # J'ajoute les éléments les uns à la suite des autres

    print "       --------------"

    print "Donnees["+str(i)+"] =",Donnees[i],"   Donnees["+str(i+1)+"] =",Donnees[i+1]

    print "     ----------------"

# Début de la phase de calculs

div_prod =1 

for i in range(1,fin_bcl,2):

    div_prod*=Donnees[i]

print

print "div_prod =",div_prod

print

print "Calcul et Stockage des Mi"

for i in range(1,nbequa+1):

    indice = 2*i-1                          # A partir de maintenant, je commence à me préoccuper des indices...

    Donnees.append(div_prod/Donnees[indice])

    print "Donnees["+str(i+fin_bcl)+"] =",Donnees[i+fin_bcl]

print

print "Stockage des inverses modulo..."

for i in range(1,nbequa+1):

    indice = 2*i-1

    j=fin_bcl+i

    nn = inv_modulo(Donnees[j],Donnees[indice])

    Donnees.append(nn)

    print "Donnees["+str(j+nbequa)+"] =",nn

print

Som_prd = 0

print "Calcul de la somme des produits ai*Mi*yi (notations de l'ex. BibM@th)"

for i in range(1,nbequa+1):

    indice = 2*i

    j=fin_bcl+i

    k = fin_bcl+nbequa+i

    Som_prd+=Donnees[indice]*Donnees[j]*Donnees[k]

    print "Som_prd=",Som_prd

print

resultat = Som_prd%div_prod

print "Solution : ",resultat

Voilà ce que donne en fonctionnement :

***   Théorème des restes chinois    ***

Combien d'équations avez-vous à entrer : 3

                 **********

Entrer la valeur du modulo : 17

Entrer la valeur du reste : 3

       --------------

Donnees[1] = 17    Donnees[2] = 3

     ----------------

Entrer la valeur du modulo : 11

Entrer la valeur du reste : 4

       --------------

Donnees[3] = 11    Donnees[4] = 4

     ----------------

Entrer la valeur du modulo : 6

Entrer la valeur du reste : 5

       --------------

Donnees[5] = 6    Donnees[6] = 5

     ----------------

div_prod = 1122

Calcul et Stockage des Mi

Donnees[7] = 66

Donnees[8] = 102

Donnees[9] = 187

Stockage des inverses modulo...

Donnees[10] = 8

Donnees[11] = 4

Donnees[12] = 1

Calcul de la somme des produits ai*Mi*yi (notations de l'ex. BibM@th)

Som_prd= 1584

Som_prd= 3216

Som_prd= 4151

Solution :  785

@+

yoshi · 22-05-2009 19:33:41

Bonsoir,

ATTENTION !
J'ai corrigé/abondé la dernière partie du morceau de code proposé...
A la relecture, j'ai détecté une erreur d'indice :
les a_i de Bibm@th a_1, a_2, a_3 (qui servent à générer les M_i), mes "diviseurs" donc, sont rangés dans Eq_coeff[1], Eq_coeff[3], Eq_coeff[5]...etc et non dans Eq_coeff[1], Eq_coeff[2], Eq_coeff[3]...
D'où la modif en question !

Désolé !

Courage, on tient le bon bout...

@+

yoshi · 21-05-2009 17:07:32

'lut,

Oui, j'ai une idée... C'est pour ça que j'ai posé la question ; on dit bien : poser une question c'est y répondre...

Regarde du côté des listes : newList(nombre) -> Eq_coeff

Maintenant, il semble bien que l'on doive faire d -> y[1] avec des crochets et non des parenthèses. A vérifier...
Si oui alors on reprend :

: Restes chinois()

: Prgm

: Input "Entrer le nombre d'équations",nbequa:

: newList(4*nb*equa) -> Eq_Coeff

: 2*nbequa-1 -> fin

: for i,1,fin,2                               // dans l'ex. BibM@th fin = 5 et je ne veux que les indices 1,3 et 5

: Input "Entrer le diviseur",d

: d ->Eq_coeff[i]

: Input "Entrer le reste correspondant",r

: r -> Eq_coeff[i+1]

: EndFor

: 1 -> prod_div

: For i,1,nbequa

: 2*i-1 -> index

: prod_div*Eq_coeff[index] -> prod_div        // prod_div correspond au M de la démo de BibM@th

: EndFor

: For i,1, nbequa

: i+2*nbequa -> j                             // je génère nbequa indices consécutifs (à partir de fin+2)

: 2*i-1 -> index                              // je génère les indices 1,3, 5...

: prod_div/Eq_coeff[index] -> Eq_coeff[j]     // Je calcule les Mi de BibM@th  que je range à la suite                          

: EndFor

..

..

: Endprgm

Donc sur la base de l'ex. BibMath, je réponds
3 rangé dans nbequa.
Je fabrique l'indice de fin de boucle 2*3-1 = 5 rangé dans fin
Puis je boucle de 1 à 5 par pas de 2 et je réponds :
pour i = 1 : 17 -> Eq_coeff[1] et 3 -> Eq_coeff[1+1]
pour i = 3 : 11 -> Eq_coeff[3] et 4 -> Eq_coeff[3+1]
pour i = 5 : 6 -> Eq_coeff[5] et 5 -> Eq_coeff[5+1]
En boucle, je calcule le produit des diviseurs... -> div_prod
Maintenant je calcule les Mi, que je range à la suite de Eq_coeff[fin+2] à Eq_coeff[fin+nb_equa], autrement dit avec l'exemple BibM@th avec i de 1 à 3, de Eq_coeff[2*3+1] à Eq_coeff[2*3+3] :
M1 rangé dans Eq_coeff[7]
M2 rangé dans Eq_coeff[8]
M3 rangé dans Eq_coeff[9]

Maintenant il te faut calculer les y_i autrement dit les inverses de ces Mi et les ranger à la suite ou les inverser un par un et sommer les produits partiels dans une dernière variable somme_f par ex (pour somme finale : pas plus de 8 lettres pour une variable)

@+

matro25 · 21-05-2009 12:29:14

Bon, ça ne fonctionne pas. J'ai l'impression que le problème vient du fait qu'il faut définir ce que "y()" veut dire. T'aurais pas une idée pour ça, par hasard??

j'ai écrit le programme suivant :

:test()
:Prgm
:Local i,d,m
:1->i
:While i<3
:Input "entrer d",d
:d->y(i)
:i->m
:m+1->i
:Endwhile
:i=1
:Disp y(i), y(i+1)
:EndPrgm

yoshi · 21-05-2009 11:21:43

Bonjour,

T'as bien avancé...
Mais avant d'aller plus loin, il faudrait que je sache si ce que j'ai présumé vrai fonctionne...
Peux-tu voir si l'affichage des y(i),y(i+1) fonctionne ?
Autrement dit tester (à part)
: 17 -> y(1)
: 3 -> y(2)
: Disp y(1)
: Disp y(2)
et si on obtient bien 17 puis 3

@+

matro25 · 21-05-2009 10:17:58

Au cas ou, j'ai la fonction permettant de trouver l'inverse modulo.

Pour ce qui cloche, j'ai juste l'impression de créer variable après variable! Je te montre ce que j'ai jusqu'à maintenant.

: INPUT "Nombre d'équations", nbequa
: 2*nbequa-1 -> nbequa
: 1 -> i
: WHILE i < nbequa
: INPUT "Entrer le diviseur",d
: d ->y(i)
: INPUT "Entrer le reste",r
: r -> y(i+1)
: i + 2 -> i
: EndWhile
:1->a
:mod(a,2)=1
:for a<n
:PI(y(i+a)),mm //Multiplication de tout les y(i) avec nombres impairs (y(i1) x y(i3)...)
:endfor
:1->s
:While i<n
:mm/y(i),q
:q->y(s)
:y(i+2)->y(i)
:y(s+1)->y(s)
:Endwhile
:1->y(s)
:0->a
:1->k
:While s<n
:xeuklid(y(s),y(i+a)),nn //c'est la fonction de modulo inverse.
:nn->y(k)
:k+1->k
:y(s+1)->y(s)
:a+2->a
:Endwhile

Regarde déjà ceci...

yoshi · 21-05-2009 08:36:40

Bonjour,

Qu'est-ce qui cloche ?
Ce prg d'utilisation du th. des restes chinois, c'est un peu un non sens de refiler ça à un vrai débutant en programmation : c'est assez complexe, puisque qu'il faut calculer l'inverse modulo qq ch de 3,4,5,6.... nombres : je suis en train de réfléchir pour savoir comment on peut faire avec une calculatrice.
J'ai pensé à créer une nouvelle fonction genre :inv_mod(a,b) mais
1. je ne sais pas encore si on peut passer deux paramètres à une fonction dans une calc.
2. comment on appelle cette fonction dans le prg principal...

Ton prof aurait mieux fait de te demander de réaliser ce que j'ai fait seul pour mon 1er prog : rentrer un nombre a, donner deux bases l'une de départ bd, l'autre d'arrivée ba et il y a conversion du nombre a, écrit en base ba, dans la base bd ce qui n'est déjà pas si mal...

Je vais donc lire le manuel et m'instruire... ;-)

@+

Tu sais quand même accéder à la zone de programmation ? Si tu as déjà entré un code qui ne marche pas, donne ce code que je ou qu'on le regarde de près...
Sans ton code, difficile de savoir ce qui cloche !

matro25 · 20-05-2009 22:43:21

Bon, j'ai passé toute ma soirée dessus, et je n'y arrive toujours pas. Je comprends pas comment on écrit un * * * * * de programme correctement.

Je vais retenter demain, puisque je pense que maintenant, ça ne sert à rien de continuer!

matro25 · 20-05-2009 20:39:03

Okay, j'essaie de m'y mettre de suite avec cette solution!

Merci!

Forum de mathématiques - Bibm@th.net

Répondre

Résumé de la discussion (messages les plus récents en premier)

Pied de page des forums