Poster un nouveau sujet Poster une réponse Page: 1,      >>
mouvement aléatoire de puce
Auteur Message
monsalbert
Invité
Posté le : Mar 23 Juil 2013, 18:18   Citer 

bonsoir Linka (ou tout autre bienfaiteur )

On étudie le mouvement aléatoire d'une puce qui se déplace sur 3 cases A,B,C. A t=0 la puce est en A.

- Si la puce est en A à l'instant n ,à n+1 elle est
soit en B avec une proba. de 1/3
soit en C avec une proba de 2/3

- Si elle est B à n, à n+1 elle sera
soit en C soit en A avec une proba. de 1/2

- si elle est en C, elle y reste.

Ecrire un algorithme effectuant 10.000 simulations des 3 premiers déplacements...

Je laisse de coté les 10.000 simulations ( pour plus tard avec un FOR). On se concentre sur une é&preuve à 3 déplacements.

un essais du 1er étage (1:A; 2:B; 3: C et J la position à n ):

For(I, 1,3)
1 sto J
3 -> dim(L1 pour voir les choses, on mettra les J.

If EntAleat (1,3) =2
2 -> J (en B ) compte tenu que p(C)= 2/3
Else
3 -> J (en C) à cause de p(c)= 2/3

Aprés c'est le brouillard à cause des SI (ceux qu'on doit fermer et ceux qu'on peut laisser ouverts ), je m'y perd. ou faire des choix tactique différents ?

  Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Mar 23 Juil 2013, 20:52   Citer 


Citer : monsalbert

bonsoir Linka (ou tout autre bienfaiteur )


Bouhouhou c'est toujours Linka cry.gif
nan je plaisante winkle.gif



Pour revenir à ton problème:
Il faut bien structurer les choses, alors je vais y aller étapes par étapes.
Déjà, les variables: je garde comme tu as choisis J la position de la puce, mais par contre je vais prendre 0:A; 1:B; 2:C au lieu de 1:A; 2:B; 3:C, ça permettra plus d'optimisations ^^
L1 permet de sauvegarder les positions

Code
//On initialise:
DelVar J3->dim(L1
For(I,1,3
Rand //Pour l'aléatoire
End


Maintenant quand on est dans la boucle, on a 3 cas à gérer: on est au point A (auquel cas on va soit en B soit en C), en B ou en C (on fait rien).

Code
//On initialise:
DelVar J3->dim(L1
For(I,1,3
Rand //Je ne suis plus sur de la fonction anglaise sur une française c'est NbrAléat
If non(J
Then
J+1+(Ans>=1/3->J //On incrémente de 1 (on va en B) si Le nombre aléatoire tiré est inférieur à 1/3 (1/3 de chances), et de 2 sinon (en C)
Else //permet d'éviter que si on vient d'aller en B on refasse direct une action
If J=1
J+(Ans>=.5)-(Ans<.5->J //On incrémente de 1 (on va en B) si Le nombre aléatoire tiré est supérieur à .5 (50% de chances), et de -1 sinon (en A)
End
//Si on est à J=2 on ne fait rien
//Maintenant on sauve la position
J->L1(I
End
L1 //On affiche le résultat



Bon je n'ai pas le temps de tester tout de suite mais ça devrait marcher winkle.gif
Je te laisse faire pour les 10.000 de tirages, n'hésites pas à demander si tu n'y arrives pas ^^

EDIT: ça a l'air de marcher happy.gif

----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Mar 23 Juil 2013, 22:22   Citer 

Oulala tu optimises trop vite je trouve... Tu places une incrémentation conditionnelle pour changer d'état, et puisque cela dépend du choix des cas cela me dérange dans la façon de faire.
Cela n'empêche pas la validité.

EDIT: je voulais dire que les calculs dépendent directement des valeurs de J asociées aux points A,B,C. Si on change ça, on doit reprendre tout le raisonnement depuis le début.
Et ainsi j'aurais préféré voir un programme moins optimisé puis celui de m@thieu41 pour bien comprendre le raisonnement


L'aléatoire réel équiprobable entre 0 et 1 c'est NbrAléat/rand.
L'aléatoire entier équiprobable entre A et B, c'est soit randInt(A,B), soit A+int((B-A+1)rand)
avec int traduit par partEnt (mais pas ent) et randInt par entAléat.

Remarque : si vous bidouillez mon expression A+int((B-A)rand), méfiez vous de ne pas écrire NbrAléat(B-A) mais bien NbrAléat*(B-A) car sur ti82stat cela génère une liste de B-A termes aléatoires.

EDIT : remplacez "déséquilibré" par "pondéré" dans toutes mes phrases.

L'aléatoire entier pondéré se fait facilement en générant un entier aléatoire équiprobable à un certain nombre de possibilités, ce nombre est le total des numérateurs de probas mis au même dénominateur.
Lorsqu'on veut 1/3 vs 2/3, il suffit de générer entre 0 et 2 car cela représente 3=1+2 états puis de tester une des trois valeurs pour l'évènement de probabilité 1/3, les deux autres valeurs pour celui de proba 2/3.

Si on ne le fait pas avec des entiers, il faut effectuer des tests d'inégalité comme m@thieu41 qui teste par exemple Ans>=1/3 pour les valeurs entre 1/3 et 1, ce qui correspond à la probabilité 2/3 puisque 1-1/3=2/3.

De base on pourrait générer de 1 à N, mais utiliser 0 à N-1 permettra de simplifier les tests, comme m@thieu41 a déjà fait.

Pour réaliser les cas, il faut :
-soit sauvegarder l'état précédent pour que les tests ne s'influencent pas
-soit imbriquer correctement des alternatives
-soit condenser les tests et les actions dans une seule commande

Pour ne pas s'embrouiller il ne faut pas hésiter à écrire des commentaires et des indentations.


Code
1->J  // j'ai supposé points {A,B,C}={1,2,3} mais on pourra le changer
For(A,1,3
  J->K
  If K=1    // point A
  Then
    entAléat(0,2->P   // 3 possibilités
    If non(P      // une possibilité sur 3 ,  proba 1/3  // point B
      2->J
    If P  // P non nul , 2 possibilités sur 3 , proba 2/3  // point C
      3->J
  End
  If K=2
  Then
    entAléat(0,1->P
    If non(P
      1->J
    If P
      3->J
  End

//If K=3  // on ne l'écrit pas puisqu'il n'y a pas de changement de J à faire
//Then
////////////   point C
//End


////  EDIT : ajouté le 24 juillet
// If J=1:Disp "A
// If J=2:Disp "B
// If J=3:Disp "C
////

End

Maintenant je passe à l'imbrication.
Code
1->J
For(A,1,3
  If J=1    // point A
  Then
    entAléat(0,2->P   // 3 possibilités
    If non(P      // une possibilité sur 3 ,  proba 1/3  // point B
      2->J
    If P  // P non nul , 2 possibilités sur 3 , proba 2/3  // point C
      3->J
  Else       // pas le point A
    If J=2   // le point B
    Then
      entAléat(0,1->P
      If non(P
        1->J
      If P
        3->J

//  Else  // pas le point B ni le point A, donc le point C
//////////  on n'écrit pas puisqu'on ne fait rien

    End
  End
End
      // EDIT : j'avais un End en trop

Maintenant je vais optimiser beaucoup plus afin de rassembler les actions. (je met des conditions dans les calculs)
Etape 1 : j'effectue des sommes pour les changements

Code
1->J
For(A,1,3
  If J=1
  Then
    entAléat(0,2->P
    2+(P>0->J           // 2+0=2 ou bien 2+1=3 , le 2 est en fait J+1
  Else
    If J=2
    Then
      entAléat(0,1->P
      3-2non(P->J      // 3-2*1=1 ou bien 3-2*0=3 , le 3 est en fait J+1
    End
  End
End
      // EDIT : j'avais un End en trop

Etape 2 : je rassemble les actions et j'associe A,B,C à 1,2,0
EDIT : ce programme est faux, j'ai oublié de réécrire les valeurs de variation, c'est ce que m@thieu41 corrige juste après

Code
1->J
For(A,1,3
  entAléat(0,3-J   // 3-J donne les bornes suppérieures 2 et 1 pour J = 1 et 2
  If J  // pas le point C
    J+1+(J=1)(Rép>0)-(J=2)2non(Rép->J
End
      // EDIT : j'avais un End en trop



Je pourrais peut-être faire mieux, je n'ai pas regardé correctement celui de m@thieu41, il a peut-être fait mieux.
(je me perd dans les commentaires, c'est pour ça que je le fais en plusieurs étapes)

##### EDIT : ma propre correction :
Reprenons mon code "Etape 1" et changeons les valeurs
Code
1->J  // A,B,C = 1,2,0
For(A,1,3
  If J=1
  Then
    entAléat(0,2->P
    2-2non(P->J       // 2-2*0=2 si P=0 (1/3) ou bien 2-2*1=0 si P=1ou2 (2/3)
  Else
    If J=2
    Then
      entAléat(0,1->P
      P->J      // 0 ou bien 1, à autant de proba
    End
  End
End

Maintenant on rassemble tout comme je voulais déjà faire
Code
1->J  // A,B,C = 1,2,0
For(A,1,3
  entAléat(0,3-J
  If J
    Rép(J=2)+(J=1)(2-2non(Rép->J
          // je fait la somme pondérée des calculs par les conditions de J
End

Voilà tout pour la méthode complète. Vous pouvez bien sûr faire mieux en cherchant des astuces de calcul telles que m@thieu41 a fait dans le message du Mer 24 Juil 2013, 12:12

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Mar 23 Juil 2013, 22:52   Citer 

Je n'ai pas fait mieux (j'en étais plus ou moins entre ta première étape d'optimisation et la seconde crazy.gif )
Par contre à la fin tu as gardé un End en trop (à partir du deuxième code en fait)

Et aussi:
Citer : Linkakro
Tu places une incrémentation conditionnelle pour changer d'état, et puisque cela dépend du choix des cas cela me dérange dans la façon de faire.


Heu... je ne comprends pas ce que tu dis ^^ (enfin l'incrémentation conditionnelle je vois mais qu'est ce que tu entends quand tu dis que ça dépend du choix des cas ?

En fait non ton code ne marche apparemment pas (tu as oublié de changer certains calculs quand tu es passé de C=3 à C=0

Code
1->J
For(A,1,3
entAléat(0,3-J
If J
J+1+(J=1)(Rép>0)-(J=2)2non(Rép->J //Si J=1 1+1+1=3 ou 1+1+0=2 si J=2 2+1+0-0=3 ou 2+1+0-2=1
End


Il fallait pouvoir arriver à 0:

Code
1->J
For(A,1,3
entAléat(0,3-J
If J
J-1+2(J=1)non(Rép)-(J=2)non(Rép->J //Si J=1 1-1+2-0=2 ou 1-1+0-0=0 si J=2 2-1+0-1=0 ou 2-1+0-0=1
End



----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Mer 24 Juil 2013, 1:18   Citer 

Ce que je voulais dire en parlant de choix des cas est justement ce qui a causé mon oubli et erreur dans ce que tu as signalé : les valeurs des états sont différents, donc il faut réécrire les calculs contenant les conditions.
J'ai changé la structure et les valeurs d'une seule traite quand j'aurais dû commencer par changer toutes les valeurs.

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
monsalbert
Invité
Posté le : Mer 24 Juil 2013, 9:26   Citer 

merci à tousles deux,mais doucement!..

Premièrement:

Ai-je bien compris ?
- personnellement j'avais l'intention , après avoir fait l'arbre ( 1 pour A, 2 pour B,3 pour C) pondéré de suivre pas à pas..d'ou beaucoup de SI..Dans ce cas EntAleat (1, 3) faisait le tri des positions

Mathieu tu as changé de tactique? tu tri à partir des probabilités qui sont connues.Est-ce celà ?
J'ai du mal à comprendre le code car Je ne connais pas ANS ( comment marche cette instuction ) Je ne l'ai pas. (dans catalogue). A t-elle un remplacement dans TI 82 Stat.fr?

Je bosse vos commentaires mais je peux avoir du mal avec certaines de vos formulations Ne craigniez pas d'expliquer

  Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Mer 24 Juil 2013, 12:12   Citer 

En fait je n'ai pas changé de tactique, j'ai juste corrigé le prgm de Linka

Ans (Rép en français) est une variable un peu spéciale: elle contient le résultat de la dernière opération calculée, hors argument de fonction.
Ex:
Code
1->A //A et Rép contiennent 1

34+A //Rép contient A+34=35

2Rép //Rép contient 2*35=70

Disp 4+Rép //Affiche 74 mais ne modifie pas Rép

-Rép //Rép = -70

asb(Rép //Rép = 70

"BONJOUR->Chaine0 //Rép=Chaine0="BONJOUR

Rép+" TOUT LE MONDE //Rép = "BONJOUR TOUT LE MONDE

NbAléat //Rép contient un nb compris entre 0 et 1



Je vais reprendre la logique de puis le début:

On considère les 3 point A=1 B=2 C=0.
On sait qu'au début on est sur A, on a donc J (notre position) = 1.
On a 3 déplacements, il faut donc faire une boucle de 3 tours.
A chaque tours, il y a 3 possibilités: on est en C (on ne fait rien), on est en A (on va en C ou en B avec respectivement 2/3 et 1/3 de proba), ou on est en B (auquel cas on va soit en A (50% de chances), ou en C (idem))
Il faut aussi penser à sauvegarder les positions de chaque tour (on fixe donc la taille de L1 à 3).

On sait donc tout ce qu'il faut faire, on va maintenant le coder.

Code
1->J //On est en A au début
3->dim(L1 //Pour les positions
For(I,1,3 //Une boucle de 3 tours
  If J=1
  Then //On est en A

   EntAléat(0,2->P //On tire un nombre aléatoire entre 0 et 2
   If P //Si P vaut 1 ou 2 on va en C
    0->J
   If non(P //Si P vaut 0 on va en B
    2->J

  Else

  If J=2
  Then //On est en B

   EntAléat(0,1->P //On tire un nombre aléatoire entre 0 et 1
   If P //Si P vaut 1 en C
    0->J
   If non(P //Si P vaut 0 on va en A
    1->J

  End

  End  //Si J = 3 (point C) on ne fait rien
J->L1(I //On sauve la position
End //Fin de la boucle, on recommence 3 fois pour 3 déplacements
L1 //On affiche les positions



Maintenant on va tenter de faire des optimisations (j'enlève les anciens commentaires pour plus de lisibilités)


Code
1->J
3->dim(L1
For(I,1,3
  //On peut remarquer (comme l'a fait Linka) qu'on doit tirer un nombre aléatoire entre 0 et 2 quand on est en 1, et entre 0 et 1 quand on est en 2 soit entre 0 et 3-J (quand J=1 3-1=2 J=2 3-2=1 donc ça marche)
  EntAléat(0,3-J->P
  If J=1
  Then //On est en A

   If P
    0->J
   If non(P
    2->J

  Else

  If J=2
  Then //On est en B

   If P
    0->J
   If non(P
    1->J

  End

  End
J->L1(I
End
L1



Maintenant plutot que mettre des If P ou If non(P) on va mettre des calculs en utilisant les booléens (je ne sais pas si tu connais si tu ne connais pas demande nous)


Code
1->J
3->dim(L1
For(I,1,3
  EntAléat(0,3-J->P

  If J=1
  Then //On est en A
   0+2non(P->J //Explication: si P=1 ou 2 J=0+2*0=0 si P=0 J=0+2*1=2

  Else

  If J=2 //On est en B
   0+non(P->J //Si P=0 J=0+1=1 si P=1 J=0+0=0

  End
J->L1(I
End
L1



Pour plus d'optimisations (on peut réunir les 2 calculs en un seul) voit les messages précédents là j'ai pas le temps je le fait ce soir si tu veux ^^
Si tu n'as pas compris quelque chose n'hésites pas à le demander

EDIT: Pas testé mais ça devrait marcher:

Code
1->J
3->dim(L1
For(I,1,3
  If J  //Si on est pas sur C
   0+(3-J)(non(EntAléat(0,3-J->J
  J->L1(I
End
L1


//On pourrait même utiliser Rép au lieu de J du coup:

Code
3->dim(L1
1
For(I,1,3
  If Rép  //Si on est pas sur C
   0+(3-Rép)(non(EntAléat(0,3-Rép
  Rép->L1(I
End
L1



----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Mer 24 Juil 2013, 13:41   Citer 

Là ça commence à m'impressionner, en fait j'ai mieux compris les expressions booléennes puisqu'on a déjà posté les version non-optimisées.

---
monsalbert :

Citer : "monsalbert"
- personnellement j'avais l'intention , après avoir fait l'arbre ( 1 pour A, 2 pour B,3 pour C) pondéré de suivre pas à pas..d'ou beaucoup de SI..Dans ce cas EntAleat(1,3) faisait le tri des positions

Nous avons justement créé des pondérations avec nos aléatoires.
Nous n'avons pas décomposé l'étude en un arbre et une simulation brute. Nous avons tout simuler brut.
On reparlera peut-être de ce que tu voulais.

Pour consulter chaque état, m@thieu41 a maintenant proposé d'utiliser une liste. On pouvait aussi simplement afficher le nom du point à la fin de la boucle. Par exemple If J=1:Disp A

entAléat(1,3) a autant de chances de répondre 1,2 ou 3. Il est équiprobable.
Or on veut des probabilités pondérées : 1/3 et 2/3.
Donc on doit se débrouiller pour contrôler les probabilités.

** je génère un entier à trois possibilités et j'en teste une pour l'évènement à probabilité 1/3, et les deux autres pour la probabilité 2/3.

** m@thieu41 au tout début : génère un décimal entre 0 et 1 et teste des intervalles aussi larges que les probabilités étudiées, donc de 0 à 1/3 c'est le premier évènement, et de 1/3 à 1 (large de 2/3) c'est le second évènement

---
Pour t'expliquer les calculs conditionnels et les booléens :
http://tout82.free.fr/forum/sujet.php?sujet=2741
La calculatrice génère 0 ou 1 pour faux et vrai quand on effectue un test.
Ainsi quand on place une condition entre parenthèses, cela génère 0 ou 1 qu'on utilise en produit pour contrôler le résultat d'un calcul. Par exemple "J+(A=1)-3*(A=2)->J" reviendrait à incrémenter si A=1, décrémenter de 3 si A=2, ne rien faire sinon. Bien sûr on peut effectuer des produits de plusieurs conditions ou écrire des conditions complexes comme (A=1 et B>3).
Quand on lui donne autre chose pour des fonctions de test telles que If ou "et" c'est comme lui donner vrai.
Ainsi "If not(A)" et "If A" suffisent à tester la valeur nulle ou pas. On peut aussi écrire "A ou B" qui revient à écrire que l'un des deux doit être non-nul.

EDIT: j'ai corrigé ma confusion entre A et J, voir prochain message de m@thieu41.

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
monsalbert
Invité
Posté le : Mer 24 Juil 2013, 16:55   Citer 

- je revois toutes vos remarques.

Pour l'instant des essais sur le 1er code de hier de linka surprennent ?

Ayant mis après entAléat(0,2->P Disp p
après le End (de K=1) Disp J

après le entAléat(0,1->P Disp p
après le End (de K=2) Disp J pour voir le détail, la surprise fut grande de voir la TI afficher 7 ou 8 résultats !

Donne t-elle les 2 Si-Si? et le FOR ? on attendrait 4 chiffres?

  Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Mer 24 Juil 2013, 18:14   Citer 

Le For simule successivement les trois déplacements de la puce. Chaque valeur de A représente une étape.

Les probabilités des évènements ne sont pas les mêmes selon le point auquel on se trouve. Donc chaque If:Then:End permet de contrôler une des deux expériences.

Tu places le code ci-dessous à la fin de la boucle For juste avant son End.
C'est la seule chose dont tu ais besoin pour observer le comportement de la puce à chacune des trois étape.
Code
If J=1:Disp "A
If J=2:Disp "B
If J=3:Disp "C



Tu te demandes peut-être pourquoi j'ai exigé d'utiliser soit K soit les imbrications soit les booléens.
C'est parce que si tu es au point A et que tu passes au point B avec le premier test, alors il faut empêcher le second test de s'effectuer durant la même boucle.
K permet de connaître l'état précédent pour éviter la confusion.
L'imbrication empêche simplement les tests suivants de s'effectuer.
Les booléens permettent de rassembler en une seule commande toutes les instructions, ainsi la valeur de J ne peut pas changer entre les opérations.

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Mer 24 Juil 2013, 20:29   Citer 

@Linka: Tu as mélangé A et J à un moment dans tes explications je comprenais plus ^^ : "J+(A=1)-3*(A=2)->J" reviendrait à incrémenter si J=1, décrémenter de 3 si J=2, ne rien faire sinon.

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


Citer : monsalbert

Ayant mis après entAléat(0,2->P Disp p
après le End (de K=1) Disp J

après le entAléat(0,1->P Disp p
après le End (de K=2) Disp J pour voir le détail, la surprise fut grande de voir la TI afficher 7 ou 8 résultats !

Donne t-elle les 2 Si-Si? et le FOR ? on attendrait 4 chiffres?


Je ne suis pas sur que tu ais compris le fonctionnement de la condition If...
Si j'ai bien compris tu as fait un truc du style (j'allège le code):

Code
For(I,1,3

 If K=1
 Then
  entAléat(0,2->P
  Disp P
 End

 Disp J

 if K=2
 Then
  entAléat(0,1->P
  Disp P
 End

 Disp J

End


C'est bien ça?
Dans ce cas il est logique que tu ais eut plus de 3 résultats: Tes 2 "Disp J" sont en dehors de la condition If, et seront donc éxécutés à chaque tour! Il y aura également un Disp P qui sera exécuté si K=1ou2...

Au cas où je te poste une explication de l'instruction If:
Il y a 3 cas possibles pour cette instruction

1 cas:

Code
If condition
//instruction a executer sur une seule ligne si la condition est verifiee



2 cas:

Code
If condition
Then
//instructions a executer
//sur plisieures lignes si la condition est verifiee
End



3 cas:

Code
If condition
Then
//instructions a executer si la condition est verifiee
Else
//instructions si elle n est pas vraie
End



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

Petite remarque:
Au lieu de

Code
If J=1:Disp "A
If J=2:Disp "B
If J=3:Disp "C


on pourrait faire (dans le cas où A=1, B=2, C=3):

Code
"ABC->Chaine1 //Avec les initialisations de départ

Disp sous-chaine(chaine1,J,1 //A la fin de la boucle for avant son End


Et, dans le cas où C=0, A=1, B=2

Code
"CAB->Chaine1 //Avec les initialisations de départ

Disp sous-chaine(chaine1,J+1,1 //A la fin de la boucle for avant son End (Si tu prend mon dernier code où J est supprimé remplace J par Rép)



----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
monsalbert
Invité
Posté le : Jeu 25 Juil 2013, 16:00   Citer 

Mathieu, linka n'allez pas plus avant.Laissez moi vous rejoindre progressivement.
( je pratique dans l'ordre ).Pour le gros-oeuvre je pense avoir compris où vous vouliez m'amener en 3 étapes. je pense avoir compris l'essentiel de ces étapes. C'est super. Celà me plait beaucoup.

Pour Mathieu: Impeccable ton explication du Hans (Rep). Merci .

Pour ta question "Citer : monsalbert"..

Clair: je n'ai absolument pas touché le code de linka. J'ai simplement intercalé, en espion, les Disp pour voir ou p ou j dans chaque cas.C'est pourquoi je pensais lire 4 chiffres ou 6 peut-être.

Pour tout les 2:

J'ai apporté la modif.au code 1 de linka
If J=1:Disp "A
If J=2:Disp "B
If J=3:Disp "C Pas de problème, donc la chose est dite.

questions

1- le code fait 3 boucles.Il garde en mémoire les valeurs de J ?.. au moins les 2 premières qui sont carrément inscrites par le programme? la dernière il la déduit de l'étape précédente. C"est bien celà ?

2-les end: un pour fin K=1 // un pour fin K=2 // un pour fin K=3 et le dernier fin du For. Il y en aurait un en trop( dont parle Mathieu. C'est celà ?

3- pour essais sur ce programme on peut mettre le FOR(X,1,1000(ou autre)
On le mettra avant le 1->J.
Pour les calculs de probabilité il faudra calculer le nombre de B (ou C ). On mettra le compteur après le end de K=3 ou aprés les 3 Disp. D'accord?

J'espère avoir été clair.

  Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Jeu 25 Juil 2013, 17:47   Citer 

1_ Je ne suis pas sur de comment tu vois les choses en fait... On va prendre un des prgm qui ont été proposés parmis les moins optimisés, pour que ce soit plus simple:

Code
1->J //On est en A au début
3->dim(L1 //Pour les positions
For(I,1,3 //Une boucle de 3 tours
  If J=1
  Then //On est en A

   EntAléat(0,2->P //On tire un nombre aléatoire entre 0 et 2
   If P //Si P vaut 1 ou 2 on va en C
    0->J
   If non(P //Si P vaut 0 on va en B
    2->J

  Else

  If J=2
  Then //On est en B

   EntAléat(0,1->P //On tire un nombre aléatoire entre 0 et 1
   If P //Si P vaut 1 en C
    0->J
   If non(P //Si P vaut 0 on va en A
    1->J

  End

  End  //Si J = 3 (point C) on ne fait rien
J->L1(I //On sauve la position
End //Fin de la boucle, on recommence 3 fois pour 3 déplacements
L1 //On affiche les positions


Quand tu dis: "Il garde en mémoire les valeurs de J ?", je ne comprends pas ta question: la valeur que contient J ne changera jamais d'elle même, la seule chose qui puisse faire changer sa valeur c'est de faire une affectation (nombre ou opération ->J).

Donc dans le code ce qu'il se passe, c'est:
_Au début on initialise la position à 1 (A);
_Ensuite, dans la boucle:
.On teste la position J;
.On effectue un déplacement aléatoire si on est pas sur C (0). Le résultat de ce déplacement est stocké dans J, donc au prochain tour de boucle on testera la nouvelle position (voire instruction précédente);
.On sauvegarde/affiche la position (enfin ça je ne sais pas trop quels résultats tu voudra obtenir sur 1000 essais)
.Et on retourne 2 fois au début de la boucle, avec J une nouvelle position, de manière à effectuer 3 déplacements.

2_ Oui c'est ça, Linka a corrigé dans son message.

3_ Pour les 1000 essais quel est le résultat qui t'intéresse? Combien de fois on a finit sur C? sur A? sur B? combien de fois on est tombé sur chaque point?

Sinon oui il faut bien englober le code avec un For(variable que tu veux tant qu'elle est pas utilisée autre part dans le code,1,1000
Tu places le For au début (juste avant le 1->J comme tu l'as dit), sans oublier bien sur un End à la fin, et pour les probabilités bah je sais pas la proba de quoi tu veux ^^

----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Ven 26 Juil 2013, 1:59   Citer 


Citer
1- le code fait 3 boucles.Il garde en mémoire les valeurs de J ?.. au moins les 2 premières qui sont carrément inscrites par le programme? la dernière il la déduit de l'étape précédente. C"est bien celà ?

2-les end: un pour fin K=1 // un pour fin K=2 // un pour fin K=3 et le dernier fin du For. Il y en aurait un en trop( dont parle Mathieu. C'est celà ?

3- pour essais sur ce programme on peut mettre le FOR(X,1,1000(ou autre)
On le mettra avant le 1->J.
Pour les calculs de probabilité il faudra calculer le nombre de B (ou C ). On mettra le compteur après le end de K=3 ou aprés les 3 Disp. D'accord?


1_ Moi aussi j'ai du mal à savoir comment tu vois les choses.

Le contenu de la boucle For représente un déplacement. Le calcul de ce déplacement est lui-même composé des alternatives en If (ou calculs plus compliqués après optimisation). Ce calcul de déplacement est effectué à chaque fois que la boucle est executée, et à chaque fois il modifie la variable J qui sera réutilisée la prochaine fois. Ainsi chaque execution de boucle calcule un déplacement.
Vois simplement ça comme For(A,1,3):calcul(J)->J:End

2_ Il y avait eu des End en trop dans la plupart de mes codes car j'avais effectué des copier-coller. Maintenant j'ai corrigé et laissé des commentaires pour aider à comprendre l'histoire du sujet.

3_ Exact. Je propose ce code à partir de mon deuxième code de ce sujet, celui imbriqué mais pas optimisé.


Code
{0,0,0}->L1    // chaque case comptera les occurrences d'un des évènements

For(X,1,10000  // contrôle de chaque expérience

1->J           // point A
For(A,1,3      // une expérience de trois déplacements successifs

If J=1         // début du calcul de déplacement
Then
entAléat(0,2->P
If non(P
2->J
If P
3->J
Else
If J=2
Then
entAléat(0,1->P
If non(P
1->J
If P
3->J
End
End            // fin du calcul de déplacement

End            // for(a

1+L1(J->L1(J
     // compte de l'évènement "la puce se trouve au point J après l'expérience"

End            // for(x

Disp L1/10000  // probabilités = occurrences/total



======================
======================
======================

Maintenant je m'amuse à calculer théoriquement, comme dans le sujet de la pyramide de la fourmi. (cette fois j'écris vraiment des probabilités, pas des énumérations de branches de l'arbre)

p(A,0)=1
p(B,0)=0
p(C,0)=0
p(A,n)(A,n+1)=0
p(A,n)(B,n+1)=1/3
p(A,n)(C,n+1)=2/3
p(B,n)(A,n+1)=1/2
p(B,n)(B,n+1)=0
p(B,n)(C,n+1)=1/2
p(C,n)(A,n+1)=0
p(C,n)(B,n+1)=0
p(C,n)(C,n+1)=1

p(A,n+1)=p(A,n)*p(A,n)(A,n+1)+p(B,n)*p(B,n)(A,n+1)+p(C,n)*p(C,n)(A,n+1)
= 0+ p(B,n)*p(B,n)(A,n+1) +0
=p(B,n)*1/2

p(B,n+1)=p(A,n)*p(A,n)(B,n+1)+p(B,n)*p(B,n)(B,n+1)+p(C,n)*p(C,n)(B,n+1)
=p(A,n)*p(A,n)(B,n+1) +0 +0
=p(A,n)*1/3

p(C,n+1)=p(A,n)*p(A,n)(C,n+1)+p(B,n)*p(C,n)(B,n+1)+p(C,n)*p(C,n)(C,n+1)
=p(A,n)*2/3+p(B,n)*1/2+p(C,n)

p(A,3)=p(B,2)*1/2=p(A,1)*1/3*1/2=p(B,0)*1/2*1/3*1/2
=0

p(B,3)=p(A,2)*1/3=p(B,1)*1/2*1/3=p(A,0)*1/3*1/2*1/3
=1/18

p(C,3)=p(A,2)*2/3 +p(B,2)*1/2 +p(C,2)
=p(B,1)*1/2*2/3 +p(A,1)*1/3*1/2 +p(A,1)*2/3 +p(B,1)*1/2 +p(C,1)
=p(A,0)*1/3*1/2*2/3 +p(B,0)*1/2*1/3*1/2 +p(B,0)*1/2*2/3 +p(A,0)*1/3*1/2 +p(A,0)*2/3 +p(B,0)*1/2 +p(C,0)
=1/9 +0 +0 +1/6 +2/3 +0 +0
=17/18

J'aurais dû calculer les probabilités une par une depuis n=1 jusqu'à n=3 plutôt que commencer à n=3.

##### Maintenant la théorie pour n'importe quel nombre de déplacement.

J'épargne à tout le monde un raisonnement par récurrence.
p(A,n) vaut soit 0 quand n est impair soit 1/6^(n/2) quand n est pair.
Idem pour p(B,n), 0 quand n est pair, 1/3*1/6^((n-1)/2)=2*1/6^((n+1)/2) quand n impair

===
p(C,n)= somme(k,1,n, p(A,k-1)*2/3+p(B,k-1)*1/2 )
p(C,n)= somme(k,0,n-1, p(A,k)*2/3+p(B,k)*1/2 )
p(C,n)= 2/3*somme(k,0,n-1, p(A,k) ) + 1/2*somme(k,0,n-1, p(B,k) )

Je vais distinger les alternances paires et impaires qui causent des termes nuls que je peux éliminer en changeant les bornes des sommes et les indices.
Puis j'utiliserais la somme géométrique somme(k,0,n,aq^k)=a*(1-q^(n+1))/(1-q)

***si n est impair,
p(C,n)= 2/3*somme(k,0,n-1, p(A,k) ) + 1/2*somme(k,0,n-2, p(B,k) )
p(C,n)= 2/3*somme(f,0,(n-1)/2, p(A,2f) ) + 1/2*somme(f,0,(n-3)/2, p(B,2f+1) )
p(C,n)= 2/3*somme(f,0,(n-1)/2, 1/6^f ) + 1/2*somme(f,0,(n-3)/2, 1/3*1/6^f )

p(C,n)= 2/3*(1-1/6^((n-1)/2+1))/(1-1/6) + 1/2*1/3*(1-1/6^((n-3)/2+1))/(1-1/6)
p(C,n)= 2/3*(1-1/6^((n+1)/2))/(1-1/6) + 1/2*1/3*(1-1/6^((n-1)/2))/(1-1/6)
p(C,n) =2/3*6/5*(1-1/6^((n+1)/2)) + 1/2*1/3*6/5*(1-1/6^((n-1)/2))

p(C,n)= 4*6/5*(1/6-1/6^((n+3)/2)) + 6/5*(1/6-1/6^((n+1)/2))
p(C,n)= 4*6/5*(1/6-1/rac(6)^(n+3)) + 6/5*(1/6-1/rac(6)^(n+1))

p(C,n)= 4/5*(1-1/rac(6)^(n+1)) + 1/5*(1-1/rac(6)^(n-1))

Je veux factoriser, alors je décompose la première somme en isolant son dernier terme et je répète le résultat de ce que j'ai déjà fait en changeant l'indice.
p(C,n)= 2/3*somme(f,0,(n-1)/2, 1/6^f ) + 1/2*somme(f,0,(n-3)/2, 1/3*1/6^f )
p(C,n)= 2/3*somme(f,0,(n-3)/2, 1/6^f ) + 1/2*somme(f,0,(n-3)/2, 1/3*1/6^f ) + 1/6^((n-1)/2)
p(C,n)= 4/5*(1-1/rac(6)^(n-1)) + 1/5*(1-1/rac(6)^(n-1)) + 1/6^((n-1)/2)
p(C,n)= (1-1/rac(6)^(n-1)) + 1/6^((n-1)/2)

***si n est pair,
p(C,n)= 2/3*somme(k,0,n-2, p(A,k) ) + 1/2*somme(k,0,n-1, p(B,k) )
p(C,n)= 2/3*somme(f,0,(n-2)/2, p(A,2f) ) + 1/2*somme(f,0,(n-2)/2, p(B,2f+1) )
p(C,n)= 2/3*somme(f,0,(n-2)/2, 1/6^f ) + 1/2*somme(f,0,(n-2)/2, 1/3*1/6^f )
p(C,n)= 2/3*(1-1/6^((n-2)/2)+1)/(1-1/6) + 1/2*1/3*(1-1/6^((n-2)/2)+1)/(1-1/6)
p(C,n)= 2/3*(1-1/6^(n/2))/(1-1/6) + 1/2*1/3*(1-1/6^(n/2))/(1-1/6)
p(C,n)= 2/3*6/5*(1-1/6^(n/2)) + 1/2*1/3*6/5*(1-1/6^(n/2))

p(C,n)= 4*6/5*(1/6-1/6^((n+2)/2)) + 6/5*(1/6-1/6^((n+2)/2))
p(C,n)= 4*6/5*(1/6-1/rac(6)^(n+2)) + 6/5*(1/6-1/rac(6)^(n+2))

p(C,n)= 4/5*(1-1/rac(6)^n) + 1/5*(1-1/rac(6)^n)
p(C,n)= (1-1/rac(6)^n)

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
Google_AdSense



Publicité    



 
monsalbert
Invité
Posté le : Ven 26 Juil 2013, 18:06   Citer 

bonjour à tous deux,

Je ne suis pas fier..

Votre question pose problème ai-je bien exprimé les choses?..Reprenons l'énoncé.

LA PUCE EST EN A ET VA FAIRE 3 PAS ( c'est pour celà que j'ai mis au départ For(I,1,3)! - voir mon 1 er message ). C'est celà que j'ai appelé une épreuve. (Cette épreuve sera ensuite reproduite N fois.) Donc j'attendais comme résultats après Disp , partant de A:

BCC ou BAB ou CCC..

Donc avec ce For (I,1,3) c'est 3 triplets en questions, un pour chaque parcours.

dans mon message de jeudi 25

après avoir apporté la modif. au code 1 de linka
If J=1:Disp "A
If J=2:Disp "B
If J=3:Disp "C" on obtenait bien un triplet ,à chaque lancé. Ce triplet serait celui du troisième parcours? c'est celà?

Après le premier message ,je ne me suis concentré que sur les codes ,oubliant l'énoncé.

Excusez moi tous deux de vous avoir entraîné sur une mauvaise piste.

Donc si on laisse en l'état , il suffit de remplacer le 3 de ce For par 1000 ou 2000..celà ne change rien dans les codes .

Bilan:

1- on veut le code d' UN parcourt ( Disp donnera un triplet type BAC ou CCC..)
2- on reproduira N parcours pour déterminer la fréquence de A, ou B ou C.

Encore, excusez moi de cette erreur. Merci.

  Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Ven 26 Juil 2013, 20:22   Citer 


Citer
Ce triplet serait celui du troisième parcours?

Le mot "parcours" signifie un ensemble de déplacements, pas chaque saut de la puce.
Ce qui est affiché est bien un triplet de points décrivant l'itinéraire de trois déplacements successifs en partant du point A.

---Pour connaître l'itinéraire :
Tu conserves un des programmes que m@thieu41 et moi avons posté, et celui que j'ai posté dernièrement.
Puis tu y ajoutes si besoin des commandes d'affichages pour connaître l'itinéraire.
Enfin tu remplaces mes 10000 par une variable N et un Prompt N au début.

La méthode est toujours la même : un intègre le programme de simulation d'une expérience à un autre programme qui simule un certain nombre de fois.
Tu peux adapter mon message précédent aux détails que tu demandes comme les N simulations.
Je fais un bilan en prenant le programme le plus optimisé de m@thieu41. (dernier de Mer 24 Juil 2013, 12:12)


Code
Prompt M
1
For(I,1,M
If Rép
(3-Rép)non(EntAléat(0,3-Rép
Disp sous-Chaîne("CAB",Rép+1,1                        //edit: le "+1" manquait
End


Code
Prompt N,M
EffEcr
{0,0,0->L1  // C,A,B

For(X,1,N       // N simulations de l'expérience

1
For(I,1,M       // expérience de M déplacements
If Rép
(3-Rép)non(EntAléat(0,3-Rép
Output(1,I,sous-Chaîne("CAB",Rép+1,1                   //edit: le "+1" manquait
End

1+L1(Rép+1->L1    // compte des résultats pour chaque point en fins d'expériences
Pause
EffEcr

End
Disp L1/N     // proba de chaque point en fin de chaque expérience (C,A,B)



----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Sam 27 Juil 2013, 10:40   Citer 

@Linka: On prend C=0 A=1 B=2 donc à la place de: Disp sous-Chaîne("CAB",Rép,1) il faut mettre Disp sous-Chaîne("CAB",Rép+1,1), sinon on a une erreur en C, et en A et B on affiche pas le bon point...

Je n'ai pas compris comme Linka ce qu'il faut faire...
J'ai compris que:
Ce qu'il y a toujours (un parcours): La puce commence en A et se déplace toujours de 3 cases.
Ce qui varie: Le nombre de parcours effectués.

Si c'est bien ça (on doit donc effectuer N parcours de 3 déplacements en revenant à chaque fois en A), et bien les codes qu'on t'avait donné (avec le For(A,1,3)), marchent... En effet, cette boucle For(A,1,3) permet de simuler les 3 déplacements d'un même parcours! Ainsi, les Disp sous-Chaîne("CAB",Rép+1,1) permettent d'afficher la position de la puce pendant un parcours (il y a 3 déplacement, donc 3 affichages par parcours).
le triplet que tu obtenais correspond donc non pas au 3e parcours, mais au 3 positions de l'unique parcours effectué.

Lorsqu'on met autour du code un For(X,1,N), c'est pour simuler N parcours (chaque parcours comprenant toujours 3 déplacements de puce).
Quand tu dis la fréquence de A/B/C c'est bien après les 3 déplacements comme l'a fait Linka?
Si oui, le code suivant te donnera la fréquence obtenue sur N parcours de 3 déplacements, avec un affichage à chaque fois des points où se situe la puce (j'ai repris le dernier code de Linka que j'ai un peu modifié en fait):

Code
Prompt N
{0,0,0->L1  // C,A,B

For(N,1,N       // N parcours

EffEcr
Disp N

1
For(I,1,3       // 3 déplacements pour un parcours
If Rép
(3-Rép)non(EntAléat(0,3-Rép
Disp sous-Chaîne("CAB",Rép+1,1
End

1+L1(Rép+1->L1    // compte des résultats pour chaque point en fins d'expériences

Pause

End
L1/N   //Affichage de la fréquence


Si tu ne veux pas afficher les différents points de chaque parcours, mais que tu veux juste les fréquences des points finaux (si tu fais pour 1000 parcours par ex, supprime les 2 disp (Disp sous-Chaîne("CAB",Rép+1,1) et Disp N), le EffEcr et le Pause

----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
linkakro



Autorisation : Membre
Nb de messages : 3767
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Sam 27 Juil 2013, 17:20   Citer 

OK.
Modifs facultatives mais efficaces.

Optimiser le For(N,1,N) n'est pas quelque chose de logique, il faudrait l'expliquer. http://tout82.free.fr/forum/sujet.php?sujet=2692 Les arguments sont calculés une seule fois au début, donc utiliser la même variable deux fois fonctionne.

----------------------
ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)

Pour tout le monde et surtout les débutants, quelques-uns des articles courants :
*Traductions Algorithmie/Ti-Basic.
*Caractères spéciaux sur Tout82
Les défauts du TI-Basic : Goto_versus_algo et DelVar/End/Lbl/guillemet/store
 Adresse email Haut de page Bas de page 
 
monsalbert
Invité
Posté le : Mer 31 Juil 2013, 19:44   Citer 

bonsoir linka mathieu,

Je ne poserai pas toutes les questions pour plus de clarté -j'espère!

petite précision pour mathieu sur l'énoncé du problème

- 1 épreuve: la puce DOIT faire 3 déplacements ( FOR à 3)
- but :pour déterminer p(A), p(B),p(C) ( probabilité de finir l'épreuve en A, B ou C par l'expérience) il faut reproduire un grand nombre de fois l'épreuve (For à X ) et donc enregistrer N(A), N(B),N(C).

Linka -code du 23 juillet

For(A,1,3
-J
If J
J-1+2(J=1)non(Rép)-(J=2)non(Rép->J

Le non(Rép concerne la sortie du For( A,1,3 ? comment interpréter le non(Rép) ?


Code du 24

" Par exemple "J+(A=1)-3*(A=2)->J" reviendrait à incrémenter si A=1, décrémenter de 3 si A=2, ne rien faire sinon. B "

QUI est le A ? combien vaut-il ?

Rq où trouve –t-on Rep sur la TI? ( je vais dans catalogue !



Mathieu code du 24

3->dim(L1
1
For(I,1,3

If Rép //Si on est pas sur C

0+(3-Rép)(non(EntAléat(0,3-Rép

Rép->L1(I
End
L1

- à quoi sert le 1 tout seul ? et le 0 sous le If ?

- peux-tu expliquer cette ligne " 0+(3-Rép)(non(EntAléat(0,3-Rép " ? sans STO à la fin ?

merci.

  Haut de page Bas de page 
 
m@thieu41



Autorisation : Membre
Nb de messages : 856
Inscrit le : Mer 18 Juil 2012, 18:44
Posté le : Mer 31 Juil 2013, 20:53   Citer 

J'avais bien compris l'énoncé alors ^^

J'ai du mal à comprendre comment tu comprends les choses...

1.
La sortie d'un For se fait toujours pas l'intermédiaire d'un End, pas autrement!

Le non(Rép
non(arg) est une instruction qui renvoi 1 si arg=0, et renvoi 0 sinon (ça sert pour les booléens essentiellement).

2.

Citer
" Par exemple "J+(A=1)-3*(A=2)->J" reviendrait à incrémenter si A=1, décrémenter de 3 si A=2, ne rien faire sinon. B "

QUI est le A ? combien vaut-il ?


C'était juste pour l'exemple, rien à voir avec le code winkle.gif

3.
Le 1 tout seul: C'est pour stocker 1 dans Rép (que tu trouves en faisant [2nde] [cupsmiley.gif]).
C'est un code très optimisé, donc je me sert de Rép comme variable pour sauvegarder la position actuelle.

C'est pour ça qu'il n'y a pas de sto à la fin de la ligne: pour stocker dans Rép il n'y en a pas besoin! winkle.gif

Pour comprendre vraiment les calculs de cette ligne il faut que tu te reportes aux explications sur les codes moins optimisés que j'ai données plus haut, sinon c'est chaud à comprendre j'avoue ^^.

----------------------
Pour vous aidez dans vos débuts (et même ensuite ^^) :
*Tuto Algo->Ti Basic (par Linkakro) : Traduisez vos algo (de type algobox) en prgm pour votre TI!
*Catalogue des emplacements et traductions (anglais/français) des fonctions sur la TI.
*Faites vos propres programmes de maths (par ash)

Et au fait: la politesse n'a jamais tué personne winkle.gif
 Adresse email Haut de page Bas de page 
 
Poster un nouveau sujet Poster une réponse Page: 1,      >>





  Powered by Fire-Soft-Board v1.0.10 © 2004 - 2024 Groupe FSB
Page générée en 9 requêtes
BlackOne par Grimmlink