| 1 |
\section{Mathématiques versus méthodes numériques} |
| 2 |
Les mathématiques sont des méthodes génériques et exactes. En réalité, ces méthodes sont rarement applicables sur des problèmes d'ingénierie. |
| 3 |
\\ |
| 4 |
Par exemple : |
| 5 |
\begin{itemize} |
| 6 |
\item l'intégration est bien définie en mathématiques mais la notion de primitives associées à l'intégration est impossible à utiliser parce que dans la plupart des cas la primitive est inconnue. |
| 7 |
\item Les temps et le nombre de calculs peuvent être importants pour être fait manuellement. Bien que la solution théorique existe, il existe beaucoup de cas en ingénierie où le nombre de calculs nécessaire pour obtenir la réponse est tellement important que la méthode devient inutilisable. |
| 8 |
|
| 9 |
\end{itemize} |
| 10 |
Le recours à l'ordinateur est obligatoire pour automatiser les tâches. |
| 11 |
\\ |
| 12 |
\\ |
| 13 |
\emph{L'objectif est de transformer les théories mathématiques en méthodes numériques pour utiliser un ordinateur pour trouver des solutions numériques à un problème (d'ingénierie dans notre cas).} |
| 14 |
\\ |
| 15 |
\\ |
| 16 |
Malheureusement il existe une énorme différence entre un ordinateur et la théorie des mathématiques. Sur un ordinateur un nombre ne peut pas être représenté par un nombre infini de chiffres. |
| 17 |
Par exemple $\frac{1}{3}$ existe en mathématiques et ne peut pas exister en méthodes numériques où on a $0.3333333...3$ et $\frac{1}{3}\neq0.3333333...3$. |
| 18 |
\\ |
| 19 |
\\ |
| 20 |
\emph{L'utilisation d'un ordinateur pour solutionner des problèmes numériques introduit \underline{\textbf{nécessairement}} une erreur de calcul.} |
| 21 |
|
| 22 |
\section[La représentation des nombres]{Représentation des nombres à l'aide d'un ordinateur} |
| 23 |
Un ordinateur est un ensemble de composants électriques. En fait ce sont beaucoup de circuits électriques avec des interrupteurs qui laissent le courant passer ou non. On a donc deux états par circuit 0 ou 1. |
| 24 |
Les nombres sont représentés à l'aide de ces deux états. Les nombres sont donc représentés uniquement par des 0 et des 1. L'ordinateur fonctionne en base 2 (nombre binaire 0 ou 1 à n bits). |
| 25 |
|
| 26 |
|
| 27 |
\subsection{Entiers positifs} |
| 28 |
L'entier positif $N$ en base 10 est représenté par $n$ bits en base 2: |
| 29 |
|
| 30 |
\begin{equation*} |
| 31 |
(N)_{10}=(a_{n-1}a_{n-2}a_{n-3}...a_2a_1a_0)_2 |
| 32 |
\end{equation*} |
| 33 |
Les $a_i$ sont les différents bits et valent 0 ou 1 et |
| 34 |
\begin{equation*} |
| 35 |
N=a_{n-1}*2^{n-1}+a_{n-2}*2^{n-2}+a_{n-3}*2^{n-3}+...+a_2*2^2+a_1*2^1+a_0*2^0 |
| 36 |
\end{equation*} |
| 37 |
|
| 38 |
Exemple : $(300)_{10}=(?)_2$ |
| 39 |
\begin{eqnarray*} |
| 40 |
\frac{300}{2}&=&150\quad reste\,0\quad a_0=0\\ |
| 41 |
\frac{150}{2}&=&75\quad reste\,0\quad a_1=0\\ |
| 42 |
\frac{75}{2}&=&37\quad reste\,1\quad a_2=1\\ |
| 43 |
\frac{37}{2}&=&18\quad reste\,1\quad a_3=1\\ |
| 44 |
\frac{18}{2}&=&9\quad reste\,0\quad a_4=0\\ |
| 45 |
\frac{9}{2}&=&4\quad reste\,1\quad a_5=1\\ |
| 46 |
\frac{4}{2}&=&2\quad reste\,0\quad a_6=0\\ |
| 47 |
\frac{2}{2}&=&1\quad reste\,0\quad a_7=0\\ |
| 48 |
\frac{1}{2}&=&0\quad reste\,1\quad a_8=1\\ |
| 49 |
\\soit \quad(300)_{10}&=&(100101100)_2 |
| 50 |
\\verification \quad(100101100)_2&=&1*2^8+1*2^5+1*2^3+1*2^2=256+32+8+4\\&=&300 |
| 51 |
\end{eqnarray*} |
| 52 |
|
| 53 |
|
| 54 |
\subsection{Fraction décimale} |
| 55 |
Une fraction décimale $f$ est un nombre réel compris entre 0 et 1. On a |
| 56 |
\begin{eqnarray*} |
| 57 |
(f)_{10}&=&(0,d_1d_2d_3..........)_2\\ |
| 58 |
ou\quad f&=&d_1*2^{-1}+d_2*2^{-2}+d_3*2^{-3}+...... |
| 59 |
\end{eqnarray*} |
| 60 |
De cette écriture on remarque que |
| 61 |
\begin{eqnarray*} |
| 62 |
2f&=&d_1+f_1\quad \quad f_1\quad nouvelle\quad fraction \quad decimale \\ |
| 63 |
2f_1=2(2f-d_1)&=&d_2+f_2 \quad \quad f_2\quad nouvelle\quad fraction \quad decimale \\ |
| 64 |
2f_2=2(2f1-d_2)&=&d_3+f_3 \quad \quad f_3\quad nouvelle\quad fraction \quad decimale \\ |
| 65 |
\end{eqnarray*} |
| 66 |
Exemple 1 : |
| 67 |
\begin{eqnarray*} |
| 68 |
f&=&0.0625\\ |
| 69 |
2f&=&0.1250=0+0.1250 \quad d_1=0\\ |
| 70 |
2(2f-d_1)&=&0.250=0+0.250 \quad d_2=0\\ |
| 71 |
2(2(2f-d_1)-d_2)&=&0.5=0+0.50 \quad d_3=0\\ |
| 72 |
2(2(2(2f-d_1)-d_2)-d_3)&=&1.=1+0. \quad d_4=1\\ |
| 73 |
\\Soit\quad(0.0625)_{10}=(0,0001)_2 |
| 74 |
\end{eqnarray*} |
| 75 |
Exemple 2 : |
| 76 |
\begin{eqnarray*} |
| 77 |
f&=&\frac{1}{3}\\ |
| 78 |
2f&=&\frac{2}{3}=0+\frac{2}{3} \quad d_1=0\\ |
| 79 |
2(2f-d_1)&=&\frac{4}{3}=1+\frac{1}{3} \quad d_2=1\\ |
| 80 |
2(2(2f-d_1)-d_2)&=&\frac{2}{3}=0+\frac{2}{3} \quad d_3=0\\ |
| 81 |
2(2(2(2f-d_1)-d_2)-d_3)&=&\frac{4}{3}=1+\frac{1}{3} \quad d_4=1\\ |
| 82 |
\\Soit\quad(\frac{1}{3})_{10}=(0,0101...)_2 |
| 83 |
\end{eqnarray*} |
| 84 |
Exemple 3 : |
| 85 |
\begin{eqnarray*} |
| 86 |
f&=&0.0626\\ |
| 87 |
2f&=&0.1252=0+0.1252 \quad d_1=0\\ |
| 88 |
2(2f-d_1)&=&0.2504=0+0.2504 \quad d_2=0\\ |
| 89 |
2(2(2f-d_1)-d_2)&=&0.5008=0+0.5008 \quad d_3=0\\ |
| 90 |
2(2(2(2f-d_1)-d_2)-d_3)&=&1.0016=1+0.0016 \quad d_4=1\\ |
| 91 |
2(2(2(2(2f-d_1)-d_2)-d_3)-d_4)&=&0.0032=0+0.0032 \quad d_5=0\\ |
| 92 |
2(2(2(2(2(2f-d_1)-d_2)-d_3)-d_4)-d_5)&=&0.0064=0+0.0064 \quad d_6=0\\ |
| 93 |
...&=&0.0128=0+0.0128 \quad d_7=0\\ |
| 94 |
...&=&0.0256=0+0.0256 \quad d_8=0\\ |
| 95 |
...&=&0.0512=0+0.0512 \quad d_9=0\\ |
| 96 |
...&=&0.1024=0+0.1024 \quad d_{10}=0\\ |
| 97 |
...&=&0.2048=0+0.2048 \quad d_{11}=0\\ |
| 98 |
...&=&0.4096=0+0.4096 \quad d_{12}=0\\ |
| 99 |
...&=&0.8192=0+0.8192 \quad d_{13}=0\\ |
| 100 |
...&=&1.6384=1+0.6384 \quad d_{14}=1\\ |
| 101 |
...&=&1.2768=1+0.2768 \quad d_{15}=1\\ |
| 102 |
...&=&0.5536=0+0.5536 \quad d_{16}=0\\ |
| 103 |
...&=&1.1072=1.+0.1072 \quad d_{17}=1\\ |
| 104 |
\\Soit\quad(0.0626)_{10}=(0,00010000000001101...)_2 |
| 105 |
\end{eqnarray*} |
| 106 |
Le premier exemple montre le cas d'une fraction avec un nombre fini de décimales en base 10 qui donne une représentation avec un nombre fini de bits en base 2.\\ |
| 107 |
Le deuxième exemple montre le cas d'une fraction avec un nombre infini de décimales en base 10 qui donne une représentation avec un nombre infini de bits en base 2.\\ |
| 108 |
Le troisième exemple montre le cas d'une fraction avec un nombre fini de décimales en base 10 qui donne une représentation avec un nombre infini de bits en base 2.\\ |
| 109 |
|
| 110 |
\emph{Pour sauvegarder une fraction décimale, l'ordinateur effectue une troncature pour toutes les fractions décimales dont le nombre de bits est infini en base 2. Il n'y a pas de correspondance entre le nombre de chiffres après la virgule en base 10 et en base 2. |
| 111 |
} |
| 112 |
|
| 113 |
\subsection{Entiers signés} |
| 114 |
Pour représenter un nombre entier signé, on utilise la représentation des entiers positifs et on ajoute une représentation |
| 115 |
\begin{itemize} |
| 116 |
\item par complément à 2 |
| 117 |
\item par excés |
| 118 |
\end{itemize} |
| 119 |
\subsubsection{Représentation par complément à 2} |
| 120 |
\begin{eqnarray*} |
| 121 |
N=-a_{n-1}*2^{n-1}+a_{n-2}*2^{n-2}+a_{n-3}*2^{n-3}+...+a_2*2^2+a_1*2^1+a_0*2^0 |
| 122 |
\end{eqnarray*} |
| 123 |
Si $N$ est positif $a_{n-1}=0$\\ |
| 124 |
Si $N$ est négatif $a_{n-1}=1$\\ |
| 125 |
exemple avec une représentation sur $n=4$ bits. |
| 126 |
\begin{eqnarray*} |
| 127 |
(0101)_2&=&-0*2^3+1*2^2+0*2^1+1*2^0=4+1=(5)_{10}\\ |
| 128 |
(1101)_2&=&-1*2^3+1*2^2+0*2^1+1*2^0=-8+4+1=(-3)_{10}\\ |
| 129 |
(-6)_{10}&=&-2^{n-1}+2=-2^3+2^1=(1010)_2 |
| 130 |
\end{eqnarray*} |
| 131 |
\subsubsection{Représentation par excés} |
| 132 |
Sur n bits on peut représenter $2^n$ entiers. On ajoute au nombre une valeur $d$. $-d$ représente le plus petit nombre entier représentable. |
| 133 |
En général $d=2^n$ ou $d=2^{n-1}$ .\\ |
| 134 |
Exemple avec 4 bits et $d=2^3=8$ |
| 135 |
\begin{eqnarray*} |
| 136 |
(0000)_2&=&0-d=(-8)_{10}\\ |
| 137 |
(0001)_2&=&1-d=(-7)_{10}\\ |
| 138 |
(0010)_2&=&2-d=(-6)_{10}\\ |
| 139 |
(0011)_2&=&3-d=(-5)_{10}\\ |
| 140 |
(0100)_2&=&4-d=(-4)_{10}\\ |
| 141 |
(0101)_2&=&5-d=(-3)_{10}\\ |
| 142 |
(0110)_2&=&6-d=(-2)_{10}\\ |
| 143 |
(0111)_2&=&7-d=(-1)_{10}\\ |
| 144 |
(1000)_2&=&8-d=(0)_{10}\\ |
| 145 |
(1001)_2&=&9-d=(1)_{10}\\ |
| 146 |
(1010)_2&=&10-d=(2)_{10}\\ |
| 147 |
(1011)_2&=&11-d=(3)_{10}\\ |
| 148 |
(1100)_2&=&12-d=(4)_{10}\\ |
| 149 |
(1101)_2&=&13-d=(5)_{10}\\ |
| 150 |
(1110)_2&=&14-d=(6)_{10}\\ |
| 151 |
(1111)_2&=&15-d=(7)_{10}\\ |
| 152 |
\end{eqnarray*} |
| 153 |
Exemple avec 8 bits et $d=2^7-1=127$ |
| 154 |
\begin{eqnarray*} |
| 155 |
(-100)_{10}&=&27-127=27-d\\ |
| 156 |
\end{eqnarray*} |
| 157 |
27 est le nombre à mettre en base 2.\\ |
| 158 |
\begin{eqnarray*} |
| 159 |
\frac{27}{2}&=&13 \quad reste \quad 1\\ |
| 160 |
\frac{13}{2}&=&6 \quad reste \quad 1\\ |
| 161 |
\frac{6}{2}&=&3 \quad reste \quad 0\\ |
| 162 |
\frac{3}{2}&=&1 \quad reste \quad 1\\ |
| 163 |
\frac{1}{2}&=&0 \quad reste \quad 1\\ |
| 164 |
Soit\quad(-100)_{10}&=&(11011)_2 |
| 165 |
\end{eqnarray*} |
| 166 |
Vérification : \\ |
| 167 |
\begin{eqnarray*} |
| 168 |
(11011)_2&=&2^4+2^3+2^1+2^0=16+8+2+1=27\\ |
| 169 |
(11011)_2&=&(27-d)_{10}=(27-127)_{10}=(-100)_{10} |
| 170 |
\end{eqnarray*} |
| 171 |
|
| 172 |
\subsection{Nombres réels} |
| 173 |
|
| 174 |
Un nombre réel $x$ s'écrit en notation flottante $x=\pm m*b^l$\\ |
| 175 |
$m$ est la mantisse.\\ |
| 176 |
$l$ est l'exposant.\\ |
| 177 |
\begin{eqnarray*} |
| 178 |
m&=&0,d_1d_2d_3...d_n...\\ |
| 179 |
m&=&d_1*b^{-1}+d_2*b^{-2}+d_3*b^{-3}+...+d_n*b^{-n}+... |
| 180 |
\end{eqnarray*} |
| 181 |
Le nombre de bits de la mantisse est limité donc on applique une troncature ou un arrondi : |
| 182 |
\begin{itemize} |
| 183 |
\item troncature : on limite le nombre de bits et on supprime le reste : $m=d_1*b^{-1}+d_2*b^{-2}+d_3*b^{-3}+...+d_n*b^{-n}$ |
| 184 |
\item arrondi : on ajoute $\frac{b}{2}$ au $(n+1)^{eme}$ bit et on fait une troncature à $n$ bits. |
| 185 |
\end{itemize} |
| 186 |
A l'aide de cette notation il y a une infinité de solution pour représenter un nombre réel. Une norme a été établie pour les ordinateurs : la norme IEEE-754. Pour les ordinateurs à 32 bits où 64 bits, il existe deux types de nombres reéls : |
| 187 |
\begin{itemize} |
| 188 |
\item les simples précisions (single ou float selon les langages) codés sur 32 bits. |
| 189 |
\item les doubles précisions (double dans les langages) codés sur 64 bits. |
| 190 |
\end{itemize} |
| 191 |
Un nombre simple précision s'écrit $(d_1d_2...d_{31}d_{32})_2$. On a alors |
| 192 |
\begin{itemize} |
| 193 |
\item $d_1$ est le bit de signe. |
| 194 |
\item $d_2...d_9$ sont les 8 bits de l'exposant avec un excès de $d=d^8-1=127$ |
| 195 |
\item $d_{10}...d_{32}$ sont les 23 bits de la mantisse normalisée. Le premier bit est à 1 et est non sauvegardé. |
| 196 |
\item $(d_1d_2...d_{31}d_{32})_2=(-1)^{d_1}2^{d_2...d_9}2^{-127}(1,d_{10}...d_{32})_2$ |
| 197 |
\end{itemize} |
| 198 |
Un nombre double précision s'écrit $(d_1d_2...d_{63}d_{64})_2$. On a alors |
| 199 |
\begin{itemize} |
| 200 |
\item $d_1$ est le bit de signe. |
| 201 |
\item $d_2...d_{12}$ sont les 11 bits de l'exposant avec un excès de $d=d^{11}-1=1023$ |
| 202 |
\item $d_{13}...d_{64}$ sont les 52 bits de la mantisse normalisée. Le premier bit est à 1 et est non sauvegardé. |
| 203 |
\item $(d_1d_2...d_{63}d_{64})_2=(-1)^{d_1}2^{d_2...d_{12}}2^{-1023}(1,d_{13}...d_{64})_2$ |
| 204 |
\end{itemize} |
| 205 |
La norme impose l'arrondi comme méthode de coupure.\\ |
| 206 |
Exemple : |
| 207 |
\begin{eqnarray*} |
| 208 |
(11000001111001000000000000000000)_2&=&(-1)^12^{(10000011)_2}2^{-127}(1,11001)_2\\ |
| 209 |
&=&(-1)^12^{(128+2+1)}2^{-127}(1+1*2^{-1}+1*2^{-2}+1*2^{-5})\\ |
| 210 |
&=&(-1)2^4(1+0.5+0.25+0.03125)\\ |
| 211 |
&=&-28.5 |
| 212 |
\end{eqnarray*} |
| 213 |
Validation : |
| 214 |
\begin{eqnarray*} |
| 215 |
-28.5&=&-28-0.5\\ |
| 216 |
(28)_{10}&=&(11100)_2\\ |
| 217 |
(0.5)_{10}&=&(0,1)_2\\ |
| 218 |
(-28.5)_{10}&=&(-1)^1(11100,1)_2\\ |
| 219 |
&=&(-1)^1(1.11001)_22^4\\ |
| 220 |
&=&(-1)^1(1.11001)_22^{131}2^{-127}\\ |
| 221 |
(131)_{10}&=&(10000011)_2\\ |
| 222 |
(-28.5)_{10}&=&(-1)^12^{(10000011)_2}2^{-127}(1.11001)\\ |
| 223 |
&=&(11000001111001000000000000000000)_2 |
| 224 |
\end{eqnarray*} |
| 225 |
|
| 226 |
Il existe quelques nombres flottants particuliers : |
| 227 |
\begin{itemize} |
| 228 |
\item $+0$ : tous les bits valent 0. |
| 229 |
\item $-0$ : Le bit de signe vaut 1 et tous les autres bits valent 0. |
| 230 |
\item $+\infty$ : Le bit de signe vaut 0, les bits de l'exposant valent 1 et tous les autres bits valent 0. |
| 231 |
\item $-\infty$ : Le bit de signe vaut 1, les bits de l'exposant valent 1 et tous les autres bits valent 0. |
| 232 |
\item $+NaN$ : Not a Number. Le bit de signe vaut 0, les bits de l'exposant valent 1 et un autre bit vaut 1. |
| 233 |
\item $-NaN$ : Not a Number. Le bit de signe vaut 1, les bits de l'exposant valent 1 et un autre bit vaut 1. |
| 234 |
\end{itemize} |
| 235 |
|
| 236 |
\subsection{Effet sur les calculs} |
| 237 |
|
| 238 |
En prenant l'exemple suivant : |
| 239 |
\begin{eqnarray*} |
| 240 |
\sum_{i=1}^{10000}1.0&=&10000.00000\\ |
| 241 |
\sum_{i=1}^{100000}0.1&=&9998.556640\quad en\quad simple\quad precision\\ |
| 242 |
\sum_{i=1}^{100000}0.1&=&10000.00000001885\quad en\quad double\quad precision\\ |
| 243 |
\end{eqnarray*} |
| 244 |
nous pouvons constater qu'il existe une influence de la représentation des nombres sur le résultat des calculs. Dans certains cas des simples calculs peuvent être erronés. Dans ce cas l'erreur provient du fait que $0.1$ est représenté par un nombre infini de bits en base $2$. Il y a donc $100000$ arrondis à faire avant de de faire la somme. |
| 245 |
|
| 246 |
\section[Ordinateur et représentation des nombres]{Prise en compte de la représentation des nombres dans l'utilisation d'un ordinateur} |
| 247 |
|
| 248 |
Les problèmes d'ingénierie nécessitent souvent l'utilisation d'un ordinateur pour se solutionner. Mais l'ordinateur fait nécessairement des erreurs de calculs. |
| 249 |
L'ingénieur doit dont utiliser un ordinateur en sachant et en assimilant le fait que l'ordinateur fait des erreurs de calculs. Il fait face à deux cas : |
| 250 |
\begin{itemize} |
| 251 |
\item il utilise le plus souvent des logiciels commerciaux. Dans ce cas une évaluation préalable du logiciel est nécessaire pour prendre en compte le traitement des erreurs. |
| 252 |
\item il doit construire un logiciel qui résout une problématique particulière à l'aide d'un logiciel de programmation. Dans ce cas la gestion des erreurs doit être réalisée en même temps que le calcul de la solution du problème. |
| 253 |
\end{itemize} |
| 254 |
|
| 255 |
Les erreurs commises à un moment du calcul se propagent dans le reste du calcul. Il faut savoir évaluer cette évolution de l'erreur au travers de tout le calcul. |
| 256 |
\\ |
| 257 |
Soit $x$ un nombre qui a été arrondi. Il y a une erreur sur sa représentation $x^*$ de $2\Delta x$. On a alors $x=x^*\pm\Delta x$. $x$ est utilisé dans un calcul quelconque $f(x)$. Nous voulons connaître l'erreur sur le résultat $\Delta f(x)$ du calcul en fonction de l'erreur sur $x$. |
| 258 |
On a donc : |
| 259 |
\begin{eqnarray*} |
| 260 |
\Delta f(x)&=&\mid f(x^*)-f(x)\mid\\ |
| 261 |
f(x)&=&f(x^*\pm \Delta x)=f(x^*)\pm f'(x^*)\Delta x+O((\Delta x)^2)\\ |
| 262 |
f(x)-f(x^*)&\simeq&\mid f'(x)\mid \Delta x\\ |
| 263 |
\Delta f(x)&=&\mid f'(x) \mid \Delta x\\ |
| 264 |
\end{eqnarray*} |
| 265 |
En réalisant le même calcul, on peut généraliser la propagation d'erreur si plusieurs valeurs sont concernées par le calcul : |
| 266 |
\begin{eqnarray*} |
| 267 |
\Delta f(x_1,x_2,...,x_n)=\left | \frac{\delta f(x_1,x_2,...,x_n)}{\delta x_1} \right | \Delta x_1+\left | \frac{\delta f(x_1,x_2,...,x_n)}{\delta x_2} \right | \Delta x_2+...+\left | \frac{\delta f(x_1,x_2,...,x_n)}{\delta x_n} \right | \Delta x_n |
| 268 |
\end{eqnarray*} |
| 269 |
|
| 270 |
|
| 271 |
\section{Logiciel de programmation} |
| 272 |
|
| 273 |
Le logiciel de programmation permet d'effectuer les calculs de solutions aux problèmes d'ingénierie en effectuant une gestion des erreurs adéquates. |
| 274 |
Les notions importantes de programmation sont les variables, les types, les fonctions, les sous routines, les arguments et les moyens d'interaction avec l'utilisateur. Ce sont les types de variables qui permettent de choisir une manière de représenter les nombres. Ce choix comme nous venons de voir est crucial : |
| 275 |
ainsi le nombre 1 s'écrit en notation flottante en simple précision : |
| 276 |
\begin{eqnarray*} |
| 277 |
(1)_{10}=(00111111100000000000000000000000)_2 |
| 278 |
\end{eqnarray*} |
| 279 |
alors qu'en entier non signé il s'ecrit : |
| 280 |
\begin{eqnarray*} |
| 281 |
(1)_{10}=(00000000000000000000000000000001)_2 |
| 282 |
\end{eqnarray*} |
| 283 |
Il faut être très rigoureux dans le choix des types et dans la comparaison des valeurs. |
| 284 |
\\Il peut être intéressant de connaître rapidement la précision d'un nombre flottant sur une machine informatique sans connaître exactement son architecture. Cet algorithme permet d'obtenir la précision d'une représentation flottante: |
| 285 |
\\ |
| 286 |
|
| 287 |
\begin{algorithm}[H] |
| 288 |
\SetAlgoLined |
| 289 |
\KwData{$\epsilon$} |
| 290 |
\KwResult{Précision d'un type flottant } |
| 291 |
$\epsilon=1$\\ |
| 292 |
\While{$\epsilon+1>1$} |
| 293 |
{ |
| 294 |
$\epsilon '=\epsilon$\\ |
| 295 |
$\epsilon=\frac{\epsilon}{2}$\\ |
| 296 |
} |
| 297 |
precision$=\epsilon '$\\ |
| 298 |
\caption{Calcul de la précision d'un flottant} |
| 299 |
\end{algorithm} |
| 300 |
\hspace{3cm}\\ |
| 301 |
\\ |
| 302 |
Les langages généralement utilisés pour mettre en oeuvre des méthodes numériques sont le C ou le fortran. Dans ce cours les langages utilisés sont le C ou le visual basic et les travaux sont réalisés selon le principe suivant : |
| 303 |
\begin{itemize} |
| 304 |
\item les datas sont enregistrées dans un fichier texte |
| 305 |
\item un programme console (sans interface graphique) qui permet de résoudre le problème. |
| 306 |
\item le résultat est écrit dans un fichier texte |
| 307 |
\end{itemize} |
| 308 |
\hspace{1cm}\\ |
| 309 |
Un exemple de programme est disponible dans le portail de cours : premierexemple.zip Il illustre le principe de programme console en effectuant simplement une table de multiplication. |
