\documentclass{article}
\usepackage[francais]{babel}
%\usepackage[OT1]{fontenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath,amsfonts,amssymb}
\usepackage{xspace}
\usepackage{makeidx}
\usepackage{times}
 \usepackage[ps2pdf,
            breaklinks=true,
            colorlinks=true,
            linkcolor=red,
            citecolor=green
            ]{hyperref}

%HEVEA\htmlfoot{Retour \`a la page personnelle de \ahref{http://www-fourier.ujf-grenoble.fr/\~parisse}{Bernard Parisse}.}
%HEVEA\htmlhead{Retour \`a la page personnelle de \ahref{http://www-fourier.ujf-grenoble.fr/\~parisse}{Bernard Parisse}.}
\usepackage{pst-plot}
\usepackage{graphicx}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\makeindex

\textwidth 15cm
\textheight 21cm
\topmargin=-7mm
\oddsidemargin=0mm

\begin{document}

\title{Apercu HP49/49+/50}
\author{ {\tt Bernard.Parisse@ujf-grenoble.fr} }

\maketitle

Ce document d\'ecrit des fonctionnalit\'es de la HP49/49+/50 pour
les candidats au Capes. Pour b\'en\'eficier de l'ensemble
des fonctionnalit\'es d\'ecrites (g\'eom\'etrie et tableur), 
il faut mettre \`a jour la ROM de votre calculatrice, en allant sur le
site~:
\begin{center}
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/#hpgeo|
\end{center}
Les HP49G+ et 50G n'\'etant pas r\'etroprojettables (sur tablette,
il existe des \'emulateurs pour PC), ce sont
des HP49G qui sont susceptibles d'\^etre utilis\'ees,
elles sont de l'ordre de 2 \`a 3 fois moins rapides que les HP49G+ 
ou HP50G, 

Vous trouverez l'index \`a la page suivante, il est suivi par 
la table des mati\`eres, puis le texte lui-m\^eme.
La derni\`ere section \ref{sec:depannage} donne
quelques astuces de d\'epannage.

\printindex

\tableofcontents


\section{Prise en main, configuration}
\begin{itemize}
\item Chaque touche\index{touche} peut avoir jusque 6 fonctions selon
qu'elle est ``shiftée'' ou en mode alphabétique (repérez les 2 
{\bf shift}\index{shift}
droit et gauche et la touche {\bf alpha}\index{alpha} 
au-dessus de \verb|ON|). Les 
fonctions principales
(modes non shift\'e, shift\'e gauche, shift\'e droit, alpha)
sont affich\'ees en couleurs sur chaque touche.
On peut bloquer le mode alpha en tapant 2 fois
sur la touche alpha (on débloque alors en tapant une nouvelle
fois sur alpha).
En mode alphab\'etique, les caract\`eres sont en majuscule, sauf
si on tape sur shift avant un caract\`ere. On peut bloquer en mode
miniscule\index{minuscule} si on est en mode 
alphab\'etique en tapant sur la touche shift puis la touche alpha.
On peut saisir des caract\`eres non pr\'esents au clavier en tapant
sur la touche \verb|CHARS| (shift droit-\verb|EVAL|).
Par exemple, pour éteindre la calculatrice,
taper la touche shift droit puis la touche \verb|ON|.
\item Si la calculatrice semble {\bf bloqu\'ee}\index{blocage} 
(calcul trop long par  exemple), appuyer sur \verb|ON|. Si
cela ne fonctionne pas, taper simultan\'ement sur \verb|ON| et
\verb|F3|, ou enfoncer un objet pointu, trombone par exemple,
dans le trou reset\index{reset} situ\'e \`a l'arri\`ere.
\item Les calculs se font dans l'historique (si vous \^etes dans
une autre application, quittez-la, par exemple en 
tapant plusieurs fois sur \verb|ON|).
On tape le calcul dans une ligne
séparée appelée ligne de commande. Taper \verb|ENTER|
pour exécuter la ligne de commande. Les paires
de question/réponse s'affichent dans l'historique. On peut 
recopier un niveau de l'historique
puis le modifier (touches \verb|HIST| et flèches haut et bas).
La saisie d'expressions peut se faire avec l'\'editeur d'\'equation
(touche \verb|EQW|). Pour effacer des niveaux de
l'historique utilisez la touche \verb|HIST| puis la touche
d'effacement, pour effacer tout l'historique, utilisez shift droit
puis la touche d'effacement (\verb|CLEAR|).
\item
Le menu apparait en bas de l'\'ecran, on l'appelle {\bf bandeau}\index{menu}. 
Les menus s'actionnent avec les touches en correspondance
\verb|F1| \`a \verb|F6|. 
On peut changer le menu courant par des touches du clavier, par exemple 
la touche \verb|TOOL| affiche le menu courant de l'application, 
\verb|ALGB| affiche le menu algèbre, etc.. 
Utiliser les touches \verb|NXT| et \verb|PREV|
pour passer à la page suivante/précédente du menu.
\item
Pour acc\'eder \`a l'{\bf aide}\index{aide}~: 
on dispose d'un catalogue\index{catalogue} des fonctions (touche \verb|CAT|)
et d'une aide en ligne pour les commandes du CAS (\verb|TOOL NXT F2|)
d\'ecrivant bri\`evement la commande, avec un exemple et des
liens vers les commandes proches.
\item
Les calculs sont affectés par le {\bf mode}\index{mode} courant
(réel\index{reel@r\'eel!mode}/complexe\index{complexe@complexe!mode}, 
exact\index{exact!mode}/approx\index{approx!mode}, 
radian\index{radian!mode}/degré, etc.). Ces modes apparaissent
en haut de l'\'ecran sur une ligne
appel\'ee ligne d'état (\verb|R/C| pour r\'eel ou complexe, 
\verb|=/~| pour mode
exact ou approch\'e, \verb|RAD/DEG| pour l'angle). 
Pour changer de mode, utiliser la touche \verb|MODE|, puis choisissez
le menu \verb|CAS| (touche \verb|F3|)
pour changer les parties spécifiques au calcul formel.
Il existe des raccourcis pour les changements de mode fréquents~:
\begin{itemize}
\item pour passer rapidement du mode exact au mode approch\'e appuyer 
simultan\'ement sur le shift droit et \verb|ENTER| (touche
\verb|->NUM|).
\item pour basculer du mode r\'eel au mode complexe, appuyer simultan\'ement
sur le shift gauche et \verb|TOOL| (touche \verb|i|)
\end{itemize}
\end{itemize}
Dans les sections suivantes, on abordera plus en d\'etails les
possibilit\'es de l'historique, puis les applications telles
que les trac\'es de graphes, le tableur, les statistiques, les
calculs financiers et la programmation.

{\bf Exercices}:
Ces exercices sont destin\'es
\`a vous familiariser avec la saisie de commandes (au clavier,
mode alphab\'etique, utilisation des menus)
et les changements de mode sur la calculatrice.
\begin{enumerate}
\item Calculer $\sin(3)$ en mode radian et en mode degr\'es.
\item Calculer 10! en mode exact
\item Passez en mode approch\'e et refaites le m\^eme calcul
\item Repassez en mode exact.
D\'evelopper puis factoriser le polyn\^ome $(X+3)^7 \times
  (X-5)^6$.
Utiliser les menus pour trouver la fonction \verb|EXPAND| ou \verb|FACTOR|,
essayez aussi de les saisir au clavier.
\end{enumerate}

\section{Calculs\index{historique}}

\subsection{Les nombres: représentation exacte\index{exact} et approchée\index{approx}}
On distingue~:
\begin{itemize}
\item 
Les {\bf entiers}\index{entier} longs (en précision arbitraire):\\
Ils sont limit\'es uniquement par la m\'emoire disponible
mais plus ils sont grands, plus les opérations arithmétiques
sont longues.
\item Les entiers courts:\\ 
Ce sont des entiers de taille fixe (64 bits par exemple, compris
entre $[0,2^{64}-1]$), on utilise le préfixe \verb|#|. 
Ils peuvent \^etre saisis en base 10 (suffixe \verb|d|)
ou 16 (suffixe \verb|h|). Ils sont surtout utiles en programmation.
\item Les nombres {\bf flottants}\index{flottant} (r\'eels)\\
Ils se composent d'une {\bf mantisse}\index{mantisse} 
et d'un {\bf exposant}\index{exposant} s\'epar\'es par le
signe \verb|E| (touche \verb|EEX|). Le s\'eparateur d\'ecimal
est par d\'efaut \verb|.|. \\
Les flottants sont cod\'es 
en base 10 (on parle de BCD, binaire codé décimal).
La base 10 est utilis\'ee sur beaucoup de calculatrices car
elle permet de repr\'esenter les nombres d\'ecimaux sans erreurs.
\end{itemize}

Rappel sur les nombres flottants~:
L'\'ecriture d'un flottant normalis\'e $x$ de mantisse $m=0.m_1...m_k$ et
d'exposant $e$ en base $b$ ($b=10$ ici) est
\[ x = (m_1 b^{-1} + ... + m_k b^{-k}) b^e, \quad m_1 \in
[1,b-1], ..., m_k \in [0,b-1] \]
o\`u $k$ est le nombre de chiffres significatifs.
Par exemple \verb|0.12E7| qui repr\'esente le nombre approch\'e 1 million
200 mille, a pour mantisse $m_1=1, m_2=2, m_3=...=m_k=0$ et pour exposant 7.
Les HP disposent de deux repr\'esentation de flottants, 
qui diff\`erent par la valeur de $k$, celui qui a la plus grande
valeur de $k$ est utilis\'e en
interne pour am\'eliorer la pr\'ecision des calculs interm\'ediaires.

Erreurs d'arrondi\index{arrondi} et de représentation~: La mantisse étant
de taille finie, à chaque calcul ou d\`es qu'on représente
un rationnel qui n'est pas de la forme un entier divisé par 10
à une puissance petite, on fait une erreur relative sur le nombre
représenté (par exemple si on repr\'esente 1/3). 
Cette erreur relative peut atteindre $1E-11$ pour les r\'eels
et $1E-15$ pour les r\'eels utilis\'es en interne.

Lorsqu'on effectue une multiplication, les erreurs relatives
s'additionnent (en toute rigueur, il faut y ajouter le produit des*
erreurs, souvent négligeable et une erreur relative d'arrondi).
Pour les additions et soustractions ce sont les erreurs absolues
qui s'additionnent, donc si les mantisses se compensent presque, l'erreur
relative peut augmenter considérablement, par exemple 
$(1.0+1E-12)-1.0$ donne comme résultat un flottant nul.



{\bf Exercices} (Calcul exact et approché sur les entiers et réels)
\begin{enumerate}
\item Y-a-t-il une limite sur la plus grande factorielle
calculable exactement et approximativement sur votre calculatrice?

\item Trouver $n$ le plus petit possible tel que $(1.0+10^{-n})-1.0$
renvoie 0.0

\item Calculer les premi\`eres valeurs de $u_{n}$ 
en mode exact et approch\'e avec~:
\[ u_{n+1}=2(u_n-1/3) = 2u_n -2/3, \quad u_0=2/3 \]
Comparer les r\'esultats, en mode approch\'e obtient-on la m\^eme
suite selon la formule de r\'ecurrence entr\'ee?

\item Calculer en mode approch\'e en croissant ou en d\'ecroissant
\[ \sum_{j=1}^n \frac{1}{j} \]
pour quelques valeurs de $n$. Pour le calcul en d\'ecroissant,
on pourra utiliser $\sum_{0}^{n-1} \frac{1}{n-j} $

\end{enumerate}


\subsection{Types, variables, \'evaluation, simplification}
Les calculs lanc\'es dans l'historique sont effectu\'es
par un mini-logiciel de calcul formel. Comme dans tout logiciel
de calcul formel, on peut utiliser des {\bf variables}\index{variable} 
formelles (qui n'ont pas de valeur num\'erique affect\'ee) et faire
des calculs litt\'eraux. 
On peut aussi stocker des r\'esultats interm\'ediaires dans
des variables (qui ne sont plus alors formelles, on dit qu'elles
sont affect\'ees) ou faire des hypoth\`eses (sur HP, on peut
seulement supposer qu'une variable est dans un intervalle de $\R$
et les in\'egalit\'es strictes sont remplac\'ees par des
in\'egalit\'es larges).
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple        & R\'esultat \\
\hline
Affectation\index{affectation} & \verb|STO|\index{STO} & \verb|1 STO> A| & 1 \\
Suppression\index{suppression} & \verb|PURGE|\index{PURGE} & \verb|PURGE(A)| & \verb|NOVAL| \\
Hypoth\`ese\index{hypothese@hypoth\`ese} & \verb|ASSUME|\index{ASSUME} & \verb|ASSUME(A>1)| & {\tt $A\geq 1$} \\
\hline
\end{tabular}
\end{center}
On peut aussi g\'erer les variables affect\'ees avec l'application Filer 
(touche shift-\verb|FILES|).

Lorsqu'on tape une commande dans l'historique, il s'agit d'abord d'une
chaine de caractères, qui est ensuite transformée en un objet par
l'interpréteur (en anglais parser), 
puis évaluée en fonction des variables affect\'ees et des modes
et/ou simplifiée ou non. 
L'{\bf évaluation}\index{evaluation} 
consiste à remplacer les variables qui ont été
affectées par leur valeur, et à propager ces remplacement dans les calculs. 
La {\bf simplification}\index{simplifier}
consiste à appliquer certaines règles~: en mode alg\'ebrique, 
les expressions entr\'ees sont r\'e\'ecrites sous forme d'une unique fraction
rationnelle irr\'eductible apr\`es simplification \'eventuelle
des radicaux (en mode RPN, il n'y a aucune simplification).
On peut empêcher l'évaluation en utilisant le symbole \verb|'| (quote)
ou la fonction \verb|QUOTE|, on peut forcer une évaluation avec
l'instruction \verb|EVAL|. 
L'\'evaluation d'une variable non affect\'ee peut \^etre modifi\'ee en faisant
une hypoth\`ese (par exemple \verb|ASSUME(A>=0)| permet
de simplifier ${\tt \sqrt{A^2}}$ en \verb|A|), ou en d\'eclarant
la variable comme r\'eelle en mode complexe (la liste des variables 
suppos\'ees r\'eelles
est contenue dans la variable \verb|REALASSUME| du r\'epertoire
\verb|CASDIR| (utiliser shift-\verb|FILES| puis \verb|EDIT| 
du bandeau pour modifier la liste \verb|REALASSUME|).

Les principaux {\bf types}\index{type} d'objets manipulables dans l'historique sont: 
\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Types & Exemple & Remarques \\
\hline
Entier & 1 & \\
R\'eel & \verb|0.12E7| & ou \verb|1200000.| \\
Complexe exact & 1+2*i & \\
Complexe approch\'e & (1.2,2.3) & \\
Variable & \verb|M| &  \\
Expression & \verb|1+2*SIN(X) STO> EQ| & \verb|OBJ>(EQ)| 
d\'ecompose \verb|EQ|  \\
Liste & \verb|\{ 1, 2 \} STO> L| & \verb|L[1]|
 1ier \'el\'ement de la liste \verb|L| \\
Vecteur & \verb|[1, 2] STO> V | & 
\verb|V[1]| 1ier \'el\'ement du vecteur \verb|V| \\
Matrice & \verb|[[1,2],[3,4]] STO> M| & \verb|GET(M,{2,1})| 
(ou \verb|M[3]|) ligne 2 colonne 1  \\
Chaine & \verb|"Bonjour"| &  \\
\hline
\end{tabular}
\end{center}
Il existe d'autres types par exemple les 
objets-unités (pour la physique), les objets graphiques, les programmes
(délimiteur \verb|<< >>|), etc. 

Comme dans les logiciels de calcul formel, le langage
des calculatrices formelles est non typé, c'est-à-dire
que les instructions s'adaptent dans la mesure du possible aux différents 
types de données passées en argument, par exemple il existe une même 
instruction + qui permet d'additionner des réels ou des entiers ou des chaines
de caractères (concaténation). Il est toutefois important de
comprendre que les opérations peuvent être très différentes
selon le type des objets passé (et les modes). On peut utiliser
tous les types d'objets en argument d'une fonction, à l'exception des objets
de types programme en mode algébrique.
Notez qu'une instruction
a toujours le même nombre d'arguments sur les HP49. Il existe en effet
un mode de saisie, dit {\bf RPN}\index{RPN} (reverse polish notation), 
dans lequel on doit donner
les arguments d'une instruction avant l'instruction, 
elle ne peut donc pas avoir un nombre variable d'arguments comme le
font couramment les logiciels de calcul formel ou les calculatrices
d'autres constructeurs.

\subsection{Principales commandes}
Les commandes de calcul formel sont accessibles \`a partir de la
touche \verb|SYMB| (menu principal) ou de des touches
de menu sp\'ecialis\'e \verb|ALG| (alg\`ebre, par exemple pour
factoriser et d\'evelopper), \verb|CALC| (calculus, pour calculer
une limite, faire un d\'eveloppement de Taylor, etc.), \verb|S.SLV|
(r\'esoudre exactement une \'equation), \verb|EXP & LN| et \verb|TRIG|
(r\'e\'ecriture), \verb|ARIT| (arithm\'etique).
L'aide en ligne donne la syntaxe de la commande, avec un exemple
(touche \verb|TOOL| puis \verb|NXT| puis F2 (\verb|HELP|) puis tapez
la touche alpha et la premi\`ere lettre de la commande, puis les
touches de direction pour s\'electionner une commande).
Nous ne donnons ici que les principales commandes,
le guide de r\'ef\'erence du calcul formel de la HP49 est téléchargeable
sur\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/degraeve/louijean.pdf|


\subsubsection{Arithm\'etique des entiers\index{entier}}
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple        & R\'esultat \\
\hline
Division euclidienne\index{division} & \verb|IDIV2|\index{IDIV2} & \verb|IDIV2(7,5)| & \verb|{1,2}| \\
 & \verb|IQUOT|\index{IQUOT} &  \verb|IQUOT(7,5)| & \verb|1|\\
 & \verb|IREMAINDER| & \verb|IREMAINDER(7,5)| & \verb|2| \\
 & \verb|MOD|\index{MOD} &  \verb|7 MOD 5| & \verb|2| \\
PGCD\index{pgcd} & \verb|GCD|\index{GCD!entier} & \verb|GCD(15,25| & 5 \\
PPCM & \verb|LCM|\index{LCM!entier} & \verb|LCM(15,25)| & 75 \\
B\'ezout\index{Bezout} & \verb|IEGCD|\index{IEGCD} & \verb|IEGCD(15,25)| & \verb|{5,2,-1}| \\
& \verb|IABCUV|\index{IABCUV} & \verb|IABCUV(15,25,5)| & \verb|{2,-1}| \\
Liste des diviseurs & {\tt DIVIS}\index{DIVIS} & \verb|DIVIS(15)| & \verb|{1,3,5,15}|\\
Factorisation\index{factoriser} & {\tt FACTOR}\index{FACTOR!entier} & \verb|FACTOR(100)| & \verb|2^2*5^2| \\
Restes chinois & {\tt ICHINREM}\index{ICHINREM} & \verb|ICHINREM(| & \verb|[-12,35]| \\
& & \verb|[2,7],[3,5])| &  ($-12 \pmod{35}$) \\
Indicatrice d'Euler & {\tt EULER}\index{EULER} & \verb|EULER(15)| & 8 \\
Pseudo-primalit\'e\index{premier} & \verb|ISPRIME?|\index{ISPRIME?} & \verb|ISPRIME?(97)| & 1. \\
Premier suivant & \verb|NEXTPRIME|\index{NEXTPRIME} & \verb|NEXTPRIME(96)| & 97 \\
Premier pr\'ec\'edent & \verb|PREVPRIME|\index{PREVPRIME} & \verb|PREVPRIME(96)| & 93
\\
Puissance modulo rapide\index{puissance rapide} & \verb|POWMOD|\index{POWMOD} & \verb|POWMOD(11,12)| & 1 
$\pmod{13}$ \\
\hline
\end{tabular}
\end{center}
En mode {\bf pas à pas}\index{mode@mode!pas \`a pas}
(touche \verb|MODE|, configuration \verb|CAS|,
cocher \verb|Step/Step|), l'algorithme de la potence\index{potence}
(division euclidienne),
les opérations de l'algorithme d'Euclide\index{Euclide} et 
l'algorithme de Bézout\index{Bezout} sont affichées étape après étape.

\subsubsection{Arithm\'etique des polyn\^omes\index{polynome}}
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple ou arguments & R\'esultat \\
\hline
Division euclidienne\index{division} & {\tt DIV2}\index{DIV2} & \verb|(X^3-1,X^2+1)| & \verb|{X,-(1+X)}|\\
Quotient euclidien & {\tt QUOT}\index{QUOT} & \verb|QUOT(X^3-1,X^2+1)| & \verb|X|\\
Reste euclidien & {\tt REMAINDER}\index{REMAINDER} &
\verb|...(X^3-1,X^2+1))|& \verb|-(1+X)| \\ 
puissances croissantes & \verb|DIVPC|\index{DIVPC} & \verb|DIVPC(1,1+X,3)|& 
\verb|1-X+X^2-X^3|\\
PGCD, PPCM\index{pgcd} & {\tt GCD, LCM}\index{GCD!polynome}\index{LCM!polynome} & \verb|GCD(X^2-1,X^3-1)|& \verb|X-1|\\
B\'ezout\index{Bezout} & {\tt EGCD, ABCUV}\index{EGCD}\index{ABCUV} & \verb|EGCD(X^2-1,X^3-1)|& \verb|{X-1 -X 1}| \\
Factorisation\index{factoriser} & {\tt FACTOR} \index{FACTOR!polynome}& \verb|FACTOR(X^2-1)| & \verb|(X-1)(X+1)| \\
Eléments simples\index{fraction} & {\tt PARTFRAC} \index{PARTFRAC}&
\verb|PARTFRAC(2/(X^2-1))| & \verb|1/(X-1)-1/(X+1)|\\
Fraction propre\index{fraction} & {\tt PROPFRAC}\index{PROPFRAC} &
\verb|PROPFRAC((X^3-1)/(X^2+1))| &
\verb|X-(1+X)/(X^2+1)|\\
R\'esultant & {\tt RESULTANT} \index{RESULTANT} & \verb|...(X^3+P*X+Q,3*X^2+P)| &
\verb|27Q^2+4P^3|\\
\hline
\end{tabular}
\end{center}
On peut aussi travailler avec des polynômes à coefficients
dans $\Z/nZ$\index{modulaire}, 
il suffit de stocker $n$ dans la variable \verb|MODULO|
(touche \verb|MODE|, configuration du \verb|CAS|) puis d'appeler
les mêmes instructions avec le préfixe \verb|MOD|.

\subsubsection{R\'e\'ecriture\index{simplifier}}
On peut appliquer ces règles de réécriture en ligne de commande,
ou sur la sélection dans l'éditeur d'équation (prendre la commande
depuis l'un des menus \verb|ALGB|, \verb|EXP&LN|, \verb|TRIG|)~:\\
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Remarque \\
\hline
Substituer\index{substituer} & \verb|SUBST|\index{SUBST} & une variables par une valeurs \\
D\'evelopper\index{developper@d\'evelopper} & \verb|EXPAND|\index{EXPAND} &
fraction rationnelle \\
R\'eordonner\index{reordonner@r\'eordonner} & \verb|REORDER|\index{REORDER} &
fraction rationnelle \\
Regrouper\index{regrouper} & \verb|COLLECT|\index{COLLECT} & fraction rationnelle \\
Simplifier\index{simplifier} & \verb|SIMPLIFY|\index{SIMPLIFY} & recherche de relations algébriques \\
Vers exponentielle\index{exp} et ln\index{ln} & \verb|EXPLN|\index{EXPLN} &  \\
Vers fonctions trigonométriques\index{sin}\index{cos}\index{trigo@trigonom\'etrie} &
\verb|SINCOS| \index{SINCOS} &  \\
Développer exp, ln, sin, cos, tan & \verb|TEXPA|\index{TEXPA} & à $2i\pi$ près \\
Linéariser des exponentielles\index{exp} & \verb|LIN|\index{LIN} &  \\
Rassembler des logarithmes\index{ln} & \verb|LNCOLLECT|\index{LNCOLLECT} & à $2i\pi$ près \\
Rassembler des sin/cos\index{sin}\index{cos}\index{trigo@trigonom\'etrie} &
\verb|TCOLLECT|\index{TCOLLECT}, \verb|TLIN|\index{TLIN} & \\
\hline
\end{tabular}
\end{center}
Il existe d'autres règles de réécriture, par exemple
pour la trigonométrie\index{trigo@trigonom\'etrie}~:
\begin{itemize}
\item \verb|TRIG|\index{TRIG}, \verb|TRIGSIN|, \verb|TRIGCOS|,
\verb|TRIGTAN|~: simplifie
une expression trigonom\'etrique en utilisant la relation
$\sin^2+\cos^2=1$. Favorise la r\'e\'ecriture en terme de $\sin$,
$\cos$ ou $\tan$.
\item \verb|HALFTAN|\index{HALFTAN}: remplace les expressions trigonom\'etriques
en fonction de la tangente de l'arc moiti\'e. 
\verb|TAN2SC2| et 
\verb|TAN2CS2| effectue l'op\'eration inverse, alors que \verb|TAN2SC|
remplace tangente par sinus sur cosinus.
\end{itemize}

\subsubsection{Analyse}
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple ou arguments & R\'esultat \\
\hline
Dérivée\index{derivee@deriv\'ee} & \verb|DERIV|\index{DERIV} & \verb|DERIV(SIN(X),X)| & \verb|COS(X)| \\
Variations & \verb|TABVAR|\index{TABVAR} & \verb|TABVAR((X+1)/(X+2)| & ... \\
\hline
Primitive\index{primitive}
\index{integration@int\'egration!ind\'efinie}
 & \verb|RISCH|\index{RISCH@RISCH} & \verb|RISCH((2*X^2+1)*EXP(X^2)| &
\verb|X*EXP(X^2)| \\
Intégrale\index{integration@int\'egration!d\'efinie} & {\tt $\int$ } & {\tt $\int(0,1,1/(X^2+1)^4,X)$} & {\tt
  (15$\pi$+44)/192} \\
Par parties 
\index{integration@int\'egration!par parties}
& \verb|IBP|\index{IBP} & \verb|IBP(LN(X),X)| & \verb|{X*LN(X),-1}|\\ 
\hline
Limite\index{limite} & \verb|LIMIT|\index{LIMIT} & \verb|LIMIT(SIN(X)/X,X=0)| & 1 \\
(à droite)  &              & \verb|LIMIT(SQRT(1-COS(X))/X,X=0+0)| & {\tt $\sqrt{2}/2$} \\
\hline
Taylor & \verb|TAYLR|\index{TAYLR} & \verb|TAYLR(SIN(X),X,5)| &
\verb|1/120X^5-1/6X^3+x| \\
Séries\index{series}\index{taylor} & \verb|SERIES|\index{SERIES} & \verb|SERIES((EXP(X)-1)/SIN(X),X=0,4)| & \verb|{ Limit:1 ...}| \\ 
(en $+\infty$) & & \verb|SERIES((1+1/X)^(X),X=|$+\infty$\verb|,3| & \verb|{ Limit:e ...}| \\
(à gauche) & & \verb|SERIES(SQRT(1-COS(X))/X,X=0,-3.0)| & \verb|{ Limit:...}| \\
\hline
\end{tabular}
\end{center}
Notez que~:
\begin{itemize}
\item Les instructions de dérivation et d'intégration ont un équivalent
à un seul argument, respectivement \verb|DERVX| et \verb|INTVX|.
\item L'instruction de développement en séries
{\tt SERIES} renvoie dans une liste la limite, l'équivalent,
le développement en séries en fonction d'un petit paramètre $h$ ainsi que le
reste du développement (en grand $O$ d'une puissance de $h$), la liste
se termine par la définition de $h$ en fonction du paramètre de
départ. 
\item La division en puissances croissantes (\verb|DIVPC|) permet de faire
pas \`a pas des d\'eveloppemets de Taylor.
\end{itemize}

\subsubsection{Matrices}
Rappelons que pour entrer une matrice\index{matrice} 
on utilise l'éditeur de matrices, ou on tape
directement la matrice (délimiteurs \verb|[]|, séparateur \verb|,|).
Les opérations arithmétique \verb|+ - * ^ NEG INV| s'appliquent
aussi aux matrices. Attention à l'usage ambigu de \verb|/|, car le produit
de matrice n'est pas commutatif.
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple ou arguments & R\'esultat \\
\hline
matrice identit\'e\index{identite@identit\'e} & \verb|IDN|\index{IDN}  & \verb|IDN(2)| &
\verb|[[1,0],[0,1]]| \\
matrice constante & \verb|CON|\index{CON} & \verb|CON({2,2},X)| &
\verb|[[X,X],[X,X]]| \\
matrice al\'eatoire\index{aleatoire@al\'eatoire!matrice} &\verb|RANM|\index{RANM} &  \verb|RANM({2,3})| & matrice 2x3 \\
 $M_{i,j}=f(i,j)$ & \verb|LCXM|\index{LCXM} &
\verb|LCXM(2,2,1/(I+J-1)| & \verb|[[1,1/2],[1/2,1/3]]|\\
\hline
accéder élément & \verb|GET|\index{GET} & \verb|GET([[1,4]],{1,2})| & \verb|4| \\
modifier élément & \verb|PUT|\index{PUT} & \verb|PUT([[1,4]],{1,2},3)| 
& \verb|3| \\
\hline
transpos\'ee\index{transpose} & \verb|TRAN|\index{TRAN} & \verb|TRAN([[1,-1],[2,4]])| &
\verb|[[1,2],[-1,4]]| \\
trace\index{trace} & \verb|TRACE|\index{TRACE} & \verb|TRACE([[1,-1],[2,4]])| &
\verb|5| \\
coeff. \verb|*| coeff. & \verb|HADAMARD|\index{HADAMARD} &
\verb|...([[1,3]],[[3,2]])| & \verb|[[3,6]]| \\
\hline
exécuter sur & \verb|MAP|\index{MAP} & \verb|MAP(RANM({3,3}),X MOD 2)|
& matrice 3x3 de coeffs 0 ou 1 \\
\hline
pivot de Gauss\index{pivot} \index{Gauss} &\verb|RREF|\index{RREF} &  \verb|RREF([[1,-1,1],[2,4,1]])|
& \verb|[[1,0,5/6],[0,1,-1/6]]| \\
pivot de Gauss &\verb|rref| &  \verb|rref([[1,-1,1],[2,4,1]])|
& \verb|{...[[6,0,5],[0,6,-1]]}| \\
d\'eterminant\index{determinant@d\'eterminant} & \verb|DET|\index{DET} & \verb|DET(-IDN(3))| & -1 \\
diagonalisation\index{diagonalisation} & \verb|EGV|\index{EGV} & \verb|EGV([[1,-1],[2,4]])| &
\verb|{[[-1,-1],[2,1]],[3,2]}|\\
\hline
\end{tabular}
\end{center}
Notez que \verb|rref| (en minuscules)
n'effectue pas de division par les pivots et renvoie la liste
des pivots, ce qui permet de traiter les cas particuliers
de syst\`emes lin\'eaires lorsqu'il y a des param\`etres sans utiliser
le d\'eterminant. De plus \verb|rref|, \verb|RREF| et \verb|INV|
affichent les étapes intermédiaires du pivot de Gauss en mode pas à
pas lorsque la matrice est à coefficients exacts.

On peut par exemple utiliser les matrices pour coder un
graphe\index{graphe@graphe!orient\'e} (orient\'e ou non). 
On utilise une matrice (symétrique si le graphe est non orient\'e)
ne contenant que des 0 et des 1 (1=arête présente)
Pour en générer une de manière aléatoire,
\begin{center}
\verb|RANM({4,4}) STO> M|\\
\verb|TRAN(M)+M STO> M| (pour graphe non orient\'e) \\
\verb|MAP(M,X MOD 2) STO> M| 
\end{center}
Ensuite par exemple \verb|GET(M^4,{1,2})| donne le nombre
de chaines de longueur 4 reliant le sommet 1 au sommet 2,
\verb|TRACE(M^5)| donne le nombre de cycles de longueur 5.

On peut également étudier une matrice de transition d'un graphe
probabiliste avec la fonction puissance, le produit matriciel
et vérifier la convergence vers l'état propre correspondant
à la valeur propre de norme maximale.
\begin{center}
\verb|[[.7,.2,.1],[.6,.1,.3].[.0,.5,.5]] STO> P| \\
\verb|[.1,.5,.4] STO> V| \\
\verb|TRAN(P)*V STO> V|
\end{center}
on répète plusieurs fois pour observer la convergence de \verb|V| vers
\verb|[.5,.25..25]|, qui est vecteur propre de la transposée de $P$
\verb|EGV(TRAN(P))| correspondant à la valeur propre 1 de module
maximal. On peut aussi calculer $P^n$ pour $n$ assez grand, par
exemple \verb|P^20|.

\subsubsection{Racines\index{racine} de polyn\^omes.}
Rappelons que l'on peut exprimer les racines des polyn\^omes
de degr\'e inf\'erieur ou \'egaux \`a 4 avec des radicaux. Toutefois,
les formules g\'en\'erales en degr\'e 3 et \`a fortiori en degr\'e
4 sont trop complexes \`a manipuler sur une calculatrice.

Sur la HP49, un polyn\^ome dont on cherche les racines par 
la fonction \verb|ZEROS|\index{ZEROS} ou \verb|SOLVE|\index{SOLVE}
est donc d'abord factoris\'e sur $\Z$, puis les racines
des facteurs de degr\'e 1 et 2 sont calcul\'ees (en fonction
du mode complexe). S'il reste des facteurs de degr\'e 3 ou plus, 
la recherche s'arr\^ete, sauf si on est en mode approch\'e ou si on a coch\'e
Num factorize (touche \verb|MODE|, \verb|FLAGS|, fl\'eche vers le haut
jusqu'au num\'ero 109, puis \verb|OK| deux fois).
Ind\'ependamment du mode, la recherche numérique des racines 
complexes d'un polynome se fait avec \verb|PROOT|\index{PROOT}.
La fonction inverse est \verb|PCOEF|\index{PCOEF}.

\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Exemple & Mode & R\'esultat \\
\hline
\verb|ZEROS(X^3-8,X)| & R\'eel & \verb|2| \\
\verb|ZEROS(X^3-8,X)| & Complexe & {\tt \{ $-2\frac{1-i\sqrt{3}}{2},
-2\frac{1+i\sqrt{3}}{2},2$ \} } \\
\verb|ZEROS(X^3+X+1,X)| & R\'eel & \verb|{}| \\
\verb|ZEROS(X^3+X+1,X)| & R\'eel, num factorize & \verb|{-.68...}| \\
\verb|ZEROS(X^3+X+1,X)| & Complexe, num factorize &
\verb|{(.34,-1.16),(.34,1.16),-.68}| \\
\verb|PROOT([1,0,1,1])| & Indiff\'erent &
\verb|[(.34,-1.16),(.34,1.16),-.68]|  \\
\hline
\end{tabular}
\end{center}

\subsubsection{R\'esolution exacte et approch\'ee}
Les solveurs exacts permettent de
\begin{itemize}
\item résoudre des équations\index{equation@\'equation}
 se ramenant à des équations polynomiales
par changement de variable et factorisation (fonction \verb|SOLVE|, 
attention au choix du mode r\'eel/complexe et factorisation num\'erique).
\item résoudre des systèmes d'équations linéaires \index{systeme@syst\`eme}
(fonction \verb|LINSOLVE|), et plus généralement
des systèmes simples d'équations polynomiales par base de Groebner
(fonction \verb|SOLVE|, on peut aussi afficher la base
de Groebner par \verb|GBASIS|, et réduire un polynôme par rapport à une
base de Groebner d'un idéal par \verb|GREDUCE|).
\item certaines équations différentielles \index{equation@\'equation!differentielle}
(par exemple linéaires
du 1er ordre ou linéaires à coefficients constants par transformation
de Laplace et inverse) par appel de \verb|DESOLVE| ou \verb|LDEC| pour
les équations linéaires à coefficients constants, ce dernier
permet aussi de r\'esoudre les systèmes diff\'erentiels
linéaires à coefficients constants.
\end{itemize}


Les solveurs numériques permettent de
\begin{itemize}
\item trouver une solution d'équation non polynomiale dans un intervalle
donné ou en partant d'une valeur initiale (initial guess). Fonction
\verb|ROOT|\index{ROOT} sur les HP49, on peut acc\'eder au menu solveur 
numérique en shiftant la touche 7. N'oubliez pas de purger la variable
apr\'es utilisation.
\item trouver une solution de système d'équations non polynomiales
(fonction \verb|MSLV| sur HP)
\item résoudre numériquement une équation différentielle 
(fonctions
\verb|RKF, RKFERR, RKFSTEP|, il est plus simple 
d'utiliser l'application de repr\'esentation graphique)
\end{itemize}

\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Type & Exemple  & R\'esultat \\
\hline
Exact \'equation &\verb|SOLVE(COS(3*X)-COS(X)=0,X)|\index{SOLVE} & 
{\tt \{ $X=-2\pi n_1$, ... \} } \\
Approch\'e \'equation & \verb|ROOT(COS(X)-X,X,0.0)|\index{ROOT} & \verb|0.739| \\
\hline
Exact syst\`eme poly. & \verb|SOLVE([X^2+Y^2=5,X+Y=3],[X,Y])| & \verb|{[Y=1,X=2],[Y=2,X=1]}|\\
Exact syst\`eme lin. & \verb|LINSOLVE([X+2Y=3,X+Y=2],[X,Y])|\index{LINSOLVE} & 
\verb|{...,[Y=1,X=1]}|\\
Approch\'e syst\`eme &
\verb|MSLV([X^2+EXP(Y)=5,EXP(X)+Y=3],|\index{MSLV} & \\
& \verb|[X,Y],[0,0])| & 
\verb|{...,[.3471,1.5850]}| \\
\hline
$y'+xy=1$ & \verb|DESOLVE(X*d1Y(X)+Y(X)=1,Y(X))|\index{DESOLVE}& \verb|Y(X)=(X+cC0)*1/X|\\
$y'+y=\sin(x)$ & \verb|LDEC(SIN(X),X+1))|\index{LDEC} & $\frac{1+2cC0}{2} e^{-X}
-(\frac{\cos(X)}{2}+...%\frac{-1}{2}\sin(X))
$\\
\hline
\end{tabular}
\end{center}


\subsubsection{Conversions}
Les menus de conversion\index{conversion}
sont accessibles à partir de la touche shift
gauche-6 (CONVERT).

On peut convertir des types d'objets en autres types, mais aussi
des unités d'angle en autres unités d'angles, et plus
générallement une unité physique en une autre unité physique.
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Instruction & HP & Exemple & R\'esultat \\
\hline
Matrice vers liste & \verb|AXL|\index{AXL}& \verb|AXL(IDN(2))| & \verb|{{1,0},{0,1}}|
\\
Liste vers matrice & \verb|AXL| & \verb|AXL({1,0})| & \verb|[1,0]|
\\
\hline
Rendre approch\'e\index{approx} & \verb|->NUM|\index{XNUM} & \verb|->NUM(1/2)| & \verb|0.5| \\
Rendre exact\index{exact} & \verb|XQ|\index{XQ} & \verb|XQ(0.5)| & \verb|1/2| \\
\hline
Vers chaine de caract\`eres & \verb|->STR|\index{STR} & \verb|->STR(1/2)| & \verb|"1/2"|\\
De chaine de caract\`ere & \verb|STR->| & \verb|STR->("1/2")| & \verb|1/2| \\
\hline
Unités d'angles & \verb|CONVERT|\index{CONVERT} &
\verb|CONVERT(3.14_r,1_grad)| & \verb|199.8986_grad|\\
Unités physiques & \verb|CONVERT| &
\verb|CONVERT(20_mph,1_kph)| & \verb|32.1869_kph| \\
Unités de temps & \verb|CONVERT| &
\verb|CONVERT(1_h+20_min+30_s,1_s)| & \verb|4830_s| \\
\hline
\end{tabular}
\end{center}

\subsection{Les listes}\index{liste}
On utilise les \verb|{ }| pour d\'elimiter une liste avec comme
séparateur \verb|,|. 
\begin{enumerate}
\item Attention!!!
Il ne faut pas confondre cette notation  avec la notion d'ensemble en
math\'ematiques : dans un ensemble l'ordre des \'el\'ements n'a pas 
d'importance mais dans une liste l'ordre est important...
\item
\verb|{}| d\'esigne la liste vide et \verb|{1, 2, 3}| 
est une liste de 3 \'el\'ements, \verb|+| 
concat\`ene\index{concatenation@concat\'enation!liste}
deux listes, par exemple~:
\begin{center}
{\tt \{1, 2, 3\}->TAB}\\
{\tt TAB+4 ->TAB} 
\end{center}
Maintenant {\tt TAB} contient \verb|{1,2,3,4}|.\\
De nombreuses fonctions prenant une liste en argument sont
appliqu\'ees \`a chaque \'el\'ement un \`a un. Par exemple~:
\begin{center}
COS(->NUM(TAB))
\end{center}
renvoie la liste des valeurs approch\'ees des
cosinus des 4 \'el\'ements de \verb|TAB|.\\
Remarquez que \verb|+| concat\`ene deux listes même si elles ont la
même longueur, c'est la commande {\tt ADD}) qui permet d'ajouter 
deux listes terme à terme.
\item
On obtient la taille de la liste avec la commande \verb|SIZE|.
On obtient le {\tt P}-i\`eme \'el\'ement de {\tt L } (o\`u \verb|P|
est compris entre 1 et la taille de la liste) en tapant~:
\begin{center}
 {\tt L[P]} ou {\tt L(P)} ou {\tt GET (L,P)}.
\end{center}
\item
Si on veut modifier le {\tt P}i\`eme \'el\'ement de {\tt L} 
(par exemple le mettre \`a 0)  on \'ecrira :
\begin{center}
{\tt PUT(L, P, 0) STO$\triangleright$ L }\\
ou {\tt  PUT('L', P, 0)}
\end{center}
En effet {\tt PUT(L, P, 0)}\index{PUT} renvoie  la liste modifi\'ee 
(sans modifier {\tt L})  alors que {\tt PUT ('L', P, 0) } 
modifie la liste {\tt L}.
\item
La commande {\tt SEQ}\index{SEQ} permet de constituer une liste à partir d'une
formule, par exemple si on tape :
$${\tt SEQ('X*X','X',4,10,1)}$$
on obtient~:
$${\tt \{16,25,36,49,64,81,100\}}$$
\item La commande \verb|SORT(L)| trie une liste \verb|L| 
de valeurs num\'eriques
par ordre croissant, \verb|REVLIST(L)| renverse l'ordre de \verb|L|, 
\verb|SUB(L,2,4)| extrait les termes d'ordre 2 \`a 4, ...
\end{enumerate}

\subsection{Les chaines de caract\`eres}\index{chaine}
Les chaines de caract\`ere utilisent le d\'elimiteur
\verb|"|. Quelques fonctions~:
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple        & R\'esultat \\
\hline
longueur & {\tt SIZE}\index{SIZE} & \verb|SIZE("Bonjour")| & 7 \\
concat\'enation\index{concatenation@concat\'enation!chaine} & {\tt +} & \verb|"12"+"34"| & \verb|"1234"| \\
partie de chaine & {\tt SUB}\index{SUB} & \verb|SUB("12345",2,4)| & \verb|"234"| \\
code ASCII & {\tt CHR}\index{CHR} & $\sum$\verb|LIST(CHR({65,66}))| & \verb|"AB"| \\
code ASCII & {\tt NUM} \index{NUM} & \verb|NUM("ABC")| & 65 \\
\hline
\end{tabular}
\end{center}
Le code ASCII permet de faire des petits programmes de cryptographie
en codant ou en d\'ecodant une liste de nombres provenant d'une
chaine de caract\`eres. Voir la section \ref{sec:ex_prog} pour traduire
une chaine de caractères en liste de codes ASCII.


\subsection{Exercices}
\begin{enumerate}
\item Créez un objet de chaque type en mode ligne de commande, 
stockez-le dans une variable, par exemple \\
\verb|1.1, 12, 1+2i, (0.5,2.3), 1/2, x, x*sin(x)-x, [1,2]|,\\
une matrice al\'eatoire 2 par 2, la liste des objets pr\'ec\'edents.
\item Vérifiez le type de la variable avec \verb|TYPE|
\item Essayez de décomposer l'objet si on peut le faire 
(selon le type d'objet).
\item Testez ce que font les opérations +, inverse, *, /, avec chaque 
type de variable. 
\item Testez l'acc\`es \`a un \'el\'ement d'une liste,
d'un vecteur, d'une matrice.
\item Testez les environnements de saisie 
pour entrer une équation, une matrice.
\item Calculez les int\'egrales (utilisez l'\'editeur
d'\'equation pour les saisir) et simplifiez le r\'esultat:
\[ \int \frac{1}{e^x-1} \ dx, \quad
\int  \frac{1}{x\ln(x)} \ln(\ln(x)) dx, \quad \int (2x^2+1)e^{x^2} \ dx,
\quad \int x\sin(x)e^{x} \ dx \]
V\'erifiez en d\'erivant les expressions obtenues.

\item D\'eterminer la valeur de:
\[\int _1^2\frac{1}{(1+x^2)^3}, \quad  \int _1^2 \frac{1}{x^3+1} \ dx \]

\item Calculer les sommes suivantes
\[\sum_{k=1}^N k,\ \sum_{k=1}^N k^2,\ \sum_{k=1}^\infty \frac{1}{k^2}\]

\item D\'evelopper $\sin(3x)$, lin\'eariser l'expression obtenue
et v\'erifier qu'on retrouve l'expression initiale.

\item Calculer le d\'eveloppement de Taylor en $x=0$ \`a l'ordre 4
de:
\[ \ln(1+x+x^2),\quad
\frac{\exp(\sin(x))-1}{x+x^2} , \quad \sqrt{1+e^{x}}, \quad
\frac{\ln(1+x)}{\exp(x)-\sin(x)} \]

\item R\'esoudre le syst\`eme lin\'eaire
\[ \left\{ \begin{array}{lllllll}
 x &+& y &+& az&=&1\\
 x & +& a y&+& z&=&2 \\
 ax & +&y &+& z&=&3 
\end{array}\right. \]
en utilisant soit l'instruction \verb|rref| sur la matrice
augment\'ee, soit la formule $A^{-1} b$.
\item tester la recherche de racines numérique/exactes
de $x^3+x+1=0$, $\exp(x)+x=3$, $\sin(x)^2-2=0$.
\item Trouver l'intersection du cercle de centre
l'origine, rayon 1 et de l'ellipse d'équation $x^2+2xy+3y^2 +3x-3y=3$.
Résoudre $sin(x)+y=2, x+cos(y)=2$.
\item
Résoudre l'équation différentielle $e^x y'=y+1$, calculer la valeur
de $y$ vérifiant $y'=\sqrt{\sin(y+x)^2+1-\cos(x)}, y(0.0)=1.2$ en
$x=1.0$.
\item Simplifier $\sin(3x)/\sin(x)$
\item Donner la valeur de $5^k \pmod k$ avec $k=10007$.
\item V\'erifier que le polyn\^ome $x^5+x+1$ n'a que des racines
simples et d\'eterminer son nombre de racines r\'eelles. Faire
son tableau de variations.
\item Chercher les extremas locaux de la fonction
$(x+y+1)(x-2y-3)(x-y-1)$
\item Calculer une valeur approch\'ee de $\int_0^{\infty} \exp(-x^2)
 \ dx$ en faisant le changement de variable $x=\tan(t)$.
\item Donner une primitive (\`a coefficients approch\'es) de
  $1/(x^4-3x^3+5x+1)$
\item Calculer le terme d'ordre $n$ du d\'eveloppement de Taylor
en $x=0$ de $1/((x^2-1)(x+2))$. V\'erifiez pour les 5 premiers
termes.
\end{enumerate}

\section{Représentations graphiques: fonction, courbes paramétrées et  équation différentielles.}\index{graphe@graphe!repr\'esentation} 
Les principaux types de graphes (hors statistiques) sont~:
\begin{itemize}
\item les graphes de fonction\index{fonction} (d'une ou deux variables)
\item les courbes paramétrées\index{parametrique@param\'etrique}
\item les courbes en polaire\index{polaire}
\item les solutions (numériques) d'équation différentielles
\index{equation@\'equation!differentielle} du 1er
ordre de la forme $y'=f(x,y)$. Notez qu'on peut toujours résoudre numériquement
ce type d'équation si la fonction $f$ est assez régulière, alors
qu'il n'est quasiment jamais possible d'obtenir une formule
pour $y$ à l'aide des fonctions élémentaires.
\end{itemize}
Lorsqu'on effectue une repr\'esentation graphique,
la calculatrice va échantilloner la (ou les) fonction(s) définissant
la courbe en fonction des paramètres de discrétisation 
(l'\'ecart entre deux \'evaluations successives et les valeurs limites
des param\`etres), puis
tracer les points correspondants et éventuellement les relier
entre eux par de petits segments de droite.

Sur la calculatrice, il faut configurer le type de graphe
à représenter puis indiquer l'équation ou les équations de la courbe 
et les param\`etres. Pour cela,
\begin{enumerate}
\item 
taper simultanément sur shift-gauche et \verb|F4| (2D/3D)
puis choisir le type parmi (Function, Parametric, Polar, Diffeq, 
Slopefield (champ des tangentes)\index{champ des tangentes}, Fast3D\index{3d}),
puis donner l'expression à tracer en fonction de la variable
indépendante et d'éventuelles informations complémentaires en fonction
du type de tracé (pour tracer plusieurs graphes, entrer une liste).
\item
L'expression ou la liste des expressions \`a repr\'esenter doit \^etre
stock\'ee dans la variable \verb|EQ|\index{EQ}. On peut le faire depuis
l'historique ou en tapant sur shift-gauche puis \verb|F1| (Y=)~:
\begin{itemize}
\item Pour les fonctions d'une variable, l'expression \`a entrer est
  $f(X)$, 
\item pour les courbes paramétriques, l'expression
est donnée par le nombre complexe $x(t)+i*y(t)$, attention à changer
le nom de la variable indépendante (en $t$ ici) ou si on garde
\verb|X| \`a exprimer l'abscisse et l'ordonn\'ee en fonction de \verb|X|, 
\item pour les courbes
en polaires, on donne $\rho(X)$ où $X$ est l'angle, 
\item pour les
équations différentielles, on donne $f(X,Y)$ où l'équation
différentielle est $Y'=f(X,Y)$.
\item pour les fonctions de 2 variables, on donne $f(X,Y)$
\end{itemize}
\item
Pour les trac\'es dans le plan, les paramètres H-Tick et V-Tick indiquent
le décalage entre 2 marques (ticks)\index{tick} 
successives sur les axes, donn\'es en pixels
ou en unités (selon que Pixels est coch\'e ou non).
\item Le réglage des paramètres de discrétisation et de la fenêtre
d'affichage se fait en appuyant simultanément sur shift gauche-\verb|F2| (WIN)
puis régler H-Win et W-Win. 
\begin{itemize}
\item
Pour les fonctions, vous pouvez appuyer sur
\verb|AUTO| (autoscale)\index{autoscale} qui calculera W-Win 
(s'il n'y a pas de pole de la fonction dans l'intervalle).
\item
Pour les tracés de type autres que fonction,
il faut définir la plage du paramètre (ou les valeurs
initiales et finales de la variable pour une équation différentielle),
pour les fonctions. Par défaut le calcul est effectué de H-min/xmin à 
H-max/xmax (vous pouvez changer ces valeurs).
\item
Selon le tracé, on indique le pas d'échantillonage, pour une fonction 
(en unités ou en pixels) ou le pas de résolution numérique pour une
équation différentielle. Plus le pas d'échantillonage est petit,
plus le tracé sera précis, mais plus il sera lent.
\item Revenez dans shift-2D/3D et cochez ou d\'ecochez l'option 
Connect\index{connect}.
\end{itemize}
\item
On trace enfin en appuyant
sur \verb|F6| (on efface souvent l'\'ecran graphique au pr\'ealable
par \verb|F5|).
\item Les menus permettent ensuite de changer
les paramètres d'affichage (zoom), mais attention cette opération
prend du temps, car la machine recalcule le graphe.\\
Pour les trac\'e de fonctions, on peut utiliser le menu
\verb|FUNC| pour trouver une racine numérique 
de $f(x)=0$, afficher la tangente au graphe, calculer l'aire sous la
courbe entre deux points,...\\
On peut aussi d\'eplacer le curseur sur l'une des courbes trac\'ees
et regarder la valeur des coordonn\'ees du point, etc.\\
On peut aussi ajouter divers objets g\'eom\'etriques \`a
l'image en allant dans le menu \verb|EDIT| (l'objet graphique affich\'e
est sauvegard\'e dans la variable \verb|PICT|)
\item Pour les fonctions d'une variable, on peut 
afficher un tableau de valeurs de la fonction,
taper sur shift gauche \verb|F5| pour r\'egler la valeur initiale
de $X$ et la valeur du saut, puis shift gauche \verb|F6| pour
afficher le tableau, les fl\`eches vers le haut et vers le bas
permettent de changer la valeur initiale.
\end{enumerate}

{\bf Remarques}
\begin{itemize}
\item Il est possible pour les fonctions et les courbes
paramétrées de tracer simultanément plusieurs
courbes sur le même graphe. Il suffit de mettre dans \verb|EQ| une liste
d'expressions.
Par exemple, pour tracer plusieurs courbes d\'ependant d'un param\'etre,
on peut utiliser dans l'historique la commande \verb|SUBST|, ainsi\\
\verb|SUBST(A*SIN(X),A={1,2,3}) STO> EQ|\\
permettra de tracer les courbes $a \sin(x)$ pour $a=1,2,3$.
\item Parallèlement à l'étude graphique, on peut bien sur utiliser l'historique
 pour faire une étude formelle de la fonction
à tracer. Il est alors judicieux de donner un nom à la fonction
ou à l'expression étudiée (par l'intermédiaire de define ou de STO).
Par exemple, on pourra pour une fonction d'une variable utiliser
la fonction \verb|DERIV| et \verb|SOLVE| pour rechercher les
extremums, pour
une fonction de plusieurs variables, on utilisera
\verb|DERIV| (qui calcule le gradient, qui est normal au plan
tangent en un point de la surface en 3-d), \verb|HESS|, \verb|GAUSS| 
(qui donne la signature de la forme quadratique en un point critique).
\item On peut lancer un trac\'e de fonction depuis l'historique
par la commande \verb|PLOTADD| (on peut aussi utiliser les
commandes de type de trac\'e \verb|FUNCTION|, \verb|PARAMETRIC|, ...
et l'affectation de \verb|EQ|).
\end{itemize}

Exercices~:
\begin{itemize}
\item Représenter la fonction $f(x)=(x^3+x+1)/(x^2-x-1)$ pour
$x \in [-2,0]$ puis $x\in [-3,3]$ puis $x\in [-10,10]$.
Trouver numériquement une solution de $f(x)=0$.
En utilisant l'application main, faites une étude de la fonction
(tableau de variations, asymptotes, signe) et vérifiez sur le
graphe.
\item Tracer sur le même graphique les fonctions $\sin(x)$
et son développement de Taylor à l'ordre 1, 3 et 5. Graphiquement,
pour quelles plages de valeurs de $x$ les développements
sont-ils de bonnes approximations de $\sin(x)$?
\item Tracer en paramétriques la courbe d'équations
\[ x(t)=3 \sin(3t), \quad y(t)=2 \sin(4t) \]
Pour les matheux, faites aussi l'étude des auto-croisements de la courbe.
\item Tracer en polaire la courbe $\rho=2 \cos(4\theta)$.
Quelques autres courbes si vous avez le temps~:\\
lemniscate de Bernouilli~:$\rho=\sqrt{\cos(2t)}$\\
limacon de Pascal~:$\rho=a\cos(t)+b$, si $a=b$, cardioide\\
ellipse (demi-grand axe $a$, excentricit\'e $e$): $\rho=a(1-e^2)/(1+e\cos(t))$.
\item On considère l'équation différentielle logistique
(utilisée pour modéliser la croissance d'une population dans un 
milieu aux ressources naturelles finies)~:
\[ y'= y(1-y), \quad y(t=0)=0.01 \]
Tracer la courbe représentative de cette solution (sans résoudre
l'équation différentielle!). Comparez ensuite avec le tracé de la solution
exacte (obtenue avec DESOLVE).
\item Tracer tout d'abord le champ des tangentes de l'équation
différentielles
\[ y'=\sin(xy) \]
puis superposer quelques solutions de l'équation 
(sans effacer le champ des tangentes).
\end{itemize}


\section{Calculs financiers}\index{financier}
L'application Time Value of Money permet principalement 
de calculer des mensualités
de remboursement pour un emprunt à taux $t$ et remboursement $r$ fixes.
Les mathématiques sous-jacentes sont les suites géométriques.
Si $u_k$ est la valeur empruntée l'année $k$, la valeur de $u_{k+1}$
s'obtient en enlevant le remboursement $r$ et en ajoutant les intérêts
sur $u_k$
\[ u_{k+1}= u_k(1+t) -r \]
Il s'agit alors de trouver l'une des valeurs $n$, $r$, $t$ ou $u_0$ 
pour que $u_n=0$. Pour cela on calcule $u_k$, en cherchant $C$
pour que $v_k=u_k-C$ soit une suite géométrique de raison $1+t$~:
\[ v_{k+1}=u_{k+1}-C=u_k(1+t)-r-C=(v_k+C)(1+t)-r-C=(1+t)v_k+tC-r\]
Donc $C=r/t$, et $v_k=(1+t)^n v_0$ d'où~:
\[ v_n=u_n-C=-C=(1+t)^n v_0=(1+t)^n (u_0-C) \] 
finalement~:
\[ (1+t)^n=\frac{-C}{u_0-C}=\frac{r}{r-u_0 t} \]

Sur HP, taper shift gauche-\verb|FINANCE|. Remplir les champs sauf celui
cherch\'e et taper sur le menu \verb|SOLVE|. Par exemple
pour un emprunt de 10000 euros \`a 3\% sur 5 ans, on remplira 60
mensualit\'es (\verb|N|), le taux \`a droite, puis -10000 pour
\verb|PV|, 0 pour \verb|FV|, on d\'eplace le curseur sur \verb|FMT|
et on tape sur \verb|SOLVE|.

Exercices~:
\begin{itemize}
\item 
Il s'agit d'emprunter 150 000 euros au taux fixe de 4\% par an.
Combien de temps faut-il pour rembourser cette somme à raison
de 1000 euros par mois?
\item Mêmes données, quelle mensualité faut-il payer pour rembouser en 15 ans?
\item Combien coute un ordinateur payé pendant 3 ans 1 euro par jour
en supposant une inflation annuelle à 2.5\%?
\end{itemize}

\section{Statistiques descriptives}\index{statistiques}
Les calculs statistiques utilisent une variable r\'eserv\'ee 
{\tt $\Sigma$DAT} qui est la matrice statistique\index{matrice statistique}.
On peut utiliser l'\'editeur de matrice pour entrer les donn\'ees,
l'appui sur shift 5 (STATS) stocke la matrice dans la variable
{\tt $\Sigma$DAT} et ouvre le menu de statistiques.
On peut aussi entrer une matrice directement depuis l'historique
avec \verb|STO>|.

\subsection{Statistiques \`a une variable.}
Taper shift-5 (STATS), et choisir Single Var. Cochez ensuite les fonctions
que vous voulez calculer et le type de statistiques (population
enti\`ere ou \'echantillon, ce qui change la formule de la variance).
Pour des statistiques avec fr\'equence il faut installer une librairie
de statistiques comme Stat49Pro (disponible sur
\verb|www.hpcalc.org|).

Les calculs statistiques peuvent aussi \^etre effectu\'es en ligne
de commande depuis l'historique. Supposons par exemple que l'on
a entr\'e la matrice (dans l'historique ou dans l'\'editeur de matrice)~:
\begin{center}
{\tt TRAN([[13,18,14,16,12,13]]) STO> $\sum$DAT}
\end{center}
Voici la liste des commandes~:
\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Description & Fonction    & R\'esultat sur l'exemple \\
\hline
Moyenne\index{moyenne} & \verb|MEAN|\index{MEAN} & \verb|14.3333| \\
Maximum\index{maximum} & {\tt MAX$\sum$} & \verb|18.| \\
Minimum\index{minimum} & {\tt MIN$\sum$} & \verb|12.| \\
\'Ecart type (\'echantillon)\index{ecart@\'ecart type} & \verb|SDEV| & \verb|2.2509| \\
Variance (\'echantillon)\index{variance} & \verb|VAR| & \verb|5.0667| \\
\'Ecart type (population) & \verb|PSDEV| & \verb|2.0548| \\
Variance (population) & \verb|PVAR| & \verb|4.2222| \\
Total & \verb|TOT| & \verb|86.| \\
\hline
\end{tabular}
\end{center}
Notez que~:
\begin{itemize}
\item \verb|SDEV| et \verb|VAR| s'appliquent \`a un \'echantillon
et non \`a une population (\verb|PSDEV| et \verb|PVAR|), 
on divise la somme des carr\'es des
\'ecarts \`a la moyenne par $n-1$ o\`u $n$ est l'effectif.
\item Il n'y a pas de fonction pr\'eprogramm\'ee pour calculer
les quantiles\index{quantile}. On pourra utiliser 
\begin{center}
\verb|AXL(TRAN(|$\sum$\verb|DAT)) STO> L|
\end{center}
pour convertir en liste la matrice statistique, puis
\begin{center}
\verb|SORT(L[1]) STO> L1|\index{SORT}
\end{center}
pour trier\index{tri} par ordre croissant la première ligne de \verb|L| (donc
la première colonne de la matrice statistiques), on obtient alors
le premier quartile\index{quartile} (par exemple) en tapant
\begin{center}
\verb|L1[SIZE(L1)/4]|
\end{center}
Pour la m\'ediane\index{mediane@m\'ediane}
\begin{center}
\verb|L1[SIZE(L1)/2]|
\end{center}
\end{itemize}

On peut repr\'esenter graphiquement les donn\'ees par un
{\bf histogramme des effectifs}\index{histogramme}~: touche shift-2d/3d
choisir Histogram comme type, r\'egler dans \verb|WIN|,
horizontalement les valeurs extremes prises par la s\'erie
statistique,
verticalement entre 0 et l'effectif maximal d'une classe,
ainsi que la largeur d'une classe (dans l'exemple
ci-dessus, on pourrait par exemple prendre H-View entre 0 et 20,
V-View entre 0 et 5 et Bar Width 3).


\subsection{Statistiques \`a 2 variables, mod\`eles de r\'egression.}
On utilise cette fois 2 colonnes de la matrice de donn\'ees 
$\sum$\verb|DAT|.
On peut effectuer le calcul de la corr\'elation, de la covariance,
des {\bf r\'egressions}\index{regression@r\'egression} 
de divers types (lin\'eaire,
exponentielle, logarithmique, puissance). Comme ci-dessus, on utilise
l'application statistiques (shift-5 puis Fit) ou on tape directement les
commandes dans l'historique. Par exemple si on a entr\'e dans
{\tt $\Sigma$DAT}
\begin{center}
[[1,3],[3,5],[4,8],[6,11],[7,13],[8,13]]
\end{center}
\begin{center}
\begin{tabular}{|l|l|l|}
\hline
Description & Fonction    & R\'esultat sur l'exemple \\
\hline
Corr\'elation\index{correlation@corr\'elation} & \verb|CORR|\index{CORR} & 0.9857\\
Covariance\index{covariance@covariance} & \verb|COV|\index{COV} & 10.967\\
Choix r\'egression lin\'eaire & \verb|LINFIT| & NOVAL \\
Choix r\'egression logarithmique & \verb|LOGFIT| & NOVAL \\
Choix r\'egression exponentielle & \verb|EXPFIT| & NOVAL \\
Choix r\'egression puissance & \verb|POWFIT| & NOVAL \\
R\'egression & \verb|LR|\index{LR} (lin\'eaire) & \verb|{1.2238,1.5741}| \\
Meilleure des 4 & \verb|BESTFIT| &  \\
Pr\'ediction de $y$ & \verb|PREDY(5)| (lin\'eaire) & \verb|9.0957| \\
Pr\'ediction de $x$ & \verb|PREDX(14)| & \verb|8.1155|\\
\hline
\end{tabular}
\end{center}

On peut repr\'esenter
graphiquement les donn\'ees par un nuage de points (choisir
Scatterplot dans le champ type de 2D/3D)\index{scatterplot}. Le graphe
de la droite de r\'egression s'obtient en tapant sur le menu 
\verb|STATL| du bandeau.


\subsection{Fonctions de probalit\'e, statistiques et d\'enombrement.}
\begin{center}
\begin{tabular}{|l|l|l|l|}
\hline
Description & Fonction    & Exemple  & R\'esultat \\
\hline
Factorielle\index{factorielle} & \verb|FACT|\index{FACT} &
\verb|FACT(5)| & 120 \\
Nombre de combinaisons\index{combinaisons} & \verb|COMB|\index{COMB} &\verb|COMB(13,5)|&\verb|1287|\\
Nombre de permutations\index{permutations} & \verb|PERM|\index{PERM} & \verb|PERM(13,5)| &
\verb|154400|\\
\hline
R\'eel al\'eatoire\index{aleatoire@al\'eatoire!r\'eel} $\in [0,1]$ & \verb|RAND|\index{RAND} & \verb|RAND| &
al\'eatoire \\
Initialise \verb|RAND|\index{aleatoire@al\'eatoire!initaliser} &  \verb|RDZ|\index{RDZ} &  \verb|RDZ(0.3)| & \verb|NOVAL|
\\
\hline
\end{tabular}
\end{center}
Notez que \verb|RAND| renvoie un nombre pseudo-al\'eatoire 
compris entre 0 et 1, distribu\'e selon la loi uniforme et que
\verb|RDZ(R)| initialise le g\'en\'erateur al\'eatoire (\verb|R|
est un nombre r\'eel, si \verb|R| est nul, 
l'horloge syst\`eme est utilis\'ee).

Les fonctions
\verb|UTPC|, \verb|UTPF|, \verb|UTPN|, \verb|UTPT|
renvoient la probabilit\'e qu'une variable al\'eatoire
soit sup\'erieure \`a leur dernier argument
si la variable al\'eatoire suit respectivement
la loi\index{loi} du {\bf Chi 2}\index{chi2}, de {\bf
  Snedecor}\index{Snedecor} F, 
la loi {\bf normale}\index{loi@loi!normale} ou la loi de
{\bf Student}\index{Student}. Les premiers arguments de ces fonctions
sont respectivement nombre de degr\'es de libert\'e, 
nombre de degr\'es de libert\'e au num\'erateur et au d\'enominateur,
moyenne et variance, nombre de degr\'es de libert\'e.
Ces fonctions (et leurs inverses) sont utilis\'es en particulier
pour les statistiques inf\'erentielles (cf. infra).

\section{Statistiques inférentielles}\index{statistiques@statistiques!inferentielles}
L'exploitation de donn\'ees peut prendre plusieurs formes :
\begin{enumerate}
\item
L'inf\'erence statistique ou "th\'eorie de l'estimation" : connaissant un 
\'echantillon, on d\'esire \'emettre une estimation sur la population totale.
Dans ce cas, on n'a pas d'id\'ee a priori sur le param\`etre \`a estimer : 
on construira {\bf un intervalle de confiance  $I_\alpha$ au seuil $\alpha$}.
Cet intervalle $I_\alpha$ d\'epend de l'\'echantillon et contient, en 
g\'en\'eral, la valeur du param\`etre sauf dans $\alpha \%$ des cas c'est \`a
dire, il y a 
seulement $\alpha \%$ des \'echantillons qui ont un $I_\alpha$ qui ne contient
pas le param\`etre (on dit qu'on a un risque d'erreur \'egal \`a $\alpha$).
\item
Le test d'hypoth\`eses permet de savoir si il y a accord entre th\'eorie et
exp\'erience.
Dans ce cas on a une id\'ee a priori sur la valeur que doit avoir le
param\`etre : on construit le test d'hypoth\`eses (deux hypoth\`eses $H_0$ et 
$H_1$ seront en concurrence), puis on pr\'el\`eve un 
\'echantillon et on regarde si cet \'echantillon v\'erifie le test ce qui 
permet d'accepter ou de refuser l'hypoth\`ese privil\'egi\'ee $H_0$.\\
Par exemple : on veut contr\^oler qu'une fabrication correspond 
bien \`a ce qui a \'et\'e d\'ecid\'e, pour cela on fabrique un test
d'hypoth\`eses, puis on teste l'hypoth\`ese $H_0$ sur un \'echantillon de la 
production.
\item
Le test d'homog\'en\'eite permet de comparer une distribution
exp\'erimentale \`a une distribution th\'eorique.
Dans les deux cas précédents, on a seulement comparé ou estimé des valeurs 
caract\'eristiques comme fr\'equences ou moyennes, Ici on compare deux 
distributions.
\end{enumerate}
Pour des échantillons assez grands, le théorème qui permet de faire
ces estimations est la loi des grands nombres. Ainsi, si on calcule
la moyenne $X$ d'un échantillon de $n$ variables aléatoires indépendantes
de même loi (de moyenne $\mu$ et d'écart-type $\sigma$), 
la loi de $\overline{X}$ tend
lorsque $n$ tend vers l'infini vers une loi normale de moyenne $\mu$
et d'écart-type $\sigma/\sqrt{n}$. 
Si $n$ n'est pas assez grand (typiquement $n\leq 30$), 
on peut encore faire ce type de statistiques
inférentielles si on sait par ailleurs que la loi commune
des variables aléatoires de la population est une loi normale.

Sur la HP, certaines fonctions sont en ROM, pour des fonctions 
compl\'ementaires, il faut installer l'application Stat Pro 49.

\subsection{Estimation d'une moyenne}
Supposons par exemple qu'on veuille calculer la moyenne de la population
au vu d'un grand échantillon et qu'on cherche par exemple
un intervalle de confiance centré à 5\% sur la moyenne $\mu$ de la population.
On connait la moyenne $m$ de l'échantillon
qui est la valeur d'une variable aléatoire $X$ qu'on suppose suivre
une loi normale de moyenne $\mu$ et écart-type $\sigma$ (c'est
asymptotiquement le cas lorsque $n$ tend vers l'infini). 
Si on ne connait pas $\sigma$,
lorsque l'échantillon est assez grand, on peut estimer $\sigma$
à partir de l'écart-type de l'échantillon (qui est l\'ecart-type de la 
population multipli\'e par $\sqrt{n/(n-1)}$, fonction \verb|SDEV| sur la 49).
On cherche ensuite la distance $C$ telle que
la probabilité que $|m-\mu|>C\sigma$ soit de 5\%. Comme la loi de $X$ est
la loi normale, cela revient à calculer pour quelle valeur de $C$
on a l'équation
\[ (\int_{-\infty}^{-C} + \int_C^{+\infty})   e^{-\frac{t^2}{2}} = 0.05 
\int_{-\infty}^{+\infty} e^{-\frac{t^2}{2}} \]
calcul li\'e \`a celui de la fonction \verb|UTPN| de la HP
\[ UTPN(m,v,x)= \frac{1}{\sqrt{2 \pi v}} \int_x^{\infty} 
\exp(-\frac{(t-m)^2}{2v}) \ dt \]

Si l'échantillon est trop petit (typiquement
$n<30$) et si la loi suivie est normale, 
on utilise une autre statistique car
l'estimation de l'écart-type de la population par $\sigma \sqrt{n/(n-1)}$
n'est plus valide. On montre que
la variable aléatoire
\[ T= \frac{\overline{X}-\mu}{\frac{1}{\sqrt{n(n-1)}} \sqrt{\sum_{j=1}^n (X_j-\overline{X})^2}}\]
suit la loi de Student $S(n-1,x)$ à $n-1$ degrés de liberté~:
\[
S(n,x)=\frac{\Gamma\left(\frac{n+1}{2}\right)}{\Gamma\left(\frac{n}{2}\right)
\sqrt{n\* \pi }} 
(1+\frac{x^{2}}{n})^{-\frac{n+1}{2}}, \quad \mbox{ où } \Gamma(x)=(x-1)!
\]
N.B.: l'abr\'eviation de cette loi est T et non S (par exemple
\verb|UTPT| sur HP49).

Sur les HP49, on peut calculer des intervalles de confiance
et faire des tests d'hypothèses sur la moyenne
d'une population ou de l'égalité de moyenne de 2 populations pour
des échantillons grands,
on utilise Z si l'écart-type est connu, et T s'il est estimé.
Tapez sur shift droit-STATS puis 6 ou 5, puis
choisissez le type de test/distribution. Tapez sur HELP pour plus de 
détails sur le test effectué.

Pour faire des statistiques sur de petits échantillons suivant la loi
normale, il faut poser soi-même les calculs, en s'aidant de la fonction
\verb|UTPT|, dont le permier argument est le nombre de degré de liberté et
le deuxième $x$, par exemple pour résoudre \verb|UTPT|$(n-1,x)$=0.025 
pour $n=8$ on tape 
\begin{center}\verb|ROOT('UTPT(7,X)-0.025',X,0.0)|
\end{center} 
en faisant de m\^eme en 0.975 on obtient un intervalle de 
confiance centré à 5\%.


{\bf Exercice~:}\\
On a effectu\'e 10 pes\'ees ind\'ependantes sur une balance d'une m\^eme masse 
$\mu$ et on a obtenu :
\begin{center}
\verb|10.008,10.012,9.990,9.998,9.995,10.001,9.996,9.989,10.000,10.015|
\end{center}
On suppose que la pesée est une variable aléatoire suivant la loi normale.
On cherche \`a d\'eterminer la masse $\mu$ au vu de l'\'echantillon.
Tester l'hypothèse $H_0$ : $\mu=10$ contre $H_1$ :  $\mu>10$ au  seuil de 5\%.
Même question pour $H_1$ :  $\mu \neq 10$.
Calculer un intervalle de confiance pour $\mu$ à 5\%.

\subsection{Estimation d'un écart type}
Lorsque la population suit une loi normale,
on peut aussi estimer l'écart-type à partir d'un échantillon et
en calculer un intervalle de confiance, en utilisant la distribution
du $\chi^2$. On pose 
\[ Z^2=\frac{1}{n}\sum_{k=1}^n(X_k-\mu)^2 \]
On peut montrer que $n Z^2/\sigma^2$ suit une loi du $\chi^2$ 
ayant $n$ degr\'es de libert\'e.

Sur les HP49, les calculs se font à la main, en s'aidant
de la fonction \verb|UTPC|, qui donne la probabilité qu'une variable
aléatoire suivant la loi du $\chi^2$ à $n$ degrés de liberté
soit plus grande que le 2ème argument de \verb|UTPC|.

{\bf Exercice~:}\\
On reprend les mêmes données que ci-dessus, mais
on suppose que $\mu=10$ est connu et on veut calculer un intervalle
de confiance à 5\% près sur la précision de la balance.\\
Calculer la valeur $z^2$ ($n=10$) de $Z^2$ 
pour l'échantillon (on trouve environ 0.00007).\\
Pour $\sigma$ donné, on calcule $a=n z^2/\sigma^2$ et on regarde la probabilité
que $nZ^2/\sigma^2$ (qui suit la loi du $\chi^2$ à $n$ degrés
de liberté) soit plus grand que $a$, en calculant \verb|UTPC|$(10,a)$. On
dira qu'on a un intervalle de confiance à 5\% sur $\sigma$ si
\verb|UTPC|$(10,a)$ du $a$ correspondant 
est compris entre 0.975 et 0.025.
On cherche donc les valeurs de $\sigma$ qui correspondent à un \verb|UTPC| de 
0.975 et 0.025.
On calcule $a_1$ et $a_2$ par exemple avec la fonction de recherche
numérique de solutions de la calculatrice.
On en déduit les valeurs $\sigma_1$ et $\sigma_2$
de l'intervalle de confiance à 5\% de $\sigma$.


\section{Tableur}\index{tableur}
Notez que sur une calculatrice, l'exécution d'un tableur non trivial
est très lente, il n'est donc pas recalcul\'e automatiquement
par d\'efaut. Cette application permet n\'eanmoins de manipuler
les m\^emes notions qu'un tableur sur un ordinateur.
Pour lancer le tableur, taper la touche \verb|APPS| 
puis \verb|Spreadsheet|.

La syntaxe est proche de celle des tableurs sur micro-ordinateur.
\begin{itemize}
\item Nom de cellule\index{cellule}.\\
Le tableur est une matrice dont on numérote les lignes par des nombre
et les colonnes par une ou plusieurs lettres. 
Le nom d'une cellule est composé d'abord
de la (des) lettre(s) (donc du numéro de colonne) puis du nombre.
Par exemple ligne 2, colonne 3 se note \verb|C2|.
\item Valeur et formule de calcul.\\
La valeur d'une cellule peut être une constante ou être calculée par une 
formule pouvant faire
intervenir les autres cellules, qui sont alors désignées par une
référence (cf. ci-dessous). Lorsqu'on modifie une cellule,
on entre soit une valeur constante, soit une formule de calcul.
On valide par \verb|ENTER|, la formule ou la valeur est alors
affich\'ee mais le tableur n'est pas recalcul\'e automatiquement.
Pour le recalculer une fois, on tape sur shift-\verb|EQW|
(\verb|MTRW|). On peut passer en mode de recalcul automatique
en tapant sur le menu \verb|EVAL| du bandeau 
(\verb|TOOL NXT NXT NTX F2|).
\item Référence relative et absolue.\\
Lorsqu'on désigne une cellule depuis une formule, on peut la désigner
relativement à la cellule dont on définit la formule de calcul, ou
de manière absolue. Cela affecte les copies de la formule dans d'autres
cellules, les références absolues copiées correspondront au même
numéro de ligne/colonne, alors que les références relatives correspondent
au même décalage de lignes/colonnes. Une référence absolue se note
en précédant la (les) lettres ou/et le nombre de la cellule par le signe \$.
\item  Plage de cellules.\index{plage@plage!cellule}\\
Cela permet de faire référence à un ensemble rectangulaire de cellules,
par exemple pour en calculer la moyenne... On indique les noms
de cellule du bord du rectangle s\'epar\'es par le signe
{\tt .}\ . \\
Vous pouvez utiliser les menus pour calculer la somme, 
la moyenne, l'\'ecart-type, etc. Vous pouvez aussi
utiliser la fonction \verb|SIGMA| dont le premier argument
est une plage de cellules et le deuxi\`eme argument soit un entier
(0 pour la somme, 1 pour la moyenne, 2 pour la variance), soit
un test (par exemple \verb|X==2| pour compter le nombre de 2 d'une
plage).\\
Par exemple, pour calculer la moyenne des cellules de \verb|A1| \`a
\verb|B2| en \verb|C1|, on se place en \verb|C1|, on tape 
\verb|TOOL NXT| jusqu'\`a ce que \verb|mean| apparaisse, on tape
sur \verb|F4 (mean)|, il apparait \verb|'SIGMA(,1)'|,
on d\'eplace le curseur avant la virgule et on saisit \verb|A1.B2|.\\
Attention, si vous \'editez une formule 
contenant \verb|SIGMA|, veillez a bien encadrer votre formule
par des signes \verb|'| (qui n'y sont plus). Le deuxi\`eme param\`etre
de \verb|SIGMA| peut \^etre 1 pour la moyenne, 2 pour l'\'ecart-type
(population), 0 pour la somme.
\item Pour sauver une feuille de calcul, appuyez sur la touche
\verb|STO|. Pour charger une feuille de calcul, appuyez sur
shift gauche-\verb|STO| (\verb|RCL|). Pour envoyer une feuille vers
l'application statistiques, taper sur shift gauche-5 (STATS), vers
le graphique (histogramme), taper sur shift droit-5.
\end{itemize}

Montrons encore comment utiliser le tableur pour calculer les premiers
termes d'une suite récurrente.
Par exemple, soit la suite d\'efinie par~:
\[ u_{n+1}=f(u_n), \quad f(x)=1/2(1+2/x), u_1=2\]
On d\'efinit la fonction dans l'historique
\begin{center}
\verb|DEFINE F(X)=1/2*(1+2/X)|
\end{center}
On tape sur la touche \verb|APPS|, puis \verb|Spreadsheet|.
On met la valeur initiale $u_1=2$ dans la
cellule \verb|A1|, puis on définit \verb|A2| par la formule de
récurrence \verb|F(A1)|, on sélectionne la cellule
avec shift droit-BEGIN, shift droit-END, shift droit-COPY, et on la recopie
sur quelques cellules vers le bas.
Si on remplace \verb|A1| par \verb|2.0|, on obtient des valeurs
approch\'ees.

{\bf Exercices:} 
\begin{itemize}
\item Créez une feuille de calcul pour calculer une moyenne
de semestre LMD avec 4 modules à 6 ECTS et 2 modules à 3 ECTS.
\item
Créer une feuille de calcul pour entrer 3 notes de devoir pour 6
personnes, et faites les moyennes par personne et par devoir.
\item
Cr\'eez une feuille de calcul permettant de visualiser
quelques \'etapes de l'algorithme d'Euclide de calcul de PGCD. De
m\^eme pour B\'ezout.
\end{itemize}

\section{Suites numériques récurrentes}\index{suite}
On peut utiliser le tableur (cf. section pr\'ec\'edente)
mais on peut aussi calculer une suite dans l'historique, par exemple~:
\begin{center}
\verb|DEFINE F(X)=1/2*(1+2/X)| \\
\verb|DEFINE(U(N)=IFTE(N>1,F(U(N-1)),2)|
\end{center}
{\bf Remarques}~:
\begin{itemize}
\item Ceci permet le calcul exact des termes de la suite. Le calcul
approché est la plupart du temps plus parlant (remplacer \verb|2|
par \verb|2.0| ci-dessus), mais parfois
les deux calculs sont intéressants. 
\item Pour les récurrences à plus de 1 terme, ce type de formule est très
inefficace, car on calculerait plusieurs fois le même terme. Il faut alors
écrire un petit programme ou utiliser le tableur.
\end{itemize}

Le graphe d'une suite récurrente définie par $u_{n+1}=f(u_n)$ (en toile
d'araignée\index{araignee@araign\'ee!graphe en toile}) se trace 
\`a partir de l'application
de g\'eom\'etrie, avec la commande \verb|plot|.
Par exemple ici, on tape \verb|APPS| puis \verb|Geometrie|,
puis \verb|Fich->Nouveau|, puis \verb|Ajouter->Courbe->plot|,
puis on trace le graphe de la fonction $f$ \verb|plot(1/2*(1+2/X))|,
puis à nouveau \verb|Ajouter->Courbe->plot|, et on trace
les trois premiers termes de la suite \verb|plot({1/2*(1+2/X),2.0,3})|.

Exercices~:
\begin{itemize}
\item Méthode de Newton pour résoudre l'équation $f(x)=0$
\[ u_{n+1}=u_n-\frac{f(u_n)}{f'(u_n)}\]
\item Suite de Fibonacci
\[ u_{n+2}=u_n+u_{n+1}\]
\end{itemize}


\section{Programmation}\index{programmation}
L'essentiel de cette section est tir\'e d'un texte \'ecrit par 
Ren\'ee De Graeve qui traite de nombreuses autres calculatrices
\verb|http://www-fourier.ujf-grenoble.fr/~degraeve/grouge.ltx|

\subsection{Edition, correction, ex\'ecution}
\subsubsection{Comment \'editer et sauver un programme}
Un programme s'\'ecrit dans la ligne de commande entre les d\'elimiteurs ${\tt \ll \; \gg}$\\ 
Pour le  sauver, il suffit de faire suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOMDUPROGRAMME}$$

\subsubsection{Comment corriger un programme} 
Si la syntaxe est mauvaise, la machine vous met automatiquement le curseur l\`a
o\`u le compilateur a d\'etect\'e l'erreur. Il suffit donc de corriger!!!\\
Si l'erreur est d\'etect\'ee au cours de l'ex\'ecution du programme 
il faut taper :
\begin{center}
{\tt VISIT('NOMDUPROGRAMME')}
\end{center}
qui \'edite votre programme.
On corrige, puis  {\tt ENTER}  sauve votre programme corrig\'e. 


\subsubsection{Comment ex\'ecuter un programme}
Si le programme n'a pas de param\`etres, il suffit de taper son nom 
dans la ligne de commande ou d'utiliser le menu {\tt VAR}.
S'il y a des param\`etres, on fait suivre le nom du programme de parenth\`eses
dans lesquelles on met  les valeurs des param\`etres s\'epar\'ees 
par une virgule. Par exemple~:
\begin{center}
{\tt PGCD(45,75)}
\end{center}

\subsubsection{Comment am\'eliorer puis  sauver sous un autre nom 
un programme}
On tape {\tt RCL('NOMDUPROGRAMME')} puis {\tt EDIT} du bandeau.
On fait les am\'eliorations et on fait suivre le dernier $\gg$ par :
 $${\tt STO\triangleright \ NOUVEAUNOM}$$


\subsection{Les diff\'erentes instructions}
\subsubsection{Les commentaires}
Il faut prendre l'habitude de commenter les programmes. 
En algorithmique un commentaire commence par 
{\tt // } et se termine par un passage \`a la ligne.
Pour la {\tt HP49G}, on écrira simplement le commentaire
dans une chaine de caractères suivi par  \verb|;|. On peut aussi 
saisir une ligne commençant par {\tt @} et se terminant par un 
passage \`a la ligne ou une chaine entour\'ee de deux {\tt @}.
(le caract\`ere {\tt @} est
obtenu en tapant {\tt shift-rouge ENTER})
mais le compilateur efface les commentaires... donc pour garder ce type 
commentaires, il faut \'ecrire votre programme sous la forme d'un texte qu'il 
faut ensuite compiler avec ${\tt STR\rightarrow}$ ce qui complique un peu...

\subsubsection{Les variables}
Ce sont les endroits o\`u l'on peut stocker des valeurs, des nombres, 
des expressions. Les noms des variables sont libres. On distingue
les variables globales (définies dans l'historique) et les
variables locales (définies seulement à l'intérieur d'un programme).

Les  variables locales\index{variable@variable!locale}
 sont d\'eclar\'ees et initialis\'ees une par
une (initialisation obligatoire!) 
gr\^ace \`a \  ${\tt \ \rightarrow}$ {\tt (shift-rouge 0)}.
Chaque d\'eclaration 
doit \^etre suivie par un sous programme (d\'elimiteurs ${\tt \ll
  \gg}$) en \'ecrivant~:
\begin{center}
$${\tt \ll 1\ \rightarrow\  A \ll 2\ \rightarrow\ B \ll corps\ du\
  programme \gg \gg \gg}$$
\end{center}
La fl\`eche doit \^etre entour\'ee d'espaces, ces espaces sont mis
automatiquement quand on n'est pas en mode {\tt Alpha}. Par exemple~:
\begin{center}
$${\tt \ll   3.14\  \rightarrow\  PI \ll 2*PI*R \gg \gg
  STO\triangleright \  PER}$$
\end{center}
Dans cet exemple, on a \'ecrit le programme {\tt PER},
{\tt PI} est une variable locale qui est d\'eclar\'ee et
affect\'ee par ${\tt 3.14 \ \rightarrow \ PI} $. Cette variable est 
locale pour le 
programme qui suit sa d\'eclaration (ici ${\tt \ll 2*PI*R \gg}$).
Par contre, {\tt R} est une variable globale (qui doit exister avant
l'ex\'ecution du programme  {\tt PER}). Si, au cours d'un programme, on veut 
stocker une valeur dans une variable (locale ou globale) il faut bien
s\^ur utiliser ${\tt STO\triangleright}$.

Pour d\'eclarer plusieurs variables locales en une seule fois, on peut aussi
utiliser le couple d'instructions {\tt LOCAL} et {\tt UNBIND}.

\subsubsection{Notion de param\`etres}\index{parametre@param\`etre}
Quand on \'ecrit une fonction il est possible d'utiliser des
param\`etres, comme pour les fonctions internes de la 49.
Par exemple si {\tt A} et {\tt B} sont les param\`etres de la 
fonction {\tt PGCD}  on appellera {\tt PGCD} en tapant dans
l'historique~:
\begin{center}
{\tt PGCD(A,B)}
\end{center}
Ces param\`etres se comportent comme des variables locales, la seule 
diff\'erence est qu'ils sont initialis\'es lors de l'appel de la fonction.
On les d\'eclare en d\'ebut de fonction, en commencant la fonction
par ${\tt \ll\ \rightarrow\ }$ suivi par les variables locales
puis \verb|<< >>|.

Par exemple, si on veut que {\tt R} soit le param\`etre 
de la fonction {\tt PER}  on \'ecrit :
\begin{center}
 $${\tt \ll\ \rightarrow\ R \ll  3.14\ \rightarrow\ PI \ll 2*PI*R \gg
   \gg \gg STO\triangleright \  PER}$$
\end{center}
L'ex\'ecution se fait en tapant par exemple {\tt PER(5)}.

\subsubsection{Les Entr\'ees}\index{entree@entr\'ee}
Pour que l'utilisateur puisse entrer une valeur dans la variable {\tt A} au 
cours de l'ex\'ecution d'un programme, on \'ecrira~:\\
{\tt ...PROMPTSTO('A')}\index{PROMPTSTO}

\subsubsection{Les Sorties}\index{sortie}
Seul le dernier r\'esultat s'inscrit dans l'historique.
Pour afficher des r\'esultats interm\'ediaires on tape~:
\begin{center}
$${\tt MSGBOX( "A="+\rightarrow STR(A))}$$\index{MSGBOX}
\end{center}
(ici le {\tt +} effectue la concat\'enation de deux chaines de
caract\`eres).

On peut aussi g\'erer ligne par ligne l'\'ecran avec la commande \verb|DISP|.
Ainsi $$ {\tt DISP("A="+A,3)}$$\index{DISP}
affichera en ligne 3. Les fonctions de gestion de l'\'ecran sont
{\tt CLLCD()} (efface l'\'ecran) et
{\tt FREEZE(7)} (g\`ele l'affichage et permet de visualiser les 
7 lignes de l'affichage).


\subsubsection{La s\'equence d'instructions ou action}
Une action est une s\'equence d'une ou plusieurs instructions.\\
Pour la {\tt HP49G}, le {\tt\ ;\ } est un s\'eparateur d' instructions.\\ 
Le {\tt ;} s'obtient en tapant en m\^eme temps sur {\tt shift-rouge SPC}.

\subsubsection{L'instruction d'affectation}\index{affectation}
L'affectation est utilis\'ee pour stocker une valeur ou une expression 
dans une variable. On utilise  la touche ${\tt STO}$ qui se 
traduit \`a l'\'ecran  de la calculatrice par : 
$ \triangleright $  (que l'on  notera : ${\tt STO\triangleright}$)

\subsubsection{Les instructions conditionnelles}\index{test}
\begin{center}
{\tt IF\index{IF} \emph{condition} THEN\index{THEN} \emph{action} END}\\
{\tt IF \emph{condition} THEN \emph{action1}  ELSE\index{ELSE} \emph{action2} END}
\end{center}
Exemple (Attention au \verb|==| pour traduire la condition d'\'egalit\'e)~:
\begin{center}
{\tt IF A == 10 OR A < B THEN B-A STO$\triangleright$ B  ELSE A-B
  STO$\triangleright$ A  END}
\end{center}


\subsubsection{Les instructions "Pour" }\index{boucle}
\begin{center}
{\tt FOR\index{FOR} (I, A, B) \emph{action} NEXT\index{NEXT}}\\
{\tt FOR (I, A, B ) \emph{action} STEP\index{STEP} P}
\end{center}
L'instruction {\tt FOR} d\'eclare {\tt I} comme  variable locale 
et l'initialise automatiquement. 

\subsubsection{L'instruction ``Repeter''}
\begin{center}
{\tt DO\index{DO} \emph{action} UNTIL\index{UNTIL} \emph{condition} END}
\end{center}


\subsubsection{L'instruction ``Tant que''}
\begin{center}
{\tt WHILE\index{WHILE} \emph{condition} REPEAT\index{REPETE} \emph{action} END}
\end{center}

\subsubsection{Les conditions ou expressions bool\'eennes }\index{booleen@bool\'een}
Une condition est une fonction qui a comme valeur un bool\'een, \`a savoir elle
est soit {\tt vraie} soit {\tt fausse}.
\begin{enumerate}
\item Les op\'erateurs relationnels\\
Pour exprimer une condition simple on utilise les op\'erateurs :
\begin{center}
{\tt == < > $\leq$  $\geq$  $\neq$}
\end{center}
Attention pour les calculatrices HP le test d'\'egalit\'e se traduit,
comme en langage {\tt C}, par {\tt ==}
\item Les op\'erateurs logiques\\
Pour traduire des conditions complexes, on utilise les op\'erateurs logiques 
{\tt ou et non} qui se traduisent sur les calculatrices par :
\begin{center}
{\tt OR AND NOT} 
\end{center}
\end{enumerate}

\subsubsection{Les fonctions}\index{fonction}
Dans une fonction on ne fait pas de saisie de donn\'ees :
on utilise des param\`etres qui seront initialis\'es lors de l'appel.
Dans une fonction on veut pouvoir r\'eutiliser le r\'esultat :
on n'utilise pas de commande d'affichage. Par exemple, pour
additionner deux nombres de cette mani\`ere\\
${\tt \ll \rightarrow\ A\ B} $\\
${\tt \ \ \ll A +B \gg}$\\ 
${\tt  \gg}$ ${\tt  STO\triangleright\ ADDITION}$\\
Pour tester, on tape : $${\tt ADDITION(4,5)}$$

\subsubsection{Exemples} \label{sec:ex_prog}
L'algorithme itératif de Bézout\index{Bezout}, équivalent
de l'instruction \verb|IEGCD|, écrit en langage HP49.
Le principe consiste à calculer des égalités
\[ a l_i[1] +b l_i[2] = l_i[3] \]
on initialise $l_1$ et $l_2$ avec $\{ 1,0,a \}$ et $\{0,1,b\}$, 
le dernier élément
de la liste $l_i$ sera successivement la suite des restes de l'algorithme
d'Euclide. On passe à la ligne
suivante en faisant la combinaison linéaire 
\[ l_{i+2}=l_{i}-ql_{i+1} \]
o\`u $q$ est le quotient euclidien des deux restes $l_i[3]$
et $l_{i+1}[3]$. 
Rappelons que pour saisir \verb|;| il faut taper simultanément sur
shift droit et \verb|,|.\\
{\tt$\ll \rightarrow$ L1 L2 $\ll$}\\
\verb| |{\tt \{1,0,L1\} STO> L1;}\\
\verb| |{\tt\{0,1,L2\} STO> L2;}\\
\verb| |{\tt 0 $\rightarrow$ L3 $\ll$}\\
\verb|  |{\tt WHILE L2[3]$\neq$0 REPEAT}\\
\verb|    |{\tt L1-IQUOT(L1[3],L2[3])*L2 STO> L3;}\\
\verb|    |{\tt L2 STO> L1;}\\
\verb|    |{\tt L3 STO> L2;}\\
\verb|  |{\tt END;}\\
\verb|  |{\tt L1}\\
\verb| |{\tt $\gg$}\\
{\tt$\gg$}\\
{\tt$\gg$ STO> BEZOUT}\\
On peut alors taper \verb|BEZOUT(7,5)|.

Pour obtenir la liste des codes ASCII d'une chaine, on peut utiliser
le programme suivant\\
\verb|<< -> S <<|\\
\verb|  {} -> L <<|\\
\verb|    FOR(I,1,SIZE(S)) L+NUM(SUB(S,I,I)) STO> L NEXT;| \\
\verb|  L >>|\\
\verb| >>|\\
\verb|>> STO> ASCII| \\
On peut alors taper par exmeple \verb|ASCII("Bonjour")|.


%\pagebreak

\subsection{Exercices}
\begin{enumerate}
\item Ecrire une fonction calculant le cube d'un entier. En utilisant
cette fonction afficher la liste des cubes des entiers de 1 \`a 10.
\item Ecrire une fonction calculant les 2 racines d'une \'equation
du second degr\'e donn\'ee par $a$, $b$ et $c$.
\item Ecrire une fonction calculant la somme de $j$ variant de 1 
\`a $n$ de $1/j$. De m\^eme en faisant varier $j$ en d\'ecroissant.
\item Ecrire une fonction testant si un nombre est premier
en recherchant un diviseur inf\'erieur \`a $\sqrt{n}$.
\item Ecrire une fonction calculant le pgcd de 2 entiers par
l'algorithme d'Euclide.
\item Ecrire une fonction calculant l'indicatrice d'Euler d'un entier
en utilisant la fonction pr\'ec\'edente.
\item M\^eme question pour l'identit\'e de B\'ezout.
\item Ecrire une fonction calculant $a \pmod{pq}$ connaissant
$a =b \pmod p$ et $a=c \pmod q$ (la fonction interne s'appelle
\verb|ICHINREM|).

\item Calculer en mode approch\'e en croissant ou en d\'ecroissant
\[ \sum_{j=1}^n \frac{1}{j} \]
pour quelques valeurs de $n$~?

\end{enumerate}


\section{G\'eom\'etrie interactive} \index{geometrie@g\'eom\'etrie}
L'application de g\'eom\'etrie de la HP49 permet de faire
de la g\'eom\'etrie dynamique et de la g\'eom\'etrie analytique.
Vous devez installer la ROM contenant la g\'eom\'etrie depuis
le site\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/#hpgeo|\\
Attention, lorsque vous utilisez l'application de g\'eom\'etrie sur la
49, celle-ci passe en mode complexe. Pour passer rapidement
du mode complexe au mode r\'eel, tapez simultan\'ement sur les
tocuhes shift-gauche \verb|TOOL| (pour \verb|i|).

\subsection{Principes}

\subsubsection{G\'eom\'etrie dynamique} \index{geometrie@g\'eom\'etrie!dynamique}
Une application de g\'eom\'etrie permet d'effectuer
une construction g\'eom\'etrique, c'est-\`a-dire d\'efinir
des objets g\'eom\'etriques (points, droites, segments, cercles,
perpendiculaire, ...) ind\'ependants ou d\'ependants des objets
pr\'ec\'edents. Par exemple, on cr\'ee trois points, puis le triangle
d\'efini par ces 3 points, les m\'edianes issues des 3 sommets
puis le point d'intersection des 3 m\'edianes. On dit que
l'application est dynamique si on peut d\'eplacer certains
objets g\'eom\'etriques soit dans le plan s'ils sont ind\'ependants
des objets pr\'ec\'edents, soit sur une courbe du plan s'ils sont
sur une courbe, le logiciel recalcule alors la nouvelle position de tous
les objets g\'eom\'etriques et affiche la figure mise \`a jour. On
peut ainsi observer si une propri\'et\'e de la figure (par exemple
concourrance de trois droites, tangence, ...) est fortuite ou
semble toujours vraie. Si le logiciel de g\'eom\'etrie interagit
avec un logiciel de calcul formel, on peut aussi prouver une
propri\'et\'e en faisant des calculs de g\'eom\'etrie analytique.

Les calculatrices ont un \'ecran un peu trop petit pour faire des 
constructions complexes, de plus le temps de calcul de la figure
devient vite trop grand pour avoir une interactivit\'e agr\'eable,
n\'eanmoins, elles permettent d'effectuer de petites constructions
et d'exp\'erimenter ce type de logiciels dont le principe de
fonctionnement est identique sur ordinateur.

\subsubsection{Affichage}
L'\'ecran d'une calculatrice ou d'un ordinateur est compos\'e de
pixels, les objets g\'eom\'etriques doivent \^etre discr\'etis\'es
pour \^etre repr\'esent\'es. Sur un \'ecran d'ordinateur, il y
a suffisamment de pixels pour que l'oeil est l'impression de voir
de ``vrais'' objets g\'eom\'etriques, sur une calculatrice
on distingue souvent clairement la discr\'etisation. 

Il existe des algorithmes permettant
d'effectuer rapidement cette discr\'etisation pour les objets
g\'eom\'etriques courants (segments, cercles), le plus connu
est l'algorithme de Bresenham. Il faut aussi tenir compte
du cadrage, et ne repr\'esenter que la partie visible \`a l'\'ecran 
des objets
(par exemple une droite sera toujours repr\'esent\'ee par un segment).
Pour plus de d\'etails, chercher le mot clef Bresenham sur Internet,
cf. par exemple\\
\verb|http://raphaello.univ-fcomte.fr/IG/Algorithme/Algorithmique.htm|

\subsubsection{G\'eom\'etrie analytique} \index{geometrie@g\'eom\'etrie!analytique}
Le logiciel de g\'eom\'etrie de la HP49
utilise une repr\'esentation analytique (approch\'ee ou exacte) des objets
manipul\'es (par exemple deux nombres complexes approch\'es pour
un segment de droite, ou un complexe et un r\'eel approch\'es pour
un cercle) correspondant \`a un rep\`ere orthonorm\'e qui est
affich\'e ou non. Les liens entre un objet et les objets pr\'ec\'dents
se font en utilisant des fonctions \`a un ou plusieurs arguments
comme par exemple le centre (d'un cercle), l'intersection (de 2
objets),...

Une figure est une liste de noms de variables et d'expressions
permettant de calculer ces variables en fonction des objets
d\'efinis pr\'ec\'edemment. On peut acc\'eder depuis l'historique
aux objets de la derni\`ere figure g\'eom\'etrique affich\'ee (ils
sont stock\'es dans des variables). On peut alors
effectuer dans l'historique des calculs sur ces objets
g\'eom\'etriques, par exemple obtenir l'\'equation d'une droite
ou l'affixe d'un point.

Sur les HP, les commandes de cr\'eation d'objet sont ``explicites'',
la plupart du temps elles se font par l'interm\'ediaire d'une ligne
de commande qui est pr\'eremplie par l'utilisation des menus. 
Les objets ont tous un nom de variable, et peuvent
avoir un label affich\'e \`a l'\'ecran (on reprend alors le nom
de variable) ou non. Le format d'un nom d'objet est compos\'e du
label affich\'e \`a l'\'ecran et du nom de variable s\'epar\'e par :,
par exemple \verb|A:A:| pour un objet nomm\'e \verb|A| et
affich\'e \verb|A|, ou \verb|::A| pour un objet nomm\'e \verb|A|
mais sans l\'egende \`a l'\'ecran.
L'application peut utiliser des coordonn\'ees exactes, et on a acc\`es
depuis l'historique \`a toutes les informations analytiques sur tous 
les objets construits
(on passe en argument d'une commande les
noms de variables des objets g\'eom\'etriques,
par exemple \verb|abscisse(A)|).
On peut \'egalement tracer des objets non g\'eom\'etriques, par
exemple une courbe repr\'esentative, une tangente \`a un point, etc.
On peut d\'efinir des objets g\'eom\'etriques \`a l'aide
de fonctions (d\'efinies dans l'historique comme une fonction normale).


\subsection{Premier exemple d'utilisation}
Pour commencer nous allons construire un triangle défini par
trois points et son cercle circonscrit\index{circonscrit}. 
\begin{enumerate}
\item Touche \verb|APPS|, puis G\'eom\'etrie.
\item Si votre calculatrice est en anglais,
tapez \verb|F6| (Config) et sélectionnez \verb|Francais|\index{francais}
(si c'est \verb|English| qui apparait, tapez sur la touche \verb|ON|
pour annuler)
\item Vous pouvez supprimer les axes en tapant \verb|F6| (Config)
puis en sélectionnant \verb|Enlever axes|
\item Tapez \verb|F1| (Fich.) puis choisissez \verb|Nouveau|,
donnez un nom de variable pour votre construction, par exemple
\verb|CIRCON|
\item Tapez \verb|F2| (Ajouter) puis choisissez \verb|Points|
puis \verb|aleatoire|\index{aleatoire@al\'eatoire!point}, 
donnez alors 3 noms de points, par exemple
\verb|A B C| (le clavier est en mode alphabétique). 
Vous avez construit 3 points aléaoires.
\item Tapez \verb|F2| (Ajouter) puis choisissez \verb|Lignes|
puis \verb|mediatrice|\index{mediatrice@m\'ediatrice}, 
vous voyez apparaitre
\begin{center}
\verb|mediatrice()|
\end{center}
le curseur se trouve après la parenthèse ouvrante,
donnez alors le nom des 2 points A et B
séparés par une virgule, vous devez avoir la ligne
\begin{center}
\verb|mediatrice(A,B)|
\end{center}
tapez sur \verb|ENTER|, donnez ensuite
le label de la médiatrice (c'est le nom qui apparaitra à l'écran) et
le nom de variable de la médiatrice, par exemple \verb|:c:c|.
Vous pouvez aussi ne pas afficher de label pour la médiatrice
en tapant \verb|::c|. Par contre vous devez toujours donner un nom
de variable à la médiatrice.
\item Recommencez pour créer la médiatrice \verb|b| des points \verb|A| et 
\verb|C| et la médiatrice \verb|a| des points \verb|B| et \verb|C|. 
\item Tapez à nouveau \verb|F2|, sélectionnez \verb|Points|
puis \verb|inter|, indiquez en argument les noms de variable
des deux médiatrices, par exemple \verb|a| et \verb|b|, donnez
un label et un nom de variable pour le point d'intersection,
par exemple \verb|:O:O|.
\item \`A nouveau \verb|F2|, puis \verb|Courbes|, puis \verb|cercle|,
donnez en argument le centre \verb|O| et l'un des 3 points, par
exemple \verb|A|, donnez un nom de label et de variable au cercle
par exemple \verb|:S:S|. Notez qu'on pouvait construire directement
un cercle circonscrit \`a partir de 3 points (en choisissant
\verb|circonscrit| au lieu de \verb|cercle|).
\item Tapez sur \verb|F1| puis \verb|Sauver| pour sauver
la figure \verb|CIRCON|
\item Pour faire varier un des points et observer comment
la figure se modifie, tapez \verb|F4| (Déplacer), sélectionnez
\verb|A|, \verb|B| ou \verb|C| et faites bouger le point avec 
les flèches (vous pouvez pr\'ec\'eder les fl\`eches par
les touches shift pour déplacer plus rapidement ou alpha moins
rapidement). 
Tapez sur \verb|Ok|
pour accepter la nouvelle position ou sur \verb|Annul| pour
annuler le déplacement.
\item Pour quitter, tapez \verb|F1| puis \verb|Quitter|.
\item Vous pouvez maintenant taper des commandes de géométrie
analytique, comme par exemple \verb|affixe(A)|\index{affixe}, 
\verb|rayon(S)|\index{rayon}
directement au clavier (taper deux fois sur alpha puis sur
la touche shift gauche puis sur alpha pour bloquer le clavier
en mode alphabétique minuscule, taper à nouveau sur
shift gauche alpha pour revenir en mode majuscule),
ou en utilisant le menu Mesures.
\item Pour revoir cette figure ultérieurement, lancez
à nouveau l'application, puis si n\'ecessaire \verb|F1| et charger
\verb|CIRCON|.
% c'est bien ca? oui
\item Vous pouvez aussi modifier la construction dans son ensemble
en l'\'editant soit depuis le menu F4 (Déplacer), 
sous-menu \verb|Edit figure|,
soit en dehors de l'application de géométrie
en éditant la variable \verb|CIRCON|. Dans les deux cas, 
vous éditez une liste d'objets
géométriques, chaque objet géométrique étant constitué 
d'une formule de calcul et d'un label/nom de variable.
\end{enumerate}

\subsection{Lancement de l'application}
Vous pouvez lancer l'application de g\'eom\'etrie par la touche
\verb|APPS| puis \verb|12.Geometry|. Si l'historique est vide,
l'application interactive d\'emarre et ouvre la figure 
\verb|FIGURE| si elle existe. Sinon, si 
le dernier niveau de l'historique contient~:
\begin{itemize}
\item un nom de variable\\
l'application interactive est lanc\'ee sur la figure ayant ce nom de variable
\item \verb|0|\\ 
l'application n'est pas lanc\'ee mais le menu de g\'eom\'etrie est
affich\'e.
\item une figure \'evalu\'ee (une liste de listes),\\
l'application est lanc\'ee en mode non interactif, les \'el\'ements
de la figure sont \'evalu\'es et la figure ainsi que le temps
d'\'evaluation sont renvoy\'es.
\item un objet g\'eom\'etrique, r\'esultat de l\'evaluation
d'une commande de g\'eom\'etrie comme par exemple \verb|point|\\
l'objet est ajout\'e au graphique courant
\item dans tous les autres cas, l'application interactive est lanc\'ee
et ouvre la figure \verb|FIGURE| si elle existe.
\end{itemize}

Vous pouvez aussi utiliser la commande \verb|GEO('arg')| pour lancer
l'application interactive sur la figure de nom \verb|arg|.
Attention aux \verb|'|, si vous tapez \verb|GEO(arg)|,
vous obtiendriez une liste avec le graphique de la figure et le temps
d'\'evaluation. On peut enfin taper \verb|GEO(0)| pour
afficher le menu de g\'eom\'etrie dans l'historique
sans lancer l'application, 

\subsection{Menu Ajouter (F1)}
Les noms ci-dessous apparaissant en gras ne sont pas des commandes,
mais permettent d'acc\'eder \`a un assistant, par opposition
aux noms en fonte de taille fixe, qui sont des commandes (utilisables
dans l'historique).

\subsubsection{Sous-menu points (raccourci P)} 
\begin{itemize}
\item {\bf aleatoire}\index{aleatoire@al\'eatoire!point}~: 
crée un point aléatoire ou une liste de points aléatoires
(raccourci clavier R pour random), vous devez indiquer le(s) nom(s) des
points à créer,
\item \verb|point|\index{point}~: tapez les deux coordonnées du point, puis ENTER.
On vous demande ensuite le nom de label  et le nom de variable  du point (le 
nom de label n'est pas obligatoire ce qui permet de ne pas encombrer la 
figure). Notez que si vous utilisez
des coordonnées formelles (par exemple \verb|point(a,b)| où \verb|a|
et \verb|b| n'ont pas de valeur numérique), il faut déclarer
ces variables comme réelles si le mode variables
réelles n'est pas sélectionné en positionnant le flag système 128
(touche MODE, puis FLAGS).
\item \verb|milieu|\index{milieu} ~: 
tapez les deux noms de variables des deux points pour 
avoir le milieu du segment d\'efini par ces points.\\
Notez que \verb|barycentre| \index{barycentre} 
est un alias de \verb|milieu|
qui peut être utilisé depuis le menu commande 
(cf. \ref{sec:menucom}) pour calculer un barycentre.
\item \verb|centre|\index{centre}~: 
tapez le nom de variable d'un cercle pour avoir son
centre. Son alias \verb|sommets|\index{sommets}
peut aussi être utilisé depuis le menu commande (cf. \ref{sec:menucom}) pour
obtenir les sommets d'un polygone.
\item \verb|inter| \index{inter}~: 
intersection de 2 objets géométriques. L'intersection
de 2 droites renvoie un point ou undef si les droites sont
parallèles, l'intersection de 2 cercles ou d'une droite et
d'un cercle renvoie une liste de 2 points (s'ils ne sont pas sécants
les 2 points valent undef, s'ils sont tangents, le point de
tangence est répété). Les autres intersections renvoient une
liste de points dont le nombre est variable. Attention, pour
les intersections de 2 courbes paramétriques, l'un des paramétrages
doit être rationnel exact pour pouvoir extraire son équation
cartésienne par calcul de résultant.
\item \verb|element|\index{element}~: 
permet de créer un point sur une droite, un cercle
ou une courbe en tapant le nom de la courbe et une valeur du param\`etre.
\item \verb|zxpnt|\index{zxpnt}~: 
permet de créer un point étant donné son affixe
\end{itemize}

\subsubsection{Sous-menu lignes (raccourci  L)}
\begin{itemize}
\item \verb|segment|\index{segment}~: 
défini par deux points ou par deux nombres complexes
\item \verb|droite|\index{droite}~: comme segment
\item \verb|parallele|\index{parallele} et
 \verb|tangent|\index{tangent}~:
trace la parallèle en un point à une
droite donnée ou la tangente en un point à une courbe donnée
\item \verb|perpendiculaire| \index{perpendiculaire}~: 
trace la perpendiculaire en un point à une droite
donnée (cf. aussi hauteur)
\item \verb|mediatrice|\index{mediatrice}~: médiatrice de deux points
\item \verb|mediane| \index{mediane}~: 
médiane issue du premier point, le joignant au milieu
des deuxième et troisième points.
\item \verb|bissectrice|\index{bissectrice}~: 
bissectrice issue du premier point 
du triangle formé par les 3 points
\item \verb|hauteur|\index{hauteur}~: hauteur issue du premier point 
du triangle formé par les 3 points
\item \verb|eqxpnt|\index{eqxpnt}
\index{equation@\'equation!droite}
\index{equation@\'equation!cercle}~: 
crée une droite ou un cercle donné par son
équation cartésienne en fonction des variables X et Y
\end{itemize}

\subsubsection{Sous-menu cercles, courbes (raccourci S)}
\begin{itemize}
\item \verb|cercle|\index{cercle}~: crée un cercle donné par son centre (point ou
nombre complexe) et son rayon (réel)
ou par son centre et un point du cercle (deux points)
\item {\bf circonscrit}\index{circonscrit}~: crée le cercle circonscrit au triangle formé par
 3 points.\\
Il n'y a pas de commande correspondante, le système traduit en interne,
un appel à \verb|cercle| avec comme arguments la liste des 3 points
et 0  (cf \ref{sec:menucom}). 
\item {\bf inscrit}\index{inscrit}~: crée le cercle inscrit au triangle formé par 3 points. \\
Il n'y a pas de commande correspondante, le système traduit en interne
un appel à \verb|cercle| avec comme arguments la liste des 3 points
et 1 (cf \ref{sec:menucom}).

Attention, le calcul du cercle inscrit en mode exact nécessite
la simplification d'expressions contenant des racines carrées
ce qui peut s'avérer très long.
\item \verb|plot|\index{plot}\index{courbe}~: trace le graphe d'une expression donnée en fonction de X.
Attention, l'argument est une expression et non une fonction. Par exemple\\
\verb|plot(cos(X))|.\\
Cette fonction permet \'egalement de tracer les termes successifs
d'une suite r\'ecurrente d\'efinie par $u_{n+1}=f(u_n)$, on donne
en argument une liste compos\'ee de l'expression $f(X)$, de
la valeur initiale $u_0$ de la suite et du nombre de termes, par
exemple\\
\verb|plot({cos(X),0.1,7})|\\
On peut donner un point comme valeur initiale, ce qui permet de voir
comment \'evoluent les premiers termes de la suite en fonction
de la valeur initiale en d\'eplacant ensuite ce point.\\
Pour avoir la liste des valeurs prises par la suite, on peut 
utiliser la commande \verb|abscisse(G)| o\`u on remplace
\verb|G| par le nom de variable donn\'e au trac\'e, chaque
valeur est r\'ep\'et\'ee deux fois
(on peut aussi utiliser le tableur et programmer la suite).
\item \verb|paramplot| \index{paramplot} ~: trace le graphe d'une courbe paramétrée donnée
par les deux expressions $X(t)$ et $Y(t)$. Attention les arguments
sont des expressions et non des fonctions. Notez que $X(t)$ et $Y(t)$
peuvent être des nombres complexes, c'est le point d'affixe
$X(t)+iY(t)$ qui sera tracé, on peut donc tracer une courbe
paramétrique donné par une expression complexe $Z(t)$ en donnant $Z(t)$
comme premier argument et 0 comme 2ème argument. On peut aussi
représenter $Z(t)$ lorsque $Z(t)$ est un objet géométrique de type point
ou de type droite (dans ce cas c'est l'enveloppe des droites qui
est représentée). \\
Exemples~:\\
\verb|paramplot(COS(2*t),COS(3*t))|\\
\verb|paramplot(EXP(i*t),0)|\\
\verb|paramplot(eqxpnt(X*SIN(t)+Y*COS(t)-1),0)|
\item \verb|lieu|\index{lieu} \index{enveloppe}~: lieu d'un point ou enveloppe de droites. On donne
en argument un point sur une droite, un cercle et une courbe
(construit avecla commande \verb|element|), puis
un point ou une droite dépendant de ce premier point. Le système
calcule l'équation paramétrique des points dépendants ou de 
l'enveloppe de la droite dépendante et trace le graphe correspondant,
le r\'eglage des valeurs pris par le param\`etre (mini, maxi, pas)
pour les trac\'es param\'etriques influe donc sur le trac\'e obtenu et
le temps de calcul d'un lieu demande un peu de patience.\\
Le calcul d'un lieu dépendant d'un point sur une droite ou un cercle
est fait avec un paramétrage rationnel, ce qui permet des simplifications
du point dépendant en mode exact. Le syst\`eme convertit en mode
exact la figure avant de calculer le lieu.\\
Attention, si vous utilisez la commande \verb|lieu| depuis
l'historique ou dans une commande,
notez qu'elle prend 3 arguments, le nom de variable de la figure compl\`ete,
le nom du point sur la courbe et le nom du point dépendant.
\end{itemize}

\subsubsection{Sous-menu Triangle, quadrilatères} 
\begin{itemize}
\item \verb|triangle|\index{triangle} ~: crée un triangle donné par 3 points.
\item {\bf isocèle}~: crée un triangle isocèle donné par 2 points et un angle.
On peut aussi utiliser la commande \verb|triangle| avec 2 points et l'angle
au sommet.
\item {\bf equilateral}~: crée un triangle équilatéral direct donné
par 2 points. On peut aussi utiliser la commande \verb|triangle| avec 2 points 
et $\pi/3$ comme 3ème argument.
\item \verb|quadrilatere|\index{quadrilatere}~: 
crée un quadrilatère donné par 4 points.
\item {\bf parallelogramme}\index{parallelogramme}~: 
crée un parallélogramme donné par 3 points 
(par exemple $A,B,D$), puis on vous demande un nom pour le 4ème point 
(par exemple $C$ et alors 
$\overrightarrow{AB}+\overrightarrow{AD}=\overrightarrow{AC}$).\\
 On peut aussi utiliser :\\
la commande \verb|quadrilatere| avec 3 points et 0 comme 4ème argument,
 ou encore \\
la commande \verb|quadrilatere| avec 2 
points (par exemple $A,B$), un angle (par exemple $t$) et un nombre r\'eel 
(par exemple $k$) pour avoir le parallélogramme $ABCD$ tel que 
$(\overrightarrow{AB},\overrightarrow{AD})=t$ et $AD=k*AB$.
Dans ce cas le 3i\`eme et le 4i\`eme point n'ont pas de nom non,
il faudra executer une commande sommets pour leur donner un nom
\item {\bf carre}\index{carre}~: crée un carré direct donné par 2 points,
et demande les noms des 3ème et 4ème points du carré.
On peut aussi utiliser la 
commande \verb|quadrilatere| avec 2 points, $\pi/2$ comme 3ème
argument et 1 comme 4ème argument, mais dans ce cas le 3ieme et 4ieme point 
n'ont pas de nom (comme ci-dessus)
\item {\bf losange}\index{losange}~: 
crée un losange donné par 2 points (par exemple $A,B$)
et un angle (par exemple $t$),
demande le nom des 3ème et 4ème points (par exemple $C,D$ et alors 
$(\overrightarrow{AB},\overrightarrow{AD})=t$ et 
$\overrightarrow{AB}+\overrightarrow{AD}=\overrightarrow{AC}$).
On peut aussi utiliser la commande \verb|quadrilatere| avec 2 points, un 
angle comme 3ème argument et 1 comme 4ème argument.
\item {\bf rectangle}\index{rectangle}~: 
crée un rectangle direct donné par 2 points et un 
rapport de longueur (2ème coté sur 1er coté), demande le nom des 3ème
et 4ème points. On peut aussi utiliser la commande \verb|quadrilatere| avec 
2 points, $\pi/2$ comme 3ème argument et le rapport de longueur comme 4ème 
argument.
\end{itemize}
Pour créer des polygones\index{polygone} 
ayant plus de 4 cotés, on peut utiliser
les commandes \verb|zxpnt| avec en argument le vecteur des affixes
des points, ou on \'ecrit un programme dans lequel on utilise la commande 
\verb|point| avec, pour un $n$-gone, en 1er argument le vecteur $L$ 
``ferm\'e'' des $n+1$ points et se terminant par $n+1$ 
($L[0]=L[n], L[n+1]=n+1$) et en 
2ème argument l'entier binaire \verb|#0|.\\
On utilise le sous-menu \verb|Commandes| pour cela. Si on souhaite
tracer plusieurs polygones ayant un nombre fixé de coté, on peut aussi
définir depuis l'historique 
une fonction \verb|pentagone| de la manière suivante~: 
\begin{itemize}
\item en mode RPN :
\begin{verbatim}
<< -> A B C D E 
   << A B C D E A 6 ->ARRY #0 point >> 
>> 
'pentagone' STO> 
\end{verbatim}
\item en mode alg\'ebrique :
\begin{verbatim}
<< -> A B C D E 
  << point([A,B,C,D,E,A],#0) >> 
>> 
STO> 'pentagone'
\end{verbatim}
\end{itemize}
{\bf Commentaires }:
\begin{itemize}
\item Dans le programme RPN, 6 est le nombre d'éléments à prendre sur la pile 
pour créer le vecteur. 
\item On utilise ensuite \verb|pentagone| depuis le menu \verb|Ajouter|,
sous-menu \verb|Commandes| de la même manière qu'on utilise \verb|triangle|
ou \verb|quadrilatere| mais en lui passant 5 arguments.
\end{itemize}

\subsubsection{Transformations}
\begin{itemize}
\item \verb|translation|\index{translation}~: 
translation selon un segment ou un
vecteur donné par son affixe (1er argument)
d'un objet géométrique (2ème argument)
\item \verb|symetrie|\index{symetrie}~: 
symétrie centrale si le 1er argument
est un point, symétrie orthogonale par rapport à une droite
si le 1er argument est un segment ou une droite, l'objet
à transformer est le 2ème argument.
\item \verb|rotation|\index{rotation}~: 
rotation déterminée par son centre (1er
argument), l'angle (2ème argument) d'un objet géométrique (3ème
argument)
\item \verb|homothetie|\index{homothetie}~: 
homothétie de centre le 1er argument,
de rapport le 2ème argument, l'objet à transformer est le 3ème
argument. Si le rapport est un complexe, on obtient une
similitude.
\item \verb|projection|\index{projection}~: 
projection sur une droite
(1er argument) du 2ème argument (qui doit être un point).
\item \verb|inversion|\index{inversion}~: 
inversion de centre le 1er argument, de puissance  
le 2ème argument et l'objet à transformer est le 3ème argument.
\end{itemize}
Notez qu'on peut définir une fonction à un argument qui est une transformation 
dont les paramètres sont fixés, par exemple,
en tapant dans l'historique~:\\
\verb|DEFINE(rA(X)=rotation(A,pi/3,X))|\\
on définit la rotation $r_A$ de centre $A$ et d'angle $pi/3$ qu'on peut
ensuite utiliser dans le sous-menu commande (par exemple \verb|rA(B)|
pour calculer l'image de $B$ par la rotation $r_A$, cf \ref{sec:menucom}).

\subsubsection{Sous-menu légende} \index{legende}
Permet d'afficher en l\'egende la valeur d'une
formule. La l\'egende est compos\'ee d'une partie fixe et
d'une formule qui sera \'evalu\'ee et affich\'ee apr\`es la partie fixe.
La l\'egende s'affiche \`a un endroit 
détermin\'e par un nom de point ou par un nombre complexe.

Par exemple, pour afficher \`a l'endroit d\'etermin\'e par le point de 
coordonnées $(2,1)$, la valeur de l'abscisse du point $M$, on tape d'abord la 
formule \verb|abscisse(M)|
(déselectionnez le mode alpha en tapant sur la touche alpha,
puis taper F6 pour faire apparaitre le sous-menu Mesures, tapez
alors sur abscisse, puis alpha puis M), puis les coordonnées du point
d'affichage \verb|(2,1)| (on peut aussi taper le nom de ce point pour 
afficher la l\'egende en ce point), 
puis la partie ``fixe'' de la légende (par exemple \verb|"Mx="|).
Si le point $M$ a pour abscisse par exemple $\ -1.21$, 
on verra \`a l'\'ecran au point d'affixe (2,1) la l\'egende
\verb|"Mx=-1.21"|. Si on d\'eplace $M$, la l\'egende indiquera
la nouvelle valeur de l'abscisse de $M$ au cours du d\'eplacement.

\subsubsection{Enregistrer formule}\index{enregistrer@enregistrer!formule}
Permet d'enregistrer une liste de formules dans une variable.
Lorsqu'on réévalue la figure, par exemple en déplaçant un point,
la liste de valeurs est recalculée et ajoutée à la variable.
On peut ensuite étudier les valeurs enregistrées dans la variable
en quittant l'application de géométrie. Par exemple, on peut
transformer la liste des variables enregistrées en une matrice
avec la commande \verb|AXL|, puis exécuter l'application
de statistiques.

\subsubsection{Menu commande}\index{commande}\label{sec:menucom}
Permet de saisir une commande pour définir un objet géométrique.
La commande est soit un objet algébrique (expression ne comportant ni liste
ni vecteur...), soit un programme.

Voici quelques exemples \`a saisir en mode algébrique~:
\begin{itemize}
\item Pour calculer l'isobarycentre d'une liste de points, taper :\\
\verb|barycentre({A,B,C},1)|
\item Pour calculer le barycentre d'une liste de points \{A,B,C\} affectée 
de la liste de coefficients \{1,2,3\}, taper :\\
\verb|barycentre({A,B,C},{1,2,3})|
\item Pour tracer un polygone fermé à 5 cotés, taper :\\
\verb|point([A,B,C,D,E,A],#0)|
\item
Pour accéder par exemple au 3-ième sommet du polygone Q  taper :\\
\verb|centre(Q)[3]|
\item
Pour tracer le cercle circonscrit au triangle ABC, taper :\\
\verb|cercle({A,B,C},0)|
\item
Pour tracer le cercle inscrit au triangle ABC, taper :\\
\verb|cercle({A,B,C},1)|
\end{itemize}

%a expliciter? par ex :  Vous pouvez utiliser toutes les fonctions de la HP49, 
%la seule  contrainte est que l'on mette tous les arguments de la fonction 
%sans utiliser la pile et que la fonction renvoie un objet 
Vous pouvez utiliser toutes les commandes et toutes les fonctions de la HP49. 
Lorsque votre ligne de commande est délimitée par \verb|<< >>|, 
ce doit être une fonction qui a zéro argument et 
renvoie un objet géométrique. Sinon, votre ligne de commande
doit désigner un objet géométrique (en mode RPN, les quotes
sont implicitement rajoutées). Notez qu'en mode RPN
on ne peut pas utiliser de listes ou de vecteurs dans un objet algébrique,
il faut alors traduire la définition de l'objet géométrique
en une fonction délimitée par \verb|<< >>|.

\subsection{Menu Effacer (F3)}
Permet de sélectionner un objet à effacer.

\subsection{Menu Déplacer (F4)}
Permet de sélectionner un point à déplacer à l'aide des
flèches de déplacement, ou permet d'éditer l'ensemble de la figure. 

Si on déplace un point, il faut attendre
quelques secondes, le temps que le système calcule la partie fixe
de l'image. Ensuite si on a sélectionné un point
libre, le déplacement se fait avec les flèches de déplacement
dans toutes les directions.
Si on a sélectionné un point sur une courbe, le déplacement
se fait sur la courbe. Utilisez les touches shift et alpha
pour faire varier le nombre de pixels du déplacement. Si vous
tapez plusieurs fois de suite sur une flèche de déplacement,
la figure peut ne pas avoir le temps de se retracer en entier.
Tapez Ok ou ENTER pour accepter
la nouvelle position, ou sur Annul pour revenir à la position
initiale.
Lors du premier déplacement, si on vous demande de passer
en mode approx, répondez oui.

Il n'est pas possible de déplacer un point si un lieu géométrique
en dépend. Par contre si le lieu géométrique est défini antérieurement
au point, le déplacement est possible. S'il est défini postérieurement,
il faut éditer la figure globalement.

Si on édite globalement la figure, l'\'editeur de matrice apparait, 
chaque ligne correspond \`a un objet géométrique avec~:
\begin{itemize}
\item en colonne 1, la formule de calcul de l'objet, par exemple :\\
\verb|'mediatrice(A,B)'|
\item en colonne 2, le label et le nom de l'objet sous la forme 
\verb|:label:nom|, par exemple :\\
\verb|:c:c| si la légende \verb|c| est affichée, ou \\
\verb|::c| ou \verb|c| si il n'y a pas d'affichage de la légende.
\end{itemize}

\subsection{Pict (F5)}
Permet d'accéder à l'application graphique intégrée de la HP49.
En particulier, l'appui sur la touche F2 (X,Y), permet de
déplacer le curseur dans la figure pour connaitre les coordonnées
approximatives des objets géométriques de la figure.
Taper sur ON pour revenir à l'application de géométrie.

\subsection{Menu Config (F6)}
Permet de configurer l'application.
\begin{itemize}
\item Exact: passe la calculatrice en mode exact. Les calculs
sont donc formels et non approchés. Les résultats peuvent
être utilisés pour faire une preuve.
\item Approx: passe la calculatrice en mode approché. Les calculs
sont plus rapides, mais on ne peut pas faire de preuve de géométrie
analytique en mode approx.
\item Xminmax, Yminmax~: permet de définir les valeurs de la fenêtre
d'affichage ainsi que les valeurs limites de $t$ (Indep-low
et Indep-high) pour les tracés de courbe et la valeur de saut
de $t$ entre 2 calculs successifs.
\item Marquage axes~: définit le ``tickmark'', l'intervalle
entre deux marques sur les axes (H-Tick et V-Tick). 
Permet aussi de définir si l'unité
est le pixel ou non.
\item Zoom in, Zoom out: multiplie ou divise par 1.414 les valeurs
limites de la fenêtre.
\item Autoriser ou supprimer l'affichage des axes.
\item English ou Francais~: change de langue.
\end{itemize}

\subsection{Les autres touches du clavier}
Les touches de déplacement permettent de changer la fenêtre de 
visualisation de la figure géométrique. Les touches + et - permettent
d'effectuer un zoom avant ou arrière (utiliser les touches shift
et alpha auparavant pour régler le facteur de zoom).
L'ensemble des raccourcis claviers peut être visualisé en tapant
sur F1 (Fich.) puis Aide.


% liste des commandes de geometrie

\subsection{Exercices}
\begin{enumerate}
\item Faites la m\^eme construction pour le centre de gravit\'e ou/et 
le cercle inscrit, l'orthocentre d'un triangle.
\item Th\'eor\`eme de Napol\'eon\\
Soit ABC un triangle quelconque, on construit sur ses
cot\'es trois triangles \'equilat\'eraux, il s'agit de caract\'eriser
le triangle form\'e par les 3 centres des triangles \'equilat\'eraux.
\item
On se donne un point $M$ sur un cercle passant par $A$, soit
$MAPN$ le carré direct de coté $MA$. Quel est le lieu de $N$
lorsque $M$ parcourt le cercle?
\item
On se donne un point $F$ et un cercle $C$ de centre $O$ et de rayon $r$.
Soit $M$ un point sur le cercle $C$, $N$ la médiatrice du segment  $FM$. Quelle
est l'enveloppe des médiatrices $N$ lorsque $M$ parcourt le cercle $C$?
\item Th\'eor\`eme de Morley\\
Soit $ABC$ un triangle, on trace les trissectrices des angles en
chaque sommet, puis on appelle $M$, $N$ et $O$ les points
d'intersection de la premi\`ere trissectrice issue d'un sommet
avec la deuxi\`eme trissectrice issue du sommet suivant. Il
s'agit de caract\'eriser le triangle $MNO$.
\end{enumerate}

\section{Un exemple associant g\'eom\'etrie, statistiques, calcul  formel et numérique.}
On se donne un carré ABCD, un point $E$ parcourant le segment $BC$.
On construit le cercle inscrit au triangle $ABE$ et le cercle
tangent aux cotés $EA$, $EC$, $CD$. Il s'agit de savoir pour
quelle position de $E$ les deux cercles ont même rayon, et pour
quelle position de $E$ les deux cercles sont tangents à la droite
$EA$ au même point.

\begin{center}
%file session0.tex
% Generated by xcas
\noindent
\psset{unit=5.0000cm}
\psset{linewidth=.5pt}
\psset{arrowsize=2pt 4}
\pspicture*(-0.1000,-0.1000)(1.1000,1.1000)
\psset{linecolor=black}
\psline[linestyle=dashed]{->}(-0.1000,0.0000)(1.1000,0.0000)
\psline[linestyle=dashed]{->}(0.0000,-0.1000)(0.0000,1.1000)
\psset{linecolor=black}
\psdots[dotstyle=*](0.0000,0.0000)
\uput{0.0100}[45.0000](0.0000,0.0000){A}
\psset{linecolor=black}
\psdots[dotstyle=*](1.0000,0.0000)
\uput{0.0100}[45.0000](1.0000,0.0000){B}
\psset{linecolor=black}
\psdots[dotstyle=*](1.0000,1.0000)
\uput{0.0100}[45.0000](1.0000,1.0000){C}
\psset{linecolor=black}
\psdots[dotstyle=*](1.0000,0.3000)
\uput{0.0100}[45.0000](1.0000,0.3000){E}
\psset{linecolor=black}
\psdots[dotstyle=*](0.0000,1.0000)
\uput{0.0100}[45.0000](0.0000,1.0000){D}
\psset{linecolor=black}
\psline[fillcolor=black](     0.000000,     0.000000)(     1.000000,     0.000000)(     1.000000,     1.000000)(     0.000000,     1.000000)(     0.000000,     0.000000)
\psset{linecolor=black}
\psline(0.0000,0.0000)(1.0000,0.3000)
\psset{linecolor=black}
\psarc[fillcolor=black](0.8720,0.1280){0.1280}{0.0000}{360.0000}
\uput{0.0100}[45.0000](0.8720,0.1280){C1}
\psset{linecolor=black}
\psdots[dotstyle=*](0.8720,0.1280)
\uput{0.0100}[45.0000](0.8720,0.1280){O1}
\psset{linecolor=black}
\psdots[dotstyle=*](0.5986,0.5986)
\uput{0.0100}[45.0000](0.5986,0.5986){O2}
\psset{linecolor=black}
\psarc[fillcolor=black](0.5986,0.5986){0.4014}{0.0000}{360.0000}
\uput{0.0100}[45.0000](0.5986,0.5986){C2}
\endpspicture 
\end{center}

\subsection{Recherche d'une solution numérique}
On entre dans l'application de géométrie. 
\begin{itemize}
\item On définit les points A, B, C et D, raccourci 1 puis le
couple de coordonnées puis le nom du point, par exemple pour d\'efinir le 
point $A$, on tape :\\
 \verb|1| puis \verb|0,0| puis \verb|:A:A|.
\item On trace le carré avec le raccourci 4 puis le nom des 4 points,
on donne \verb|::Q| comme nom au carré
\item On définit le segment $BC$ avec le raccourci 2, le nom des
2 points, et \verb|::BC| comme nom de segment
\item On définit le point $E$ comme élément de $BC$, raccourci P
puis \verb|element| puis \verb|BC,0.4| (par exemple) et
\verb|:E:E| comme nom de point
\item On trace le segment $AE$, raccourci 2 puis nom des points
$A$ et $E$, et nom du segment \verb|::AE|
\item On trace le cercle inscrit à $ABE$ avec raccourci S puis
inscrit, puis on donne les noms des 3 points $A$, $B$, $E$, appelons
le cercle \verb|::C1|
\item On trouve le centre de l'autre cercle par intersection de 
2 bissectrices\index{bissectrice}, celle de $EAC$ et celle de $CBD$,
raccourci P, puis inter, la ligne de commande est
\begin{center}
\verb|inter(bissectrice(E,A,C),bissectrice(C,B,D))|
\end{center}
on donne comme nom de point \verb|:O2:O2|
\item On construit le 2ème cercle, de centre $O_2$ et de rayon
la distance\index{distance} de $O_2$ au segment $BC$, raccourci S, cercle,
puis \verb|O2,distance(O2,BC)|, nom du cercle \verb|::C2|.
\item On affiche le rayon de $C1$, menu ajouter, Legende, puis
\verb|rayon(C1)| puis le point d'affichage, par exemple \verb|(-1,0.2)|
avec partie fixe de label \verb|"r1="|
\item On affiche le rayon du 2ème cercle, menu ajouter, Legende,
puis \verb|rayon(C2)| puis le point d'affichage
par exemple \verb|(-1,0.5)|, partie fixe de label \verb|"r2="|
\item On affiche l'ordonnée de $E$, menu ajouter, Legende,
puis \verb|ordonnee(E)| puis point d'affichage par exemple
\verb|(-1,0.8)|, partie fixe du label \verb|"y="|
\item On peut ensuite faire varier $E$ (menu déplacer) et voir
quand les rayons sont proches. Pour $y$ proche de 0.65, on
a des rayons proches l'un de l'autre.
\item Pour la tangence en un point commun, on calcule l'angle
entre les 2 centres et la droite $AE$. On construit le segment
reliant les 2 centres, par raccourci 2, puis \verb|centre(C1),O2|,
nom \verb|::O12|. 
\item Puis on construit l'intersection avec $AE$ par
raccourci P, inter, \verb|O12,AE|, nom de point \verb|::T|.
\item
Puis on affiche l'angle par menu ajouter, Legende, puis 
\verb|angle(T,E,O2)|, puis le point d'affichage 
par exemple \verb|(-1,1.1)|, puis la partie fixe de label \verb|"t="|.\\
N.B.~: pour afficher l'angle en degrés, on peut utiliser la formule
\begin{center}
\verb|angle(T,E,O2)*180/3.1415926535|
\end{center}
\item On peut a nouveau faire varier $E$ pour repérer la tangence
(l'angle en radians doit être proche de 1.57). Pour $y$ proche de 0.4
on a un angle proche de 90 degrés.
\end{itemize}

\subsection{Géométrie et statistiques.}
Nous allons maintenant enregistrer les valeurs de $r_2-r_1$ et
de l'angle $t$ pour quelques valeurs de $y$ et essayer d'affiner
la solution par du fitting. On utilise la fonction Enregistrer
formule du menu ajouter, on donne comme formule
\begin{center}
\verb|{'ordonnee(E)' 'rayon(C2)-rayon(C1)' 'angle(T,E,O2)'}|
\end{center}
puis répondre par exemple \verb|DATA| pour la variable
où enregistrer. Déplacer ensuite $E$ sur quelques positions.
Quitter ensuite l'environement de géométrie, et copier la variable
\begin{center}
\verb|AXL(DATA) STO> |$\Sigma$\verb|DAT|
\end{center}
puis lancer l'environnement
de statistiques (shift droit \verb|STATS|), sélectionner les colonnes
1 et 2 ou 1 et 3 et testez les régressions linéaires ou cubiques
pour estimer les solutions en $y$ de $r_1=r_2$ ou de $t=\pi/2$.

\subsection{Méthode formelle}
On place $A$ en l'origine, $B$ en $(0,1)$, on note $t$ l'ordonnée de $E$.
On impose au paramètre $t$ d'être entre 0 et 1
\begin{center}
{\tt ASSUME(t>0)}\\
{\tt ASSUME(t<1)}
\end{center}
Il est essentiel de faire ces deux hypothèses dès maintenant, 
sinon les valeurs absolues
ne seront pas simplifiées dans les calculs de cercles inscrits
et de bissectrices.

Depuis l'historique,
on définit les points $A$, $B$, $C$ et $E$
\begin{center}
\verb|point(0,0) STO> A|\\
\verb|point(1,0) STO> B|\\
\verb|point(1,t) STO> E|\\
\verb|point(1,1) STO> C|
\end{center}

Pour le cercle inscrit, on utilise l'instruction cercle avec 2
arguments, comme suit~:
\begin{center}
\verb|centre(cercle({A,B,E},1)) STO> O1|
\end{center}
Pour le centre de l'autre cercle, on cherche l'intersection de la bissectrice
de l'angle EA, EC avec la bissectrice de EC et CD, qui
est la 1ère bissectrice d'équation $Y-X=0$
\begin{center}
\verb|inter(bissectrice(E,A,C),eqxpnt(Y-X)) STO> O2|
\end{center}
Le vecteur O1O2 a pour affixe
\begin{center}
\verb|affixe(O2)-affixe(O1) STO> O1O2|
\end{center}
Pour que les cercles aient même rayon, les abscisses de O1 et O2
doivent être identiques, on calcule donc
\begin{center}
\verb|abscisse(O1O2) STO> E1|
\end{center}
On peut utiliser le solver numérique 
\begin{center}
\verb|ROOT(E1,t,0.6)|
\end{center}
Il faut alors purger $t$ (\verb|PURGE(t)|) avant de continuer.
On peut aussi éditer \verb|E1| dans l'éditeur d'équation, en multipliant
à la main par l'expression conjuguée (mettre le terme sans la racine
au carré et le terme en racine au carré).
L'équation obtenue est~:
\[ 2t^3-2t^2+2t-1=0 \]
Solution approchée 0.647798871261.

Pour que les cercles soient tangents, la droite joignant O1 à O2 doit
être orthogonal à la droite OE. On calcule l'affixe de O1 et
de O2, la différence doit être orthogonale au vecteur $(1,t)$
\begin{center}
\verb|abscisse(O1O2)+t*(ordonnee(O1O2)) STO> E2|
\end{center}
On peut faire les mêmes manipulations, on obtient l'équation
\[ 2t^3-2t^2-2t+1=0 \]
Solution approchée 0.403031716763

\appendix

\section{D\'epannage.} \label{sec:depannage}
\begin{itemize}
\item {\em Le contraste est mal réglé}\\
Appuyer simultanément sur \verb|ON| et \verb|+| ou sur \verb|ON| et \verb|-|
pour régler le contraste.
\item {\em La calculatrice ne s'allume pas.}\\
Appuyez sur \verb|ON| et \verb|F3| simultan\'ement.
Introduisez un trombone dans le petit trou \`a cot\'e de Reset \`a
l'arri\`ere de la calculatrice. V\'erifiez les piles.
L'appui simultan\'e sur \verb|ON|, \verb|F1| et \verb|F6| 
permet de r\'einitaliser compl\`etement la calculatrice.
\item {\em La calculatrice ne r\'epond plus, le sablier (calcul en cours) 
reste allum\'e.}\\
Appuyer sur \verb|ON| une ou plusieurs fois. Si cela ne fonctionne
pas, essayez \verb|ON| et \verb|F3| simultan\'ement (l'historique
sera perdu).
\item {\em En tapant \verb|1+2|, on obtient une erreur ou un
    r\'esultat incorrect}\\
Passez en mode alg\'ebrique, touche \verb|MODE|, \verb|F2 (CHOOSE)|,
\verb|Algebraic| puis \verb|ENTER|.
\item {\em Il n'y a plus de m\'emoire}\\
Effacez l'historique (shift droit-effacement) ou/et des variables
(shift gauche-\verb|APPS|).
\item {\em L'application \'editeur de matrice lance le tableur}\\
Touche \verb|MODE|, \verb|F1 (FLAGS)|, fl\`eche vers le haut,
remonter jusqu\`a 91 et d\'ecocher.
\item {\em Erreur \verb|Undefined Name|}\\
V\'erifiez que le mode \verb|Numeric| est d\'ecoch\'e, touche
\verb|MODE| puis \verb|CAS|
\item {\em Les nombres exacts sont convertis en nombres approch\'es (avec
un signe \verb|.|).}\\
Passez en mode exact, touche \verb|MODE| puis \verb|CAS|, d\'ecochez
\verb|Approx|.
Attention, les donn\'ees d\'eja entr\'ees sont encore en mode
approch\'e, on peut les convertir en mode exact sans les resaisir
avec la commande \verb|XQ|.
\item {\em Les menus ne s'affichent plus dans une liste
    d\'eroulante.}\\
Touche \verb|MODE|, \verb|F1 (FLAGS)|, fl\`eche vers le haut,
remonter jusqu\`a 117 et cocher.
\item {\em \verb|ABS(X)| renvoie \verb|X| sans hypoth\`ese sur
    \verb|X|}\\
Touche \verb|MODE|, \verb|F1 (FLAGS)|, fl\`eche vers le haut,
remonter jusqu\`a 119 et d\'ecocher.
\item {\em Les r\'esultats interm\'ediaires sont (ou ne sont pas)
    affich\'es}\\
Touche \verb|MODE|, \verb|F3 (CAS)|, cochez ou d\'ecochez
\verb|Step/Step| puis validez.
\item {\em L'aide en ligne est en anglais}\\
Taper la commande {\tt $\rightarrow$LANGUAGE(1)} ou lancez
l'application de g\'eom\'etrie (tocuhe \verb|APPS|, puis 
\verb|12. Geometry|, puis \verb|F6| (\verb|Config|), et choisir
\verb|Francais|).
\end{itemize}

\end{document}

\section{Sujets donn\'es au CAPES 2005}
D'apr\`es 
\verb|www.capes.math.jussieu.fr/2005/sujets_dossiers_05.htm|

\begin{enumerate}
\item (27 juin, 1.5) \\
\[ a_n=4.10^n-1, b_n=2.10^n-1, c_n=2.10^n+1 \]
Calculer $a_1,...,c_3$. V\'erifier que $b_3$ est premier, que
$b_nc_n=a_{2n}$, calculer
la d\'ecomposition en facteurs premiers de $a_6$. Calculer le pgcd
de $b_n$ et $c_n$, pr\'esenter
un algorithme de calcul du PGCD de deux entiers naturels non nuls.
\item (29 juin, 2)\\
Soit $A, B, C$ trois points non align\'es du plan, $T$ le triangle
$ABC$. On se propose de d\'emontrer uniquement avec les nombres
complexes que les hauteurs de $T$ sont concourantes en un point $H$.
Illustrer le r\'esultat. On peut se ramener au cas o\`u les affixes $a$, $b$
et $c$ de $A, B, C$ sont de m\^eme module (pourquoi?)
montrer avec les instructions de calcul formel que les hauteurs 
passent alors par $H$ d'affixe $h=a+b+c$ 
(indication, consid\'erer $z=(h-c)/(b-a)$).
\item (30 juin, 1)\\
Courbe repr\'esentative de $f(x)=\sqrt{x^2+x+1}$ (y compris 
tableau de variations, calcul des asymptotes et droite de 
sym\'etrie d'\'equation $x=-1/2$).
\item (2 juillet, 2)\\
\[ u_{n+1}=f(x), \quad f(x)=x-\frac{1}{4}(x^2-7), \quad u_0 \in [2,3] \]
Calculer les premiers termes de la suite, conjecturer le comportement
asymptotique. Montrer que $f$ est contractante de rapport $1/2$ sur
$[2,3]$ et que $\sqrt{7}$ est toujours compris entre deux valeurs successives
de la suite. Donnez une valeur approch\'ee de $\sqrt{7}$ \`a $10^{-4}$
pr\`es.
\item (4 juillet, 2)\\
Il s'agit de d\'eterminer la date $J_1$ d'apparition simultan\'ee 
de 2 corps astronomiques ayant des p\'eriodes
de 105 et 81 jours, observ\'es respectivement les jour $J_0$ et
$J_0+6$. Soit $x,y$ le nombre de p\'eriodes effectu\'ees par les
2 corps. Montrer que $35x-27y=2$. Pr\'esentez un algorithme
de calcul du PGCD de 2 entiers, puis de recherche d'une solution
particuli\`ere de $35x-27y=1$.
Calculer $J_1$ puis $J_2$ la
date de l'apparition simultan\'ee suivante.
\item (10 juillet, 1)\\
\begin{tabular}{|c|c|c|c|c|c|c|c|c|} \hline
Ann\'ee & 96 & 97 & 98 & 99 & 00 & 01 & 02 & 03  \\\hline
Production & 325 & 351 & 382 & 432 & 478 & 538 & 708 & 930 \\ \hline
\end{tabular}\\
Tracer le nuage de points correspondant, et de m\^eme pour les points
(annee,log(production)). D\'eterminer l'\'equation de la droite de
r\'egression des moindres carr\'es pour le log de la
production. Quelle
production peut-on pr\'evoir en 06?
\item (11 juillet, 1)\\
$f(x)=0.85x+3000$. Repr\'esentation graphique de $f$ et des premiers
termes de la suite $a_n$ d\'efinie par $a_{n+1}=f(a_n), a_1=60000$.
\item (14 juillet, 1)\\
Impot $I$ en fonction du revenu $R$
\[ 
\left\{
\begin{array}{cc}
R<4121 & I=0 \\
R \in [4121,8104] & I=0.075R-309.07\\
R \in [8104,14264] & I=0.21R-1403.12 \\
R \in [14264,23906] & I=0.31R-2829.52
\end{array}
\right.
\]
Trac\'e du graphe. Calcul du taux d'imposition $I/R$ pour $R=5000,
10000, 150000, 20000$. Pour $R\in [23906,37579]$, la formule est
$I=0.41R-a$, calculer $a$ pour que $I$ soit continue.
\item (15 juillet, 2)\\
On se donne un point $B$ \`a l'int\'erieur du segment $[AE]$ et 
on construit les carr\'es directs $ABCD$ et $BEFG$. Il s'agit de montrer
que $AG$ est orthogonal \`a $EC$. Faites la construction
g\'eom\'etrique. Proposez une d\'emonstration avec les outils de
calcul formel.
\item (18 juillet, 1.5)\\
Soit $ABCD$ un carr\'e direct, $M$ un point de $[AC]$, $P$ le 
projet\'e orthogonal de $M$ sur la droite $(AD)$ et $Q$ son projet\'e 
sur la droite $(DC)$. Soit $N$ le lieu
du point d'intersection de $CP$ et $BQ$ lorsque $M$ d\'ecrit $[AC]$.
Construire la figure. Quel est le lieu de $N$?
\item (21 juillet, 1)\\
Soit $C_1, C_2, C_3$ trois cercles concentriques de rayon 6, 4 et 3 et
$A$ un point du cercle $C_1$. Il s'agit de construire $B\in C_2$ et
$C \in C_3$ tels que $ABC$ soit \'equilat\'eral (on pourra utiliser
les rotations de centre $A$). Construire les solutions \`a la
calculatrice.
\end{enumerate}

