Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#76 Re : Programmation » [Python] Identité de Bachet-Bezout. » 05-07-2009 23:42:33

Yop,

yoshi a écrit :

@Barbichu
Est-ce que tu peux préciser ta pensée ? Je ne comprends pas :

l'utilisation de variables globales modifiées par un appel à une fonction (qui en plus retourne une valeur)

Si tu ne passes pas en argument à une fonction, une valeur obtenue depuis le corps du prog, comment fais-tu alors ?

je parle, dans le cas particulier de Golgup, de l'utilisation des variables 't1' et 't2' qui sont modifiées par effet de bord par chaque appel à la fonction 'modulo' (dans le corps de laquelle on n'a même pas moyen de comprendre d'où viennent ces deux variables). Ces deux variables sont les "resultats" plus ou moins utiles de la fonction pgcd, qui dépend donc d'une bonne initialisation exterieure des deux variables en question (qu'il n'est pas possible de garantir dans le cas d'un autre programme).
Ce genre de manipulation rend les deux fonctions modulo et pgcd extrêmement dangereuses à être appelées : en effet, leur correction dépend complètement du contexte d'exécution, ... une chose extrêmement regrettable.
++

#77 Re : Programmation » [Python] Identité de Bachet-Bezout. » 04-07-2009 02:17:43

Yop,
"Oh mon dieu que c'est moche" serait la remarque (absolument non constructive) que je m'autoriserais à faire si j'étais ton prof d'info (dans le supérieur, parce que dans le secondaire ça semblerait décourageant). Malheureusement, tu n'es pas mon élève, tu n'as sûrement pas de cours d'info digne de ce nom, tu n'es pas dans le supérieur et je ne suis pas prof (enfin, ça dépend de la définition de prof). Je me contenterai donc de justifier ma remarque par un argument primitif : j'évacue pour passer à la suite de façon plus constructive.

Tout d'abord, j'admire l'entrain et le bon sens dont tu fais preuve pour écrire un code permettant de résoudre des problèmes que l'on aborde normalement bien plus tard (les problèmes aussi bien que leur code).

Par contre, et pour que tu puisses progresser, voici les reproches que je fais à ton code :
1/ Il utilise des effets de bords : typiquement, l'utilisation de variables globales modifiées par un appel à une fonction (qui en plus retourne une valeur) est une chose déconseillée dans le cas général. (En fait, c'est une façon de programmer tout à fait acceptable quand on a une bonne raison de le faire, ce qui n'est à mon humble avis pas le cas ici).

2/ Le langage python te fourni un modulo : l'opérateur est %, utilise le ! Il est bon de savoir comment le reprogrammer à partir de rien, mais par exemple tu n'as jamais envisagé de reprogrammer l'addition ? De plus, le modulo de python a beaucoup de chance d'être plus efficace que ton implémentation.
2bis/ La division entière ne nécessite pas de typecast vers les entiers : a/b est le quotient dans la division euclidienne de a par b.

3/ Pour programmer de façon propre, on distingue (au moins) deux types de fonctionnalités : le calcul d'une part, l'interaction homme-machine d'autre part. Il convient alors d'encapsuler :
   * d'un côté les fonctions de calcul, comme pgcd ou modulo (ça tu l'as fait), mais aussi ta boucle while et tes calculs compliqués que tu as mis au milieu des print ! Ça constitue en quelque sorte ce qu'on appelle généralement "librairie" (sauf que là c'est une librairie locale)
   * de l'autre coté, une fonction qui fait appel aux input et aux print. Cette fonction étant appelée lors de l'exécution du fichier.


NB :
J'avais donné une version compacte de la fonction qui résout ton problème, que j'ai nommée bezout, ici : http://www.bibmath.net/forums/viewtopic.php?id=2479 (Il s'agit là d'une version fonctionnelle, de surcroît récursive)
Il y également une version impérative donnée par yoshi, ici : http://www.bibmath.net/forums/viewtopic.php?id=2701 sous le nom xeuklid qui doit être légèrement modifié pour te sortir les coefs de bezout, mais si tu me demandes, je te la donne.

N'hésite pas à poser des questions si je ne suis pas clair dans mon commentaire, si tu veux que je donne des exemples plus précis, où si tu veux que je développe quelque chose.

++

#78 Re : Entraide (supérieur) » théorie des nombres et language formel [Résolu] » 28-05-2009 20:31:20

Yop,
A vue de nez d'informaticien, je dirais qu'on ne peut pas l'exprimer au premier ordre (i.e. en ne quantifiant que sur des entiers, et pas sur des prédicats). Je n'ai pas trop le temps d'y réfléchir, mais dès que j'ai le temps je réponds.
++

#79 Re : Programmation » [Python] Appartenance d'un element à une liste [Résolu] » 22-05-2009 23:09:27

Salut,
oui, ça s'appelle "in".
Par ex "3 in [3,4]" te répond "True".
++

#80 Re : Entraide (supérieur) » exo ens [Résolu] » 17-05-2009 20:12:09

Re,
Merci de m'avoir lu: j'ai en effet passé plus de temps à rédiger qu'à comprendre le problème.
Oui, quand je parle des dérivées de P, je compte également P. Et oui, je défini deux fois n, il ne faut pas tenir compte de la première définition (degré du polynôme) que je n'utilise jamais.
Et si ça peut te rassurer, je ne pense pas que j'étais capable de faire ça en sortant de taupe.
++

#81 Re : Programmation » [Visual Basic] Algorithme de Cesar » 17-05-2009 19:59:20

Lut,
http://fr.wikipedia.org/wiki/Rubicon
La première section de l'article devrait te permettre de tout comprendre.
++

#82 Re : Entraide (supérieur) » exo ens [Résolu] » 17-05-2009 16:33:44

De rien,
s'il y a quelque chose que tu ne comprends pas, n'hésite pas à me demander. Notamment je n'ai pas détaillé à fond toutes les preuves et je ne suis pas à l'abri d'erreurs de typo.
++

#83 Re : Entraide (supérieur) » exo ens [Résolu] » 14-05-2009 17:54:33

Re, allons-y

La formalisation fait paraitre le problème plus compliqué qu'il ne l'est vraiment. On en comprend très bien l'intuition en faisant de jolis dessins sur tableau noir. Malheureusement je n'ai pas de tableau noir sur bibmath ...

L'intuition est que lorsqu'on passe par une racine de multiplicté n de P, on décroit de n.
Et lorsqu'on passe des racines de dérivées de P qui proviennent de racines complexes dans P, alors on décroit également de la multiplicité de ces racines (sachant que les racines complexes viennent toujours par 2 !!!)
Là où ça devient délicat c'est qu'en un point x on peut trouver simultanément des racines de P et des racines complexes de P, mais également des parasites dans les dérivées qui proviennent des autres racines de P.
Heureusement, on ne cherche jamais à savoir si on a rencontré des racines complexes, ou des parasites.

On va donc décomposer le V en trois types de blocs :
* les racines réelles (cf C/a/) :
une racine nieme se détecte par l'annulation des n-1 premieres dérivées et la non annulation de la nieme.
On va voir que c'est sur les changements de signes de cette zone que s'effectue la décroissance en n (cf B/).

* les parasites+les racines complexes (cf C/b/)
on les trouves forcement plus bas, et le fait que la paraité de V y soit conservé est un petit miracle (cf A/ + B/ => C/b/)

* les zones sans problème (cf C/c/)

Exemples
Première lignes = valeurs de x
Deuxième ligne = séparateurs
Lignes suivantes = signes de P et de ses dérivées successives au point x

Ex1 : X^3 (Réel pur, sans parasites)

 0
===
-0+
+0+
-0+
+++

Ex2 : X^3-1, (une racine rélle, deux racines complexes conjuguées, pas d'interference)

 0 1
=====
---0+
+0+++
-0+++
+++++

Ex3 : X^3+X (une racine réelle, deux racines complexes conjugués, qui interferent avec cette derniere)

 a 0 b
=======
---0+++
+++++++
---0+++
+++++++

Ex4 : X^3-X (3 racines réelles, -1 0 et 1. et la combinaison de -1 et 1 parasite 0, sans compter)

 a b 0 c d
===========
-0+++0---0+
+++0---0+++
-----0+++++
+++++++++++

================================
===         FORMALISATION              ===
================================
/!\ Attention, danger pour les neurones /!\

Considérons [tex]P[/tex] un polynôme de degré [tex]n[/tex]. 
Étant donné un étant donné un élément [tex]x \in \mathbb{R}[/tex] on défini les notations suivantes :
* [tex]\mathcal{O}(x) = \{i | P^{(i)}(x) = 0\}[/tex]
* [tex]\mathcal{V}(x)_{[[i,j]]} = \left\{ (i',j')\ /\ \begin{Bmatrix} i \le i'<j' \le j,\ P^{(i')}P^{(j')} < 0 \\ \wedge\; \forall k \textrm{ tq } i'<k<j',  P^{(k')}=0 \end{matrix} \right\}[/tex]
* [tex]V_{[[i,j]]}(x) = \textrm{Card}(\mathcal{V}_{[[i,j]]}(x))[/tex]
* [tex]\mathcal{V}(x) = \mathcal{V}_{[[0,n]]}(x)[/tex]
  * Alors [tex]V(x) = \textrm{Card}(\mathcal{V}(x))[/tex]
On remarque que si [tex]k\not\in\mathcal{O}(x)[/tex], alors [tex]\mathcal{V}(x)_{[[i,j]]} = \mathcal{V}(x)_{[[i,k]]} \sqcup \mathcal{V}(x)_{[[k,j]]}[/tex] (R)

I/ Preliminaires
A/ Si [tex]x \in \matR[/tex],  [tex]i<j[/tex] et [tex]P^{(i)}(x)P^{(j)}(x) \neq 0[/tex] alors :
[tex]P^{(i)}(x)P^{(j)}(x) > 0[/tex] ssi [tex]V_{[[i,j]]}(x)[/tex] est pair
Preuve :
Trivial par recurrence forte sur [tex]j-i[/tex] :
* Si [tex]j-i[/tex] = 1,  [tex]P^{(i)}(x)P^{(j)}(x) > 0 \Leftrightarrow (i,j)\not\in\mathcal{V}_{\{i,j\}}\Leftrightarrow \mathcal{V}_{[[i,j]]} = \varnothing  \Leftrightarrow V_{[[i,j]]}=0 [/tex]
   En effet : [tex]\mathcal{V}_{[[i,j]]} \subset \{(i,i+1)\}[/tex]

* Sinon, soit [tex]k>i[/tex] le plus petit, tel que [tex]k\not\in\mathcal{O}(x)[/tex].
   * Si [tex]k=j[/tex], la démo est la même que ci-dessus (Attention, on utilise pas d'hypothèse de récurrence ici)
   * Sinon, on applique l'hypothèse de récurrence à [tex](i,k)[/tex] et [tex](k,j)[/tex] on recolle par (R)
Qed.


Considérons maintenant [tex]a,x, b \in \matR[/tex] tels que [tex]a < x < b[/tex] d'une part
et tel que pour tout [tex]y \in [a,x[\cup]x,b][/tex] aucune des dérivées de P ne s'annule.
(Notez bien que je n'impose rien sur [tex]x[/tex])

B/ Si [tex]i \in \mathcal{O}(x)[/tex] alors [tex](i,i+1) \in \mathcal{V}(a)[/tex] et  [tex](i,i+1) \not\in \mathcal{V}(b)[/tex]
Preuve :
(C'est l'argument de Fred, mais mieux localisé)
Comme [tex]i \in \mathcal{O}(x)[/tex], on a [tex]P^{(i)}(x)=0[/tex].
(i) Supposons [tex]P^{(i+1)}(a)>0[/tex] (le cas négatif s'en déduit par symmétrie et le cas nul est éliminé par hypothèse)
On sait par hypothèse que [tex]P^{(i+1)}[/tex] ne s'annule pas sur [tex][a,x[[/tex], d'où [tex]P^{(i)}[/tex] croissante sur [tex][a,x[[/tex].
Et comme [tex]P^{(i)}[/tex] s'annule seulement en [tex]x[/tex], il est négatif sur [tex][a,x[[/tex] donc en a .
Donc [tex](i,i+1) \in \mathcal{V}(a)[/tex]
(ii) Idem, mais en raisonnant sur l'intervalle [tex]]x,b][/tex]. On trouve [tex](i,i+1) \not\in \mathcal{V}(a)[/tex].
Qed.

Soit maintenant [tex]i_0, j_0, i_1, j_1 \ldots , i_p, j_p[/tex] tels que
* [tex]\forall k\in[[0,p]], i_k \leq j_k [/tex]
* [tex]\forall k\in[[0,p-1]], j_k + 1 < i_{k+1} [/tex]
* [tex]\mathcal{O}(x) = [[i_0,j_0]] \sqcup \ldots \sqcup [[i_p,j_p]][/tex]
(On pose par convention : [tex]j_{-1}=0[/tex] et [tex]i_{p+1}=n[/tex])

C/  Montrons que :
   a/ Si [tex]k\in[[0,p]][/tex] et [tex]i_k=0[/tex] (on a alors nécessairement [tex]k=0[/tex]), alors  [tex]V_{[[i_k,j_k+1]]}(a) = j_k-i_k+1[/tex] et [tex]\mathcal{V}_{[[i_k,j_k+1]]}(x) = \mathcal{V}_{[[i_k,j_k+1]]}(b)) = \varnothing[/tex]
Preuve :
On remarque que par constructions des [tex](i_k,j_k)[/tex], on a nécessairement [tex]P^{(j_k+1)}[/tex] non nul.

On a [tex][[i_k,j_k]] \subset \mathcal{O}(x)[/tex], d'où par B/ :
(i) [tex]\forall i \in [[i_k,j_k]] (i,i+1) \in \mathcal{V}[[i_k,j_k+1]](a)[/tex], et alors [tex]V_{[[i_k,j_k+1]]}(a) = j_k-i_k+1[/tex]
(ii) [tex]\forall i \in [[i_k,j_k]] (i,i+1) \not\in \mathcal{V}[[i_k,j_k+1]](b)[/tex] et alors  [tex]\mathcal{V}_{[[i_k,j_k+1]]}(b) = \varnothing[/tex]
Enfin, comme il n'existe pas dans [tex]\mathcal{V}[[i_k,j_k+1]](x)[/tex] de paire [tex](i,j)[/tex] tel que [tex]P^{(i)}[/tex] et [tex]P^{(j)}[/tex] soient simultanment non nuls, on a nécessairement  [tex]\mathcal{V}_{[[i_k,j_k+1]]}(x) = \varnothing[/tex]
Qed.


    b/ Si [tex]k\in[[0,p]][/tex] et [tex]i_k>0[/tex],  alors [tex]V_{[[i_k-1,j_k+1]]}(a) \geq V_{[[i_k-1,j_k+1]]}(x) = V_{[[i_k-1,j_k+1]]}(x)[/tex] et
[tex]V_{[[i_k-1,j_k+1]]}(a) \equiv V_{[[i_k-1,j_k+1]]}(x) \pmod 2[/tex]
Preuve :
On remarque que par constructions des [tex](i_k,j_k)[/tex], on a nécessairement [tex]P^{(i_k-1)}(x)[/tex] et [tex]P^{(j_k+1)}(x)[/tex] non nul.

* On a [tex][[i_k,j_k]] \subset \mathcal{O}(x)[/tex], d'où par B/ :
[tex]\forall i \in [[i_k,j_k]] (i,i+1) \not\in \mathcal{V}[[i_k,j_k+1]](b)[/tex] et alors  [tex]\mathcal{V}_{[[i_k-1,j_k+1]]}(b) \subset \{(i_k-1,i_k)\}[/tex]

* Comme il existe  dans [tex]\mathcal{V}[[i_k-1,j_k+1]](x)[/tex] un unique paire [tex](i,j) = (i_k-1,j_k+1)[/tex] telle que [tex]P^{(i)}[/tex] et [tex]P^{(j)}[/tex] soient simultanment non nuls, on a nécessairement  [tex]\mathcal{V}_{[[i_k,j_k+1]]}(x) \subset \{(i_k-1,j_k+1)\}[/tex]


Donc [tex]V_{[[i_k,j_k+1]]}(b)[/tex] et [tex]V_{[[i_k,j_k+1]}](x)[/tex] sont dans [tex]\{0,1\}[/tex]
Et dans les deux cas, la parité du cardinal détermine complètement le cardinal :

Enfin, comme  [tex]P^{(i_k-1)}P^{(j_k+1)}[/tex] ne s'annule ni en [tex]a[/tex], ni en [tex]b[/tex], ni en [tex]x[/tex], on en tire par A/ que les trois cardinaux
[tex]V_{[[i_k-1,j_k+1]]}(a)[/tex], [tex]V_{[[i_k-1,j_k+1]}](b)[/tex] et [tex]V_{[[i_k-1,j_k+1]}](x)[/tex] ont même parité.

On en tire trivialement l'énoncé
Qed.


    c/ Si [tex]k\in[[-1,p]][/tex], alors [tex]\mathcal{V}_{[[j_k+1,i_{k+1}-1]]}(a)) = \mathcal{V}_{[[j_k+1,i_{k+1}-1]]}(x)) = \mathcal{V}_{[[j_k+1,i_{k+1}-1]}](b))[/tex]
Preuve :
Trivial : Il n'y a pas de changements de signes hors de [tex]\mathcal{O}(x)[/tex].
Qed.


D/ Enfin, si [tex]P[/tex] admet une racine [tex]n^{\textrm{ieme}}[/tex] en [tex]x[/tex] (avec [tex]n[/tex] éventuellement égal à [tex]0[/tex]),
alors
(i) [tex]V(a) - V(b) \geq n[/tex] et [tex]V(a) - V(b) \equiv n \pmod 2[/tex]
(ii) [tex]V(x) = V(b)[/tex]

Preuve :
On rappelle que par (R) on a : [tex]\forall u \in \{a,x,b\}, \mathcal{V}(u) = \bigsqcup_{k=0}^{p}\mathcal{V}_{[[i_k-1,j_k+1]]}(u)
\sqcup \bigsqcup_{k=-1}^{p}\mathcal{V}_{[[j_k+1,i_{k+1}-1]]}(u)[/tex] (car aucun des $i_k-1$ et $j_k+1$ n'est dans $\mathcal{O}$)

(ii) Trivial par C/a/b/c/ : il y a toujours égalité des [tex]V[/tex] pour [tex]x[/tex] et [tex]b[/tex].

(i) Il y a deux cas a distinguer :
   a) [tex]n = 0[/tex], donc [tex]x[/tex] n'est pas vraiment une racine de [tex]P[/tex]. Alors le cas C/a/ disparait, le cas C/c/ permet de simplifier la comparaison et il n'y a qu'à appliquer le cas C/b/ pour trouver que [tex]V(a) - V(b) \geq 0[/tex] et  [tex]V(a) - V(b) \equiv 0 \pmod 2[/tex]
   b) [tex]n > 1[/tex], on sait alors que les [tex]n-1[/tex] premières dérivées de [tex]P[/tex] s'annulent en [tex]x[/tex] et que la dérivée nième ne s'y annule pas. D'où [tex][[i_0,j_0]] = [[0,n-1]][/tex] et alors
[tex]V_{[[i_0,j_1]]}(a) = n[/tex] et [tex]V_{[[i_0,j_1]]}(b) = 0[/tex], par C/a/. En assemblant le reste avec C/b/ et C/c/. On obtient le resultat voulu.

Qed.


Rq : de D/ on déduit également :
(iii) [tex]V(a) - V(x) \geq n[/tex] et [tex]V(a) - V(x) \equiv n \pmod 2[/tex]

II/ Cas général
Soient [tex]a,b\in\matR[/tex] avec [tex]a < b[/tex] et [tex]P(a)P(b) \neq 0[/tex]
L'ensemble des points en lesquels P ou l'une de ses dérivées s'annule sur [tex]]a,b[[/tex] est fini, notons [tex]a < x_1 < \ldots < x_N < b[/tex] ses points. Et soient [tex]\mu_1, \ldots, \mu_N[/tex] leur multiplicité respective (éventuellement nulle) en temps que racine de P.
Soient alors [tex]a_0,\ldots,a_N[/tex] tels que [tex]a < a_0 < x_1 < \ldots < a_{N-1} < x_N < a_N < b[/tex]
On a [tex]V(a) - V(b) = V(a) - V(a_0) + \sum_{k=0}^{N-1}\left(V(a_k) - V(a_{k+1})\right) + V(a_N) - V(b)[/tex]

Or, en appliquant D/ judicieusement :
* [tex]V(a) - V(a_0)= 0[/tex] par D/(ii)
(en effet, [tex]a[/tex] joue le rôle de [tex]x[/tex] et [tex]a_0[/tex] le rôle de [tex]b[/tex] dans D/).
* [tex]V(a_k) - V(a_{k+1}) \geq \mu_{k+1}[/tex] et [tex]V(a_k) - V(a_{k+1}) \equiv \mu_{k+1} \pmod 2[/tex] et par D/(i)
(en effet, [tex]a_k[/tex] joue le rôle de [tex]a[/tex] et [tex]a_{k+1}[/tex] le rôle de [tex]b[/tex] dans D/).
* [tex]V(a_N) - V(b) \geq 0[/tex] et [tex]V(a_N) - V(a_b) \equiv 0 \pmod 2[/tex] par D/(iii)
(en effet, [tex]a_N[/tex] joue le rôle de [tex]a[/tex] et [tex]b[/tex] le rôle de [tex]x[/tex] dans D/).

En sommant, on obtient [tex]V(a) - V(b) \geq \sum\mu_k[/tex] et [tex]V(a) - V(b) \equiv \sum\mu_k \pmod 2[/tex] CQFD !


III/ La question 2 : appliquer la question 1 en 0 et b avec b suffisamment grand !

Ouahou !

#84 Re : Entraide (supérieur) » exo ens [Résolu] » 14-05-2009 10:59:27

Salut!
Ça y est, j'ai enfin une solution élégante ! Je vous l'expose dès que j'ai un vrai PC.
++

#85 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Paradoxe de Monty Hall amélioré » 11-05-2009 10:41:58

Salut,
Non, si on sait que le présentateur tire au hasard, on a une chance sur deux pour chaque à la fin.
En fait, j'ai l'impression (parce que ça, je ne l'ai pas vérifié) que si le choix du présentateur est indépendant de la position de la voiture, alors on a une chance sur deux pour chaque choix à la fin.

++

Edit> Je n'avais pas non plus lu jusqu'au bout, mais l'article wikipédia est d'accord avec moi : http://fr.wikipedia.org/wiki/Problème_d … 7ouverture (et pousse même plus loin http://fr.wikipedia.org/wiki/Problème_d … e_globale)

#86 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 17:51:12

Re, c'est pourtant celle-là même, mais formalisée pour être implémentée. ++

Edit> si je reprends l'exemple du dernier post (#10) du thread que tu m'indiques :
aux lignes 2, 5 9 et 13 de ton calcul, on retrouve le fameux [tex]bu + (a - bq)v[/tex],
et les lignes intermédiaires à ces dernières consistent à mettre le terme sous la forme [tex]av + b(u - qv)[/tex]  ...

#87 Re : Entraide (supérieur) » Matrice [Résolu] » 10-05-2009 17:42:44

Salut,
la méthode ? Il n'y a pas de méthode pour tout, parfois il faut juste plonger les mains dans le cambouis et essayer des trucs. Souvent d'ailleurs ce n'est pas une méthode qu'on cherche mais une reformulation de la question, qui elle admet une méthode "connue".
Ici la reformulation serait "comment savoir si alpha*X est solution de l'équation ?" et la méthode est : "injecter alpha*X dans l'équation et calculer/regarder sous quelles conditions elle la vérifie".
++

#88 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 17:28:27

Re,
I/
Le "import inv_modulo" importe le fichier inv_modulo.py en temps que module.
Tu peux donc utiliser la fonction inv_modulo en la désignant par inv_modulo.inv_modulo et la fonction bezout en la désignant par inv_modulo.bezout.
Comme on a pas envie de toujours préciser que ça vient du module inv_modulo, on importe chacune des fonctions du module indépendamment.
Par exemple, on peut faire

>>> from inv_modulo import bezout
>>> from inv_modulo import inv_modulo

ou alors les deux d'un seul coup

from inv_modulo import bezout, inv_modulo

[edit> Ça marche pareil avec tous les modules, sous linux comme sous windows.]
[edit2> Ce qui peut aussi prêter à confusion est que le fichier (donc le module) porte le même nom qu'une des fonctions qu'il contient, ce qui peut sembler peu judicieux, mais c'est discutable ...]

II/
Pour l'algo de bezout, c'est celui qu'on fait à la main pour trouver les coefficients de bezout.
On va supposer qu'on ne l'applique que sur les couples a, b tels que [tex]a\geq b[/tex].

Cas de base n°1 : [tex]a=b=0[/tex] => trivial
Cas de base n°2 ; [tex]a>0, b=0[/tex] => [tex]u = 1, v=0[/tex] et [tex]p = a[/tex]
Étape de récurence, [tex]b>0[/tex] et [tex]a \geq b[/tex]
   * soient [tex]q[/tex] et [tex]r < q[/tex] le quotient et le reste dans la div eucl de [tex]a[/tex] par [tex]b[/tex] : on a [tex]a = qb + r[/tex]
   * on applique bezout sur [tex](b,r)[/tex]. (qui est strictement plus petit que [tex](a,b)[/tex] pour l'ordre lexicographique)
        on obtient [tex]u[/tex], [tex]v[/tex] et [tex]p[/tex] tels que [tex]bu+rv=p[/tex] et [tex]\textrm{pgcd}(b,r) = p[/tex]
   * Or [tex]r = a - bq[/tex], donc [tex]bu+(a-bq)v=p[/tex] et  [tex]\textrm{pgcd}(b,a-bq) = p[/tex]
       ou encore : [tex]av + (u-qv)b = p[/tex] et  [tex]\textrm{pgcd}(b,a) = p[/tex]
   * Donc les coefficients de bezout sont [tex]v[/tex] et [tex]u-qv[/tex], et le pgcd est [tex]p[/tex]


III/ Pour conclure, on passe au modulo dans la relation de bezout [tex]xu+mv = 1[/tex]
Ce qui donne : [tex]xu = 1 \mod m[/tex]

#89 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 17:02:58

Re,
le passage avec if __name__ ... ne sert que pour la ligne de commande shell (et ms-dos si c'est compatible)
(sous ligne de commande ms-dos, il doit falloir faire C:\chemin_complet_vers_python\python inv_modulo.py 2 5)

Par contre pour l'utiliser dans le shell python, il suffit de faire l'import et d'utiliser la fonction, comme une fonction python, grâce au petit bout de code de mon dernier message en exemple ; et je suis certain que ça marche chez toi, vu que "import inv_modulo" a marché dans ton shell python. (Et il n'y a rien à modifier par rapport au fichier que j'ai soumis ici)
++

#90 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 16:46:39

Erf,
Le $ représente le prompt de ma ligne de commande bash. Il faudrait que tu essayes depuis la ligne de commande cmd de windows, mais je ne sais pas si c'est compatible.

Sinon le "import inv_modulo" dans le shell python devrait marcher ... Et d'ailleurs il marche.
Ensuite il faut que tu utilises la fonction python. Donc que tu tapes :

>>> from inv_modulo import inv_modulo
>>> inv_modulo(3,5)

#91 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 16:33:30

Re,
Un petit benchmark, sur ma machine
./inv_modulo_yoshi.py 10000001 100000000000000 => résultat en 15 secondes
./inv_modulo.py 10000001 100000000000000 => résultat en moins d'1 seconde

./inv_modulo_yoshi.py 100000001 1000000000 => résultat en 2min 12 secondes
./inv_modulo.py 100000001 1000000000; => résultat en moins d'1 seconde

++

#92 Re : Programmation » [Pascal] ou [CaML] cours » 10-05-2009 16:07:36

Salut Fred,
le programme de MPSI/MP laissant le choix entre pascal et caml (peut-être pour des raisons de backward compatibility avec les profs ?), il paraîtrait que dans certaines prépa, c'est le choix de pascal qui a été fait pour enseigner aux élèves de taupe. Donc, oui forcement, il y a encore des gens qui en font ...
++

#93 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 15:55:28

Re,
C'est sensé remplacer l'integralité de ton code, à condition de rajouter à la fin

a,modulo=1572,5441
print "L'inverse de %s modulo %s est : %s" % (a,modulo,inv_modulo(a,modulo))

et de supprimer toute la partie if __name__ ....

Et sinon
1. Oui, ma fonction bezout est récursive, je pourrais la dérécursifier, mais elle est plus agréable et mieux compréhensible ainsi
2. le "_" est une variable "puits", que je n'utiliserai donc pas. J'aurais très bien pu mettre "v" ou "toto", ce qui aurait mis un nom inutile dans l'espace de nom de ma fonction.

[edit] voila qui devrait te renseigner un peu mieux
++

#94 Re : Programmation » [Python] problème de liste » 10-05-2009 15:48:56

Salut,
je n'avais pas vu non plus ce topic.
Lorsqu'on fait

 a = b

, on dit à python que b désigne le même objet que celui que désigne a.
Donc si on modifie b, on modifie a, quelque soit l'objet, (y compris les entiers et les strings, cf [*]).

Si on regarde l'exemple de yoshi, quand il affecte une nouvelle valeur à une variable, il crée en fait un nouvel objet (le membre droit de l'affectaction), et demande à la variable d'y réferer. Par contre, si dans son exemple sur les chaines de caractères, yoshi avait modifié la variable ch1 au lieu de la réaffecter, ch2 aurait aussi changé, ... [*] sauf qu'en python on ne peut changer la valeur d'un int, ou d'une string.

++

#95 Re : Programmation » [Python] Calcul de l'inverse modulo n d'un nombre » 10-05-2009 15:02:41

Salut yoshi,
je n'avais pas vu ce programme. Je te propose cette version qui est plus courte et beaucoup plus efficace :

#!/usr/bin/python
# -*- coding: utf-8 -*-

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))


if __name__ == "__main__":
    from sys import argv
    try :
        x, m = int(argv[1]), int(argv[2])
        print "L'inverse de %s modulo %s est : %s" % (x,m,inv_modulo(x,m))
    except Exception, m:
        print m
        print "Merci de choisir un autre couple de valeurs"

[Edit] J'ai ajouté à mon code de quoi le rendre autonome pour répondre à la question de yoshi
Il s'utilise maintenant de la ligne de commande en lui fournissant comme argument le nombre et le modulo. Exemple, si je l'enregistre sous le nom "inv_modulo.py" :

$ ./inv_modulo.py 2 5
L'inverse de 2 modulo 5 est : 3
$ ./inv_modulo.py 2 4
2 et 4 ne sont pas premiers entre eux
Merci de choisir un autre couple de valeurs

++

#96 Re : Programmation » [Pascal] ou [CaML] cours » 08-05-2009 23:23:36

Salut,
pour pascal je ne suis pas fan, je ne peux te dire plus que "google it".

Pour caml, il y a deux langages qui peuvent correspondre à tes attentes : Ocaml et caml-light.
Comme le dit son nom, caml-light est une version allégée de Ocaml et facilement installable et utilisable.
L'usage de caml-light est trés répandu pour la programmation en classe prépa (tu peux le télécharger sur : http://caml.inria.fr/caml-light/release.fr.html)

Dans tout les cas, je te recommande le livre "Le Langage Caml" de P. Weis et X. Leroy (plus d'info sur http://caml.inria.fr/pub/old_caml_site/ … amlprimer) que tu dois pouvoir trouver facilement en bibliothèque universitaire scientifique. (Xavier Leroy étant à l'origine des langages caml-light et Ocaml)

Il y aussi un tuto officiel qui me semble sympa : http://www.ocaml-tutorial.org/fr pour Ocaml cette fois-ci.

Et sinon, il y a plein de chargés de TP en prépa qui ont fait des TP Caml Light plus ou moins sympa, tu peux éventuellement piocher dedans pour t'exercer.
En vrac, j'aime bien les TP de :
* J-C Filliâtre, niveau MP info : http://www.lri.fr/~filliatr/tp_caml.en.html
* Mathieu Giraud, niveau MP info : http://magiraud.free.fr/tpcaml/
* Cyril Cohen, niveau MPSI info : http://perso.crans.org/cohen/stanislas/
* Fabien Viger, niveau MPSI info : http://fabien.viger.free.fr/liafa/caml/

Pour toute question sur caml, n'hésite pas à me contacter.

++

PS : Si tu t'intéresses à l'informatique, le langage caml vaut vraiment le détour.

#97 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Pi et Phi : apparitions des décimales non aléatoires » 04-05-2009 13:13:12

J'ai lu tes documents, et tu nous donne là un bon exemple qu'on peut faire dire au chiffres tout ce qu'on veut.
Si tu choisi à la fois les constantes et le pattern, il n'y a plus rien d'exceptionnel ! C'est comme si je te disais :
"dans le nombre 1/Phi=0,61803398874989484820458684749214, il y avait 1 chances sur  1 000 000 que les 6 premières décimales soient 618033 !", or tu m'accorderas que ça n'a rien d'exceptionnel.

J'ai écrit un petit programme python qui permet, à partir de 2 séquences de décimales de trouver un pattern divisé en au moins 4 zones. ça a 4% de chances d'arriver (résultat experimental). J'ai tenté une autre experience : je tire au hasard 100 séquences décimales, j'arrive alors à trouver un pattern de au moins 4 zones qui recouvre une 15aines de ces séquences.

Cela veut dire que si j'essaye d'attraper un maximum de "constantes fondamentale", entre pi, phi, e, leurs inverses, des racines carrés diverses, et des combinaisons qu'on retrouve dans le monde des maths, je dois bien trouver là plus d'une 100aine de séquences, et ce n'est donc pas improbable du tout d'y coller un schema comme tu l'as fait ! Cependant, tu omets de préciser que tu as considéré plein de constantes sur lesquelles tu n'as pas réussi à y coller ce pattern, ce qui n'est pourtant pas négligeable pour la crédibilité de ton étude.

Si tu veux mon programme python, n'hésite pas à me le demander.
Je veux bien me donner la peine de le mettre en forme et de décrire précisément les expériences que j'ai effectués. (Si on me laisse du temps)

++

#98 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Pile ou face? » 04-05-2009 12:58:51

PS : ah je m'en veux, j'ai passé 2h à faire des calculs compliqués alors que ce phénomène se comprend finalement très bien à la main ... Bon, au moins je suis sûr de ne pas m'être trompé.

Voici la méthode à la main qui marche si bien :
* PF et FP sont symétriques donc autant de chances de gagner de part et d'autre (ça je l'avais quand même remarqué)
     => Équitable
* PF vs PP : tant que des F sont tirés, personne ne gagne, mais dès qu'un P est tiré, l'issue du lancé suivant détermine le gagnant : une chance sur deux que ce soit F (donc moi qui gagne) et une chance sur deux que ce soit P (et donc l'adversaire gagne).
     => Équitable
* PF vs FF : Il y a 4 cas pour les deux premiers tirages :
    - FF -> l'adversaire gagne immédiatement
    - PF -> je gagne immédiatement
    - FP ou PP -> tant que des P sortent, personne ne gagne, mais dès que F apparaît, je gagne tout de suite.
   => 3 chances sur 4 de gagner

#99 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Pile ou face? » 04-05-2009 12:30:18

Salut,
Tout dépend si je connais le pari de l'autre. Si je le connais, et si mon adversaire parie :
* FF, je parie PF => j'ai alors 3 chances sur 4 de gagner
* PP, je parie FP => idem
* FP, je paries PF => j'ai une chance sur deux.
* PF, je paries FP => idem
Autrement dit, je parie toujours deux cotés différents, avec comme premier choix, celui opposé au sien.

Si je ne connais pas son pari, je parie FP (resp PF). S'il parie PF ou FF (resp FP ou PP), c'est équitable. S'il parie PP (resp FF) j'ai trois chance sur quatre de gagner.

Voila, sauf erreur de calcul de ma part.
++

Pied de page des forums