logo
acceuil   plan   liens   agenda  
mail
cahier de texte | 5e1 | 4e1 | 4e2 | 4e3 | 3e2 | 
Login :  Mot de passe :
- Programme TI -

Voici les programmes pour TI-89 et TI-V200 :


Introduction

Cette section regroupe quelques programmes que j'ai réalisé ou qui m'ont aidé durant mes années d'études. Ces programmes sont spécifiques à la TI-V200, certains pourront fonctionner sur la TI-89 et d'autres seront esthétiquement pas terrible !

Ma récente venue et collaboration au programme T3 durant l'année scolaire 2007/2008 m'a remis dans mes anciens programmes... (oui, je sais, une page vide pendant 3 ans, c'est long...)

Programmes de lycée
Dérivée d'un quotient.
Ce programme détaille la dérivée d'un quotient de type $(u(x))/(v(x))$ étape par étape.
Télécharger le fichier
Le code avec les commentaires :
deriqo()
Prgm
Local ux,vx
ClrIO
DelVar x
Dialog
 Title "Integration par partie"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr
     ©On rappelle la formule
Disp "derivee d'un quotient"
Disp "(uv)'=(u'v-uv')/(v2)"
     ©On demande les deux fonctions avec x comme variable
Disp "entrer u(x)":Input ux
Disp "entrer v(x)":Input vx
     ©On donne les dérivées
Disp "u'=",δ(ux,x)
Disp "v'=",δ(vx,x)
Pause
     ©On donne les morceaux
Disp "u'v puis uv' puis v2"
Disp "",factor(δ(ux,x)*vx),factor(δ(vx,x)*ux),vx^2
Pause
     ©On donne la fonction dérivée factorisée
Disp "(uv)'=",factor(δ(ux*vx,x))
EndPrgm
Intégration par parties.
Ce programme détaille l'intégration par parties étape par étape.
Télécharger le fichier
Le code avec les commentaires :
intppart()
Prgm
Local ux,vx,α,β,h,j
ClrIO
DelVar x
Dialog
 Title "Intégration par partie"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr
     ©On rappelle la formule
Disp "integ par partie $int$uδv(x)=[uv(x)]-$int$vδu(x)"
     ©On demande les deux fonctions avec x en variable
Input "u(x) =",ux
Input "v'(x) =",vx
Disp "Resultat : u(x)*v(x) puis v(x)*δu(x)"
ux*$int$(vx,x)->h
δ(ux,x)*$int$(vx,x)->j
Disp h,j
Pause
ClrIO
     ©On demande les bornes
Input "borne inf =",α
Input "borne sup =",β
Disp "Resultat : [uv] puis $int$vδu puis $int$uδv"
     ©On calcule la valeur de [uv] en α,puis en β
h|x=β->h1:h|x=α->h2
     ©On donne le résultat
Disp h1-h2,$int$(δ(ux,x)*$int$(vx,x),x,α,β),(h1-h2)-$int$(δ(ux,x)*$int$(vx,x),x,α,β)
EndPrgm
Complexe.
Ce programme permet d'avoir les attributs principaux sur les complexes ainsi que résoudre des équations complexes.
Télécharger le fichier
Le code avec les commentaires :
complex()
Prgm
Local a,b,c,d,e,g,h,j,z,l,k,on,eq1,eq2,rep,aze,equation
ClrIO
Dialog
 Title "Complex"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr
x+ι*y->z
2->c
Dialog
DropDown "choix",{"equation","calcul","quitter"},c
EndDlog

     ©Pour quitter
If c=3 Then
Stop
EndIf

     ©Pour faire des calculs sur le nombre complexe z
If c=2 Then
     ©On cherche le module et l'argument (en radian et degré)
 Prompt z
 Disp "z=",z
 Disp "|z|=",abs(z)
 setMode("Angle","RADIAN")
 Disp "Arg de z=",angle(z)
 Pause
 setMode("Angle","DEGREE")
 Disp "Arg de z=",angle(z)
 Pause
 setMode("Angle","RADIAN")
EndIf
     ©Pour résoudre une équation
If c=1 Then
 Prompt equation
 Disp expand(equation)
 factor(real(equation))->eq1
 cFactor(imag(equation))->eq2
 Disp "Les équations sont :",eq1,eq2
 Pause
 ClrIO
 Input "combien d'équation(s)?",aze
     ©On demande le nombre d'équations pour pallier au cas d'une équation
 If aze=1 Then
   ClrIO
   solve(eq1,x)->l
   solve(eq2,y)|l->k
   solve(eq1,x)|k->j
   Disp j,k,"","z=",j+ι*k
   Pause
     ©Les autres cas
 Else
  Lbl suite
  ClrIO
  Disp eq1,eq2
  Prompt a,b,d,e,g,h
  Disp simult([[a,b][d,e]],[[g][h]])
  InputStr "encore(1->oui,2->non)",on
  If on=1 Then
   Goto suite
  Else
   Stop
  EndIf
 EndIf
EndIf
ClrIO
EndPrgm
Programmes du supérieur
Tableau des élèments.
Ce programme n'est pas de moi mais je le trouve très bien fait et il m'a servi en physique/chimie. Je ne détaillerai pas le code (trop long), mais je laisse l'archive (3 fichiers).
Télécharger le fichier
Mot de passe.
Ce programme permet d'avoir un mot de passe sur sa machine. On peut même l'éteindre et la rallumer, la machine demande toujours le mot de passe. N'oubliez pas le mot de passe... (il existe un moyen pour casser le programme néanmoins !)
Télécharger le fichier
Le code avec les commentaires :
interdit()
Prgm
Local xwv
Lbl de
     ©Try permet de passer outre les erreurs
Try
 ClrIO
 InputStr "Mot de passe :",xwv
     ©Changer m_d_p par votre mot de passe
 If xwv="m_d_p" Then
  ClrIO
 Else
  Goto de
 EndIf
     ©S'il y a une erreur, on la supprime et on revient...
Else
 ClrErr
 Goto de
EndTry
EndPrgm
Algorithme de César.
Le principe de cryptographie de César. Il décalait toutes les lettres de deux rangs pour former une phrase codée. Le programme permet de faire avec un décalage de 1 à 25 lettres, sans ponctuation autre que des espaces.
Télécharger le fichier
Le code avec les commentaires :
cesar()
Prgm
Local nn,ph,ii,oor,ch,ess,dd,phf
Lbl debut
ClrIO
Dialog
 Title "César"
 Text "Version 1.1"
 Text " créé par Sly"
     ©On demande la phrase codée ainsi que la clé
 Text "entrer la phrase à coder/décoder"
 Request "Phrase",ph
 Text "donner le decalage"
 Request "n",nn
EndDlog
©etiennesy@wanadoo.fr
expr(nn)->nn
dim(ph)->dd
""->phf

For ii,1,dd
 ord(mid(ph,ii,1))->oor
     ©Si le iième terme est un espace
 If oor=32 Then
  phf&" "->phf
 Else
     ©sinon, on fait tourner la roue
  char(mod(oor-97+nn,26)+97)->ch
  phf&ch->phf
 EndIf
EndFor
Disp "Phrase finale",phf
Pause
Dialog
 Title "Recommencer ?"
 DropDown "Un autre essai",{"oui","non"},ess
EndDlog
If ess=1 Then
 Goto debut
Else
 Stop
EndIf

EndPrgm
Jeu.
Petit jeu très simple du plus grand ou plus petit. La machine choisit un nombre et l'opérateur doit le trouver en un minimum de coups... C'est par la programmation de ce genre de code que j'ai commencé à programmer !
Télécharger le fichier
Le code avec les commentaires :
jeubete()
Prgm
Local xx,s,yy,c
ClrIO
Dialog
 Title "Jeu bête"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

Lbl b2
ClrIO
     ©la machine choisit un entier entre 1 et 100
int(rand(99)+1)->xx
0->s
     ©l'opérateur choisit un nombre
Disp "Un nombre entre 1 et 100"
Lbl b1
Input yy
s+1->s
     ©l'opérateur a trouvé le bon nombre
If yy=xx Then
 Disp "Gagné !!!"
 Disp "En "&string(s)&" coups."
 Pause
 Dialog
  DropDown "recommencer",{"oui","non"},c
 EndDlog
 If c=1:Goto b2
 If c=2:Stop
     ©l'opérateur trouve un nombre trop grand
ElseIf yy>xx Then
 Disp "trop grand"
 Goto b1
     ©l'opérateur trouve un nombre trop petit
ElseIf yy<xx Then
 Disp "trop petit"
 Goto b1
EndIf
EndPrgm
Programmes spécifiques au CAPES
Produit vectoriel.
Ce programme permet d'obtenir le produit vectoriel de deux vecteurs.
Télécharger le fichier
Le code avec les commentaires :
pvec()
Prgm
local aa,bb,cc,uu,vv,ww
ClrIO
Dialog
 Title "Produit vectoriel"
 text "version 1.1"
 Text "créé par Sly"
EndDlog
©etiennesy@wanadoo.fr
     ©On demande les coordonnées des deux vecteurs
Dialog
 Title "Premier vecteur"
 Request "a=",aa
 Request "b=",bb
 Request "c=",cc
EndDlog
Dialog
 Title "Second vecteur"
 Request "u=",uu
 Request "v=",vv
 Request "w=",ww
EndDlog
     ©On utilise la fonction de la calculatrice crossP
crossP([[expr(aa)][expr(bb)][expr(cc)]],[[expr(uu)][expr(vv)][expr(ww)]])->res
Disp "résultat :",string(res[1]),string(res[2]),string(res[3])
EndPrgm
PPF.
Un super programme (!) dont je ne retrouve plus l'utilité... et ce n'est pas Pile ou Face... Si quelqu'un trouve, ce serait sympa de me prévenir.
Télécharger le fichier
Le code avec les commentaires (enfin, pas encore):
ppf(p,a)
Prgm
local k,i,s,r
ClrIO
Dialog
 Title "ppf"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

p-1->k
0->i
While fPart(k)=0
 i+1->i
 k/2->k
EndWhile
i-1->s
(p-1)/2^s->q
Disp "s=",s,"q=",q

If mod(a^q,p)=1 Then
 Disp "ppf"
 Stop
EndIf

For r,0,s-1
 If mod(a^(q*2^r),p)=p-1 Then
  Disp "ppf"
  Stop
 EndIf
EndFor

Disp "pas ppf"
EndPrgm
Critère de Routh (spécial SI).
Ce critère permet d’analyser la stabilité des systèmes linéaires asservis en science de l'ingénieur niveau math spé.
Télécharger le fichier
Le code avec les commentaires :
routh()
Prgm
Local d,i,j,c,l
ClrIO
Dialog
 Title "CRITERE DE ROUTH"
 Text " Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On demande le degré du polynôme pour adapter la taille de la matrice
Dialog
 Title "Degré du polynôme"
 Request "Degré ",d
EndDlog
expr(d)->d
int(d/2)+2->c
d+2->l
     ©On créé une matrice qui sera retournée en résultat
newMat(l,c)->mat1
     ©On demande les coefficients du polynôme
For i,1,d+1
 Dialog
  Title "Coefficient a"&string(i-1)
  Request "a"&string(i-1)&" ",#("a"&string(i-1))
 EndDlog
 expr(expr("a"&string(i-1)))->#("a"&string(i-1))
EndFor
     ©On fait les calculs
For j,d+1,1,-1
 expr("a"&string(j-1))->mat1[((-1)^(d-j)+1)/2+1,int((d+1-j)/2)+1]
EndFor
For i,3,l
 For j,1,c-1
  (mat1[i-1,1]*mat1[i-2,j+1]-mat1[i-1,j+1]*mat1[i-2,1])/(mat1[i-1,1])->mat1[i,j]
 EndFor
EndFor
ClrIO
Disp "Résultat : dans la matrice mat1"
Pause
Disp mat1
     ©On supprime toutes les variables en trop
For i,1,d+1
 DelVar #("a"&string(i-1))
EndFor
EndPrgm
Programmes divers
Nombre premier ou non.
Ce programme (en fait, il y a un sous-programme) dit si un nombre est premier ou non. Il donne dans ce dernier cas un diviseur du nombre de départ. Attention, le temps de calcul est très long !
Télécharger le fichier
Le code avec les commentaires :
prem(n)
Prgm
2->d
0->w
     ©On fait tourner une boucle
while d^2«n and w=0
 n-d*int(n/d)->r
     ©Si le reste est nul, on sort de la boucle et on retourne dans l'autre programme
 if r=0
  1->w
 d+1->d
endwhile
EndPrgm

premier1()
Prgm
clrio
Dialog
 Title "Nombre premier"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

prompt n
     ©On lance tout simplement l'autre programme...
prem(n)
     ©... et on analyse la réponse
if w=1 then
 disp string(n)&" est divisible par "&string(d-1)
else
 disp string(n)&" est premier"
endif
EndPrgm
Liste des nombres premiers.
Ce programme réutilise une partie du programme précédent en créant la liste des nombres premiers jusqu'à un nombre choisit par l'opérateur. De même, le temps de calcul peut être très long.
Télécharger le fichier
Le code avec les commentaires :
prem(n)
Prgm
2->d
0->w
     ©On fait tourner une boucle
while d^2«n and w=0
 n-d*int(n/d)->r
     ©Si le reste est nul, on sort de la boucle et on retourne dans l'autre programme
 if r=0
  1->w
 d+1->d
endwhile
EndPrgm

premier2()
Prgm
Local i,n
ClrIO

Dialog
 Title "liste nombres premiers"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr
Prompt n
     ©On crée une liste dans laquelle on met déjà 2
{2}->l1
     ©On utilise l'autre programme pour tester les nombres, les uns après les autres
For i,1,int((n-1)/2)
 2*i+1->a
 prem(a)
 If w=0
  augment(l1,{a})->l1
EndFor
     ©On donne le résultat
Pause l1
EndPrgm
Le crible d'Eratosthène.
Le crible d'Eratosthène permet d'obtenir la liste des nombres premiers en barrant succéssivement tous les multiples de la liste des entiers jusqu'à un certain terme (choisi par l'opérateur).
Télécharger le fichier
Le code avec les commentaires :
eratos()
Prgm
Local i,j,m,l1,x,k,y
ClrIO
Prompt n
int((n-1)/2)->m
seq(2*i+1,i,1,m)->l1
1->i 3->x
     ©Cette boucle permet de tester tous les nombres jusqu'à la racine carrée du nombre de départ
While x$<= sqrt ((n))$
 i->k
     ©Cette boucle écrase les multiples en décalant la liste
 For j,i+1,dim(l1)
  l1[j]->y
  If int(y/x)$!=$y/x Then
   k+1->k
   y->l1[k]
  EndIf
 EndFor
 i+1->i
 l1[i]->x
 mid(l1,1,k)->l1
EndWhile
     ©On rajoute 2 à la liste et on donne le résultat
augment({2},l1)->l1
Pause l1
EndPrgm
Liste des diviseurs.
Cette fonction permet d'avoir la liste des diviseurs d'un nombre choisi par l'opérateur. Cette méthode est longue.
Télécharger le fichier
Le code avec les commentaires :
divis(n)
Func
Local k,l1
     ©On créé une liste avec 1 au départ
{1}->l1
For k,2,n
     ©On regarde si la partie entière du quotient est égal au quotient
 If int(n/k)=n/k
  augment(l1,{k})->l1
EndFor
     ©On renvoie le résultat
l1
EndFunc
Algorithme d'Euclide.
Cette fonction utilise l'algorithme d'Euclide pour déterminer le PGCD de deux nombres.
Télécharger le fichier
Le code avec les commentaires :
euclid1(a,b)
Func
Local l1
     ©On créé une liste à deux termes
{a,b}->l1
     ©tant que le deuxième terme est non nul, on continue l'algorithme
While l1[2]$!=$0
 {l1[2],l1[1]-int(l1[1]/(l1[2]))*l1[2]}->l1
EndWhile
     ©On renvoie le résultat
"pgcd = "&string(l1[1])
EndFunc
Algorithme d'Euclide pour les équations diophantiennes.
Ce programme permet de déterminer une solution particulière d'une équation diophantienne de type ax+by=c avec a, b et c 3 entiers relatifs. La détermination s'appuie sur l'algorithme d'Euclide.
Télécharger le fichier
Le code avec les commentaires :
euclide(a,b)
Prgm
Local r,u,v,w,x,y,z,q
Dialog
 Title "Equation diophantienne"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On initialise l'algorithme
a->r
b->y
1->u
0->v
0->w
1->x
     ©On utilise l'algorithme d'Euclide et on fait permuter les lettres
While y$!=$0
 int(r/y)->q
 u->z:w->u:z-q*w->w
 v->z:x->v:z-q*x->x
 r->z:y->r:z-q*y->y
EndWhile
     ©On n'oublie pas le signe !
sign(r)->s
abs(r)->r
ClrIO
Disp "Pgcd de "&string(a)&" et "&string(b)&" = "&string(r)
Disp string(r)&" = "&string(a)&"*("&string(s*u)&") + "&string(b)&"*("&string(s*v)&")"
EndPrgm
Dichotomie.
Ce programme est plus complet que la simple fonction ci après. Il permet de trouver la valeur d'une solution réelle par le principe de dichotomie.
Télécharger le fichier
Le code avec les commentaires :
dicho()
Prgm
Local b1,b2,b3,amp,f
Dialog
 Title "Dichotomie"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On demande les informations
Dialog
 Title "entrer la fonction"
 Request "f(x)=",ff
 Request "borne inf",bi
 Request "borne sup",bs
 Request "Amplitude",am
EndDlog

expr(ff)->f(x)
approx(expr(bi))->b1
approx(expr(bs))->b2
expr(am)->amp
ClrIO

     ©On regarde s'il y a bien une solution...
If f(b1)>0 and f(b2)>0 or f(b1)<0 and f(b2)<0 Then
 Disp "Pas de solution"
 Stop
EndIf

     ©...et si une solution n'est pas une borne
If f(b1)=0 Then
 Disp "la solution est ",b1
 Stop
ElseIf f(b2)=0 Then
 Disp "la solution est ",b2
 Stop
EndIf

     ©On commence l'algorithme en regardant le sens de la fonction et en permuttant tour à tour
While b2-b1>amp
 (b1+b2)/2->b3
 If f(b1)>0 and f(b2)<0 Then
  If f(b3)<0 Then
   b3->b2
  ElseIf f(b3)>0 Then
   b3->b1
  ElseIf f(b3)=0 Then
   Disp "La solution est :",b3
   Stop
  EndIf
 ElseIf f(b1)<0 and f(b2)>0 Then
  If f(b3)<0 Then
   b3->b1
  ElseIf f(b3)>0 Then
   b3->b2
  ElseIf f(b3)=0 Then
   Disp "La solution est :",b3
   Stop
  EndIf
 EndIf
EndWhile

     ©On donne l'encadrement
Disp "L'encadrement est :","[ "&string(min(b1,b2))&" ; "&string(max(b1,b2))&" ]"

DelVar ff,bi,bs,am
EndPrgm
Dichotomie (2).
Cette fonction donne seulement une solution approchée (ou exacte) par le principe de dichotomie.
Télécharger le fichier
Le code avec les commentaires :
dicho2(a,b,ε)
Func
Local c
     ©On divise par 2 l'encadrement
While (b-a)/2»ε
 (a+b)/2->c
     ©On fait les tests
 If f(c)=0
  Return approx(c)
 If f(a)*f(c)<0 Then
  c->b
 Else
  c->a
 EndIf
EndWhile
     ©On renvoie le résultat
approx(c)
EndFunc
Méthode simultanée de la corde et Newton.
Ce programme permet de trouver un encadrement d'une racine d'amplitude déterminée par l'opérateur par les méthodes simultanées de la corde et de Newton. De même que pour la dichotomie, on peut faire une fonction beaucoup plus rapide (s'il y a des demandes...).
Télécharger le fichier
Le code avec les commentaires :
cord_new()
Prgm
Local b1,b2,amp,f,c,t
Dialog
 Title "Encadrement par la corde et Newton"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On demande les informations
Dialog
 Title "entrer la fonction"
 Request "f(x)=",ff
 Request "borne inf",bi
 Request "borne sup",bs
 Request "Amplitude",am
EndDlog

     ©On prépare le terrain avec les dérivées première et seconde de la fonction
expr(ff)->f(x)
approx(expr(bi))->b1
approx(expr(bs))->b2
expr(am)->amp
δ(f(x),x)->gg(x)
δ(gg(x),x)->hh(x)
ClrIO

     ©On regarde si une solution existe
If f(b1)>0 and f(b2)>0 or f(b1)<0 and f(b2)<0 Then
 Disp "Pas de solution"
 Stop
EndIf

     ©On regarde si une borne n'est pas solution
If f(b1)=0 Then
 Disp "la solution est ",b1
 Stop
ElseIf f(b2)=0 Then
 Disp "la solution est ",b2
 Stop
EndIf

     ©On utilise l'algorithme
While b2-b1$>=$amp
 (b1*f(b2)-b2*f(b1))/(f(b2)-f(b1))->c
 If f(b1)*hh(b1)>0 Then
  b1-f(b1)/gg(b1)->t
 Else
  b2-f(b2)/gg(b2)->t
 EndIf
     ©On remplace les bornes sup et inf
 min(c,t)->b1
 max(c,t)->b2
EndWhile

     ©On donne le résultat
Disp "L'encadrement est :","[ "&string(approx(min(b1,b2)))&" ; "&string(approx(max(b1,b2)))&" ]"

DelVar ff,bi,bs,am,gg,hh
EndPrgm
Méthode de la tangente d'Euler.
Cette méthode permet de construire une courbe approchée solution d'une équation différentielle.
Télécharger le fichier
Le code avec les commentaires :
eqdiff2()
Prgm
Local aa,xaa,yaa,hh,xmm,tr,i
ClrIO
FnOff
PlotsOff
Dialog
 Title "Equation différentielle par Euler"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On demande les informations
Dialog
 Title "Equa diff y'=ay par la methode d'Euler"
 Request "a",aa
 Request "x0",xaa
 Request "y0",yaa
 Request "h",hh
 Request "xm",xmm
 DropDown "Tracer une courbe",{"oui","non"},tr
EndDlog

     ©On réccupère les données
expr(aa)->a
expr(xaa)->xa
expr(yaa)->ya
expr(xmm)->xm
expr(hh)->h

     ©On créé deux listes
seq(x,x,xa,xm,h)->list1
seq(0,x,xa,xm,h)->list2

ya->list2[1]
     ©On lance l'algorithme
For i,1,(xm-xa)/h
(1+a*h)*list2[i]->list2[i+1]
EndFor
1->xscl
1->yscl
     ©on affiche les points reliés par des segments correspondant à la solution approchée
NewPlot 1,2,list1,list2,,,,3
ZoomData
Pause

     ©Une courbe est tracée si l'opérateur l'a demandée
If tr=1 Then
 Dialog
  Request "Entrez la fonction",g
 EndDlog
 expr(g)->y1(x)
 DispG
 Pause
EndIf

DispHome

EndPrgm
Courbe intégrale par la méthode d'Euler.
Ce programme permet de tracer une courbe intégrale à partir de la méthode d'Euler.
Télécharger le fichier
Le code avec les commentaires :
euler_1()
Prgm
Local ff,xaa,yaa,hh,xmm,tr,i
ClrIO
FnOff
PlotsOff
Dialog
 Title "Courbe integral y'=f(x) par la méthode d'Euler"
 Text "Version 1.1"
 Text " créé par Sly"
EndDlog
©etiennesy@wanadoo.fr

     ©On demande les informations
Dialog
 Title ""
 Text "Entrer f(x)"
 Request "f(x)",ff
 Request "x0",xaa
 Request "y0",yaa
 Request "h ",hh
 Request "xm",xmm
 DropDown "Tracer une courbe",{"oui","non"},tr
EndDlog

     ©On réccupère les données
DelVar x
expr(ff)->f
expr(xaa)->xa
expr(yaa)->ya
expr(xmm)->xm
expr(hh)->h

     ©On créé deux listes
seq(u,u,xa,xm,h)->l1
seq(0,u,xa,xm,h)->l2

ya->l2[1]
     ©On lance l'algorithme, différent du programme précédent
For i,1,(xm-xa)/h
 l1[i]->x
 l2[i]+h*f->l2[i+1]
EndFor

     ©on affiche les points reliés par des segments correspondant à la solution approchée
NewPlot 1,2,l1,l2,,,,5
ZoomData
Pause

     ©Une courbe est tracée si l'opérateur l'a demandée
If tr=1 Then
 Dialog
  Request "Entrez la fonction",g
 EndDlog
 expr(g)->y1(x)
 DispG
 Pause
EndIf

DispHome
delvar x,xa,ya,f,h,xm,l1,l2,g,y1

EndPrgm

logo gestclasse

Ce site a fait l'objet d'une déclaration à la CNIL.
Vous disposez d'un droit d'accès, de modification et de suppression des données vous concernant (loi Informatique et Libertés du 6 janvier 1978).
Pour toute demande et pour exercer ce droit, adressez-vous à M. ETIENNE.
Ce site est une initiative expérimentale privée, il est totalement indépendant et ne saurait être considéré comme le reflet de la politique du collège Pablo Picasso. En aucun cas, la responsabilité de celui-ci ne pourrait être recherchée.

 
 
Gest'classe © 2003-2005 créé par Lux Pierre - gestclasse.free.fr hautdepage  Haut de page