| 1 |
|
| 2 |
%! TEX root |
| 3 |
\documentclass[a4paper,french]{article} |
| 4 |
\input{mp-geom2d-doc-preamb.tex} |
| 5 |
|
| 6 |
|
| 7 |
\begin{document} |
| 8 |
%% === Page de garde =================================================== |
| 9 |
\thispagestyle{empty} |
| 10 |
\begin{tikzpicture}[remember picture, overlay] |
| 11 |
\node[below right, shift={(-4pt,4pt)}] at (current page.north west) {% |
| 12 |
\includegraphics{fond.pdf}% |
| 13 |
}; |
| 14 |
\end{tikzpicture}% |
| 15 |
|
| 16 |
\noindent |
| 17 |
{\includegraphics{mp-geom2d}\\ |
| 18 |
\Large Paquet \MP{} pour des figures de géométrie plane}\\[1cm] |
| 19 |
\parbox{0.5\textwidth}{ |
| 20 |
\includegraphics[scale=0.86]{figure.pdf} |
| 21 |
}\hfill |
| 22 |
\parbox{0.5\textwidth}{\Large\raggedleft |
| 23 |
\textbf{Contributeurs}\\ |
| 24 |
Maxime \textsc{Chupin}\\ |
| 25 |
Jean-Michel \textsc{Sarlat} |
| 26 |
} |
| 27 |
\vfill |
| 28 |
\begin{center} |
| 29 |
Version \gddVersion\ du \printdate{\gddDate} \\ |
| 30 |
\url{https://gitlab.gutenberg-asso.fr/mchupin/mp-geom2d}\\ |
| 31 |
\url{https://ctan.org/pkg/mp-geom2d} |
| 32 |
\end{center} |
| 33 |
%% == Page de garde ==================================================== |
| 34 |
\newpage |
| 35 |
|
| 36 |
\tableofcontents |
| 37 |
|
| 38 |
\section{Objectif} |
| 39 |
|
| 40 |
\mpgeomdd a été écrit avec le but de proposer des macros \MP{} permettant |
| 41 |
de réaliser une figure de géométrie \emph{en collant} d'assez près |
| 42 |
à une description impérative: |
| 43 |
\begin{quote}\itshape |
| 44 |
Soit \(A\) le point de coordonnées (2,3).\\ |
| 45 |
Soit \(B\) le point de coordonnées (4,5).\\ |
| 46 |
Trace la droite \((A,B)\).\\ |
| 47 |
.... |
| 48 |
\end{quote} |
| 49 |
Dans ce cadre, les objets géométriques sont le plus souvent nommés |
| 50 |
(\(A\), \(B\), etc.) ou désignés par leur nature et leurs attributs |
| 51 |
(droite \((A,B)\), etc.). Pour ne pas avoir à dépasser ce mode de |
| 52 |
description, en particulier pour éviter d'avoir à déclarer le |
| 53 |
\emph{type} de ces objets, le choix a été fait de les identifier par |
| 54 |
un \emph{index}\footnote{Le type \typeMP{numeric}, qui est le type par |
| 55 |
défaut dans \MP, ne demande pas de déclaration préalable.} dans des |
| 56 |
tables qui en précisent les caractéristiques. |
| 57 |
|
| 58 |
\begin{Note} À ce jour, l'objectif n'est pas atteint, le |
| 59 |
développement est loin d'être achevé; il est encore nécessaire de |
| 60 |
faire appel à des commandes \MP{} ou à des \emph{macros |
| 61 |
intermédiaires} pour décrire une figure. Cela évoluera sans doute |
| 62 |
avec le temps, le temps de trouver une syntaxe satisfaisante... |
| 63 |
\end{Note} |
| 64 |
|
| 65 |
|
| 66 |
\section{Les fichiers} |
| 67 |
|
| 68 |
\mpgeomdd est un ensemble d'outils pour la géométrie plane avec |
| 69 |
\MP~\cite{ctan-metapost}. Cet |
| 70 |
ensemble est organisé en plusieurs fichiers : |
| 71 |
|
| 72 |
\begin{enumerate} |
| 73 |
\item \fichier{geom2d.mp} : c'est le fichier principal, qui charge tous les |
| 74 |
autres ; |
| 75 |
\item \fichier{geom2d-main.mp} : il contient |
| 76 |
les structures et fonctions générales ; |
| 77 |
\item \fichier{geom2d-arc.mp} : |
| 78 |
contient tout ce qui concerne les arcs de cercles ; |
| 79 |
\item \fichier{geom2d-c2d.mp} : |
| 80 |
contient tout ce qui concerne les courbes du second degré ; |
| 81 |
\item \fichier{geom2d-fct.mp} : |
| 82 |
contient quelques fonctions mathématiques usuelles ; |
| 83 |
\item \fichier{geom2d-lbl.mp} : |
| 84 |
contient les fonctions relatives aux labels ; |
| 85 |
\item \fichier{geom2d-plt.mp} : |
| 86 |
contient des fonctions facilitant la représentation de fonctions |
| 87 |
mathématiques ; |
| 88 |
\item \fichier{geom2d-rep.mp} |
| 89 |
contient différents outils pour le tracé de figure dans un repère ; |
| 90 |
\item \fichier{geom2d-tra.mp} |
| 91 |
contient les fonctions permettant de gérer la transparence (code |
| 92 |
emprunté à Anthony \bsc{Phan}) ; |
| 93 |
\item \fichier{geom2d-svgnames.mp} fournit les 150 couleurs de la spécification |
| 94 |
SVG. |
| 95 |
\end{enumerate} |
| 96 |
|
| 97 |
Nous allons, dans la suite, décrire plus en détail chacune de ces |
| 98 |
fonctions. Certaines fonctions s'appuient sur |
| 99 |
l'extension \fichier{graph.mp} présente dans toutes les bonnes |
| 100 |
distributions \TeX. |
| 101 |
|
| 102 |
\section{Principe général de fonctionnement} |
| 103 |
|
| 104 |
\mpgeomdd utilise des tables comme structure principale. Chaque objet est |
| 105 |
numéroté \emph{via} le compteur \variableGDD{gddO}, son type\footnote{Les types |
| 106 |
sont propres à \mpgeomdd et seront décrits plus tard.} est stocké dans |
| 107 |
la table \variableGDD{gddT[]} à la place \variableGDD{gddT[gddO]}. Les |
| 108 |
propriétés des objets sont définies dans, là encore, des tables de |
| 109 |
type \typeMP{numeric} qui sont \variableGDD{gddA[]}, \variableGDD{gddB[]}, |
| 110 |
\dots, \variableGDD{gddF[]}. |
| 111 |
|
| 112 |
Par exemple, pour un \typeGDD{Point} (type \mpgeomdd), la première coordonnée |
| 113 |
se trouve dans \variableGDD{gddA[]} et la seconde dans \variableGDD{gddB[]} |
| 114 |
(les autres tables ne sont pas utilisées pour un tel objet). |
| 115 |
|
| 116 |
Il y a trois tables particulières \variableGDD{gddP[]} qui est du type |
| 117 |
\typeMP{path}, \variableGDD{gddPX[][]} qui est sa version étendue, et \variableGDD{gddS[]} qui est du type |
| 118 |
\typeMP{string}. Nous verrons plus tard quelle est leur utilité. |
| 119 |
|
| 120 |
Bien entendu, lors d'une utilisation classique de \mpgeomdd, l'appel à |
| 121 |
toutes ces tables n'est pas chose courante. Les fonctions que nous |
| 122 |
allons décrire dans la suite de ce document permettent de ne pas |
| 123 |
avoir recours trop précisément à cette machinerie. |
| 124 |
|
| 125 |
|
| 126 |
\section{Tracés} |
| 127 |
|
| 128 |
\mpgeomdd fournit des macros pour tracer des objets. Une commande permet de tracer |
| 129 |
la plupart des objets de \mpgeomdd (qui sont décrits dans la |
| 130 |
section~\ref{sec:types}), ainsi que certains type \MP. Les exemples tout au long |
| 131 |
de la documentation permettront d'illustrer les commandes de tracé. |
| 132 |
|
| 133 |
Pour comprendre comment fonctionnent les représentations avec \mpgeomdd, il nous faut |
| 134 |
tout d'abord décrire le mécanisme de gestion des unités. |
| 135 |
|
| 136 |
\subsection{Unité} |
| 137 |
|
| 138 |
\mpgeomdd définit une unité générale avec la variable globale |
| 139 |
\lstinline+gddU+. Ce \typeMP{numeric} vaut par |
| 140 |
défaut \SI{1}{cm}. |
| 141 |
\begin{colourband} |
| 142 |
\macro|gddU| |
| 143 |
\index{gddU@\lstinline+gddU+} |
| 144 |
\end{colourband} |
| 145 |
\subsection{En place} |
| 146 |
|
| 147 |
Lors de l'utilisation des commandes de tracé, \mpgeomdd utilise la macro\label{gddEnPlace} |
| 148 |
\begin{colourband} |
| 149 |
\macro|gddEnPlace| |
| 150 |
\index{gddEnPlace@\lstinline+gddEnPlace+} |
| 151 |
\end{colourband} |
| 152 |
Cette macro permet de spécifier les transformations géométriques nécessaires au |
| 153 |
placement de l'objet, notamment le facteur d'échelle relatif à l'unité |
| 154 |
\lstinline+gddU+. |
| 155 |
|
| 156 |
En interne, cette macro est un \lstinline+scantoken+ de la variable globale |
| 157 |
\variableGDD{gddW}\index{gddW@\lstinline+gddW+} (\typeMP{string}) qui contient les transformations. |
| 158 |
|
| 159 |
\subsection{Commandes de tracés}\label{sec:trace} |
| 160 |
|
| 161 |
La macro de tracé la plus courante est la macro \lstinline+trace+. |
| 162 |
\begin{colourband} |
| 163 |
\macro|trace(«objet»)| |
| 164 |
\begin{description} |
| 165 |
\item[\meta{objet}:] |
| 166 |
\begin{itemize} |
| 167 |
\item pour le côté \MP, un \typeMP{path}, une |
| 168 |
\typeMP{picture} ou un \typeMP{pair}, et dans ce cas \lstinline+trace+ sera |
| 169 |
équivalent à \lstinline+draw+; |
| 170 |
\item du côté de \mpgeomdd, |
| 171 |
n'importe quel des 6 objets définis jusque là : \typeGDD{triangle}, |
| 172 |
\typeGDD{segment}, \typeGDD{droite}, \typeGDD{cercle}, \typeGDD{ellipse}, |
| 173 |
\typeGDD{parabole}, \typeGDD{hyperbole}, |
| 174 |
\typeGDD{polygone}, \typeGDD{chemin}, |
| 175 |
\typeGDD{courbe} ou \typeGDD{vecteur} (pour ce dernier, une flèche sera |
| 176 |
ajoutée à l'extrémité du vecteur). |
| 177 |
\end{itemize} |
| 178 |
\end{description}\index{trace@\lstinline+trace+} |
| 179 |
\end{colourband} |
| 180 |
|
| 181 |
Lorsque \lstinline+trace+ est utilisée sur un objet de \mpgeomdd, la macro fait |
| 182 |
appel à la commande \MP\ \lstinline+draw+ avec le mécanisme de mise en place |
| 183 |
décrit plus haut. |
| 184 |
|
| 185 |
\mpgeomdd fournit un tracé avec flèche faisant non plus appel à \lstinline+draw+ |
| 186 |
mais à \lstinline+drawarrow+. |
| 187 |
|
| 188 |
\begin{colourband} |
| 189 |
\macro|fleche(«objet»)| |
| 190 |
\begin{description} |
| 191 |
\item[\meta{objet}:] |
| 192 |
\begin{itemize} |
| 193 |
\item pour le côté \MP, un \typeMP{path}, une |
| 194 |
\typeMP{picture} ou un \typeMP{pair}, et dans ce cas \lstinline+trace+ sera |
| 195 |
équivalent à \lstinline+drawarrow+; |
| 196 |
\item du côté de \mpgeomdd, |
| 197 |
n'importe quel des 6 objets définis jusque là : \typeGDD{triangle}, |
| 198 |
\typeGDD{segment}, \typeGDD{droite}, \typeGDD{cercle}, \typeGDD{ellipse}, |
| 199 |
\typeGDD{polygone}, \typeGDD{chemin}, |
| 200 |
\typeGDD{courbe} ou \typeGDD{vecteur} (pour ce dernier, une flèche sera |
| 201 |
ajoutée à l'extrémité du vecteur). |
| 202 |
\end{itemize} |
| 203 |
\end{description}\index{fleche@\lstinline+fleche+} |
| 204 |
\end{colourband} |
| 205 |
|
| 206 |
On peut aussi colorier un objet grâce à la macro suivante. |
| 207 |
\begin{colourband} |
| 208 |
\macro|colorie(«objet»)| |
| 209 |
\begin{description} |
| 210 |
\item[\meta{objet}:] peut être: |
| 211 |
\begin{itemize} |
| 212 |
\item pour le côté \MP, uniquement un \typeMP{path} et dans ce cas \lstinline+trace+ sera équivalent à \lstinline+fill+; |
| 213 |
\item du côté de \mpgeomdd, |
| 214 |
n'importe quel objet coloriable : \typeGDD{triangle}, |
| 215 |
\typeGDD{cercle}, \typeGDD{ellipse}, \typeGDD{polygone}, \typeGDD{chemin}, ou |
| 216 |
\typeGDD{courbe}. |
| 217 |
\end{itemize} |
| 218 |
\end{description}\index{colorie@\lstinline+colorie+} |
| 219 |
\end{colourband} |
| 220 |
|
| 221 |
|
| 222 |
Les commandes de tracés de \mpgeomdd font appel aux macros de |
| 223 |
base de \MP : \lstinline+draw+ et \lstinline+fill+. Ainsi, pour spécifier la |
| 224 |
couleur, on pourra |
| 225 |
utiliser la commande \lstinline+withcolor+ ou bien la macro |
| 226 |
\lstinline+drawoptions+. |
| 227 |
|
| 228 |
|
| 229 |
On peut aussi colorier avec de la transparence avec la commande |
| 230 |
suivante. |
| 231 |
\begin{colourband} |
| 232 |
\macro|colorieAvecTransparence(«objet»,«couleur»,«coefficient de transparence»)| |
| 233 |
\begin{description} |
| 234 |
\item[\meta{objet}:] peut être: |
| 235 |
\begin{itemize} |
| 236 |
\item pour le côté \MP, uniquement un \typeMP{path} et dans ce cas \lstinline+trace+ sera équivalent à \lstinline+fill+; |
| 237 |
\item du côté de \mpgeomdd, |
| 238 |
n'importe quel objet coloriable : \typeGDD{triangle}, |
| 239 |
\typeGDD{cercle}, \typeGDD{ellipse}, \typeGDD{polygone}, \typeGDD{chemin}, ou |
| 240 |
\typeGDD{courbe}. |
| 241 |
\end{itemize} |
| 242 |
\item[\meta{couleur}:] est une \typeMP{color}. |
| 243 |
\item[\meta{coefficient de transparence}:] est un \typeMP{numeric} compris |
| 244 |
entre 0 et 1, 0 pour un coloriage opaque et 1 pour un coloriage invisible. |
| 245 |
\end{description}\index{colorieAvecTransparence@\lstinline+colorieAvecTransparence+} |
| 246 |
\end{colourband} |
| 247 |
|
| 248 |
En réalité, avec une utilisation \emph{classique}, on simule de |
| 249 |
la transparence avec le code emprunté à Anthony Phan : |
| 250 |
\url{http://www-math.univ-poitiers.fr/~phan/metalpha.html}. Si on utilise |
| 251 |
\mpgeomdd avec le package \package{luamplib}, la macro |
| 252 |
\lstinline+colorieAvecTransparence+ fait appel à la macro |
| 253 |
\lstinline+withtransparency+ qui utilise la transparence de \textsc{pdf} et est |
| 254 |
bien plus légère en calcul. Ainsi, un code pourra être compilable avec |
| 255 |
\texttt{luatex} et pas avec \texttt{mpost}. |
| 256 |
|
| 257 |
|
| 258 |
On pourra aussi hachurer une forme fermée\footnote{Le code est repris et adapté |
| 259 |
de l’ensemble de macros \texttt{geometriesyr16} de Christophe Poulain \url{https://melusine.eu.org/syracuse/poulecl/geometriesyr16/}.} avec la |
| 260 |
commande suivante : |
| 261 |
|
| 262 |
\begin{colourband} |
| 263 |
\macro|hachure(«objet»,«angle»,«espace»,«type»)|\return{\typeMP{image}} |
| 264 |
\begin{description} |
| 265 |
\item[\meta{objet}:] peut être: |
| 266 |
\begin{itemize} |
| 267 |
\item pour le côté \MP, uniquement un \typeMP{path} et dans ce cas \lstinline+trace+ sera équivalent à \lstinline+fill+; |
| 268 |
\item du côté de \mpgeomdd, |
| 269 |
n'importe quel objet \og{}coloriable\fg{} : \typeGDD{triangle}, |
| 270 |
\typeGDD{cercle}, \typeGDD{ellipse}, \typeGDD{polygone}, \typeGDD{chemin}, ou |
| 271 |
\typeGDD{courbe}. |
| 272 |
\end{itemize} |
| 273 |
\item[\meta{angle}:] est l’angle (\typeMP{numeric} en degré) des lignes de |
| 274 |
hachurage. |
| 275 |
\item[\meta{espace}:] est l’espace (\typeMP{numeric}) entre chaque ligne de |
| 276 |
hachurage (dans l’unité de \mpgeomdd, il ne faut donc pas mettre d’unité). |
| 277 |
\item[\meta{type}:] est le type de tracé. Si \meta{type}$=0$, les lignes |
| 278 |
seront en trait pleins, si \meta{type}$=1$, les lignes seront en traits |
| 279 |
pointillés (\lstinline+dashed evenly+), si \meta{type}$=2$, les lignes |
| 280 |
seront en traits d’axes, si \meta{type}$=3$, les lignes |
| 281 |
seront en traits pointillés avec des points (\lstinline+withdots+). Enfin, si |
| 282 |
\meta{type}$=4$, vous pouvez définir le \emph{schéma} de trait avec la command \lstinline+SchemaHachure+. |
| 283 |
\end{description}\index{hachure@\lstinline+hachure+} |
| 284 |
\end{colourband} |
| 285 |
|
| 286 |
Attention, la macro \lstinline+hachure+ retourne une \typeMP{image}, il faudra |
| 287 |
donc l’utiliser conjointement à la macro \lstinline+trace+. |
| 288 |
|
| 289 |
Pour utiliser le quatrième type de trait pour les hachures, il faudra définir |
| 290 |
son schéma (\emph{pattern}) à l’aide de la commande suivante. |
| 291 |
|
| 292 |
\begin{colourband} |
| 293 |
\macro|SchemaHachure(«schéma»)| |
| 294 |
\begin{description} |
| 295 |
\item[\meta{schéma}:] est le \emph{pattern} que l’on fournit classiquement à |
| 296 |
la commande \lstinline+dashpattern+. Nous renvoyons à la documentation de |
| 297 |
\MP{}. Notez cependant que les dimensions à fournir aux commandes |
| 298 |
\lstinline+on+ et \lstinline+off+ seront mis à l’échelle à l’unité |
| 299 |
\lstinline+gddU+ de \mpgeomdd. Il faut donc les consevoir comme exprimées dans |
| 300 |
l’unité de \mpgeomdd. |
| 301 |
\end{description}\index{SchemaHachure@\lstinline+SchemaHachure+} |
| 302 |
\end{colourband} |
| 303 |
|
| 304 |
Nous illustrons |
| 305 |
ci-dessous quelques commandes de tracé, de coloriage et de hachurage. |
| 306 |
|
| 307 |
\begin{ExempleMP} |
| 308 |
input geom2d; |
| 309 |
|
| 310 |
beginfig(1); |
| 311 |
gddU:=0.6cm; |
| 312 |
A = Point(-1,1); B = Point(3,2); |
| 313 |
C1= Cercle(origine,2); |
| 314 |
C2 = Cercle(A,2); C3 = Cercle(B,3); |
| 315 |
|
| 316 |
colorie C1 withcolor LightCyan; |
| 317 |
colorieAvecTransparence(C2,DarkRed,0.2); |
| 318 |
colorieAvecTransparence(C3,DarkBlue,0.2); |
| 319 |
|
| 320 |
T1 = Triangle((-1,-2),(2,-2),(0.2,1)); |
| 321 |
trace hachure(T1,45,0.2,0) avecCrayon(0.6,DarkRed); |
| 322 |
trace T1; |
| 323 |
pE1 = Point(-2,-3); |
| 324 |
pE2 = Point(3,-4); |
| 325 |
E = EllipseF(pE1,pE2,3.9); |
| 326 |
SchemaHachure(on0.2 off0.3); |
| 327 |
trace hachure(E,-20,0.1,4); |
| 328 |
trace E; |
| 329 |
pointe pE1; pointe pE2; |
| 330 |
endfig; |
| 331 |
\end{ExempleMP} |
| 332 |
|
| 333 |
|
| 334 |
Les macros ci-dessus, font appel à une macro plus bas niveau qui permet de |
| 335 |
retourner le \typeMP{path} à tracer ou colorier pour tous les objets \mpgeomdd. |
| 336 |
|
| 337 |
\begin{colourband} |
| 338 |
\macro|gddTraceObjet(«objet»)|\return{\typeMP{path}} |
| 339 |
\begin{description} |
| 340 |
\item[\meta{objet}:] |
| 341 |
\typeGDD{triangle}, \typeGDD{segment}, \typeGDD{vecteur}, |
| 342 |
\typeGDD{cercle}, \typeGDD{ellipse}, \typeGDD{parabole}, \typeGDD{hyperbole},\typeGDD{polygone}, \typeGDD{chemin}, ou |
| 343 |
\typeGDD{courbe}. |
| 344 |
\end{description}\index{gddTraceObjet@\lstinline+gddTraceObjet+} |
| 345 |
\end{colourband} |
| 346 |
|
| 347 |
Si l'objet n'est pas fermé, \mpgeomdd fournit la macro suivante qui ajoute un |
| 348 |
\lstinline+--cycle+ à la suite du chemin : |
| 349 |
\begin{colourband} |
| 350 |
\macro|fermeture(«objet»)|\return{\typeMP{path}}\indication{fermé \lstinline+--cycle+} |
| 351 |
\begin{description} |
| 352 |
\item[\meta{objet}:] |
| 353 |
\begin{itemize} |
| 354 |
\item du côté de \MP, \typeMP{path} ; |
| 355 |
\item du côté de \mpgeomdd, \typeGDD{triangle}, \typeGDD{segment}, \typeGDD{vecteur}, |
| 356 |
\typeGDD{cercle}, \typeGDD{chemin}, ou |
| 357 |
\typeGDD{courbe}. |
| 358 |
\end{itemize} |
| 359 |
\end{description}\index{fermeture@\lstinline+fermeture+} |
| 360 |
\end{colourband} |
| 361 |
|
| 362 |
On pourra spécifier le \emph{crayon} utilisé pour les tracés avec la commande |
| 363 |
suivante: |
| 364 |
|
| 365 |
\begin{colourband} |
| 366 |
\macro|avecCrayon(«taille»,«couleur»)| |
| 367 |
\begin{description} |
| 368 |
\item[\meta{taille}:] facteur d'échelle \typeMP{numeric} du \typeMP{pen} |
| 369 |
\lstinline+pencircle+ de \MP{} utilisé ; |
| 370 |
\item[\meta{couleur}:] couleur \typeMP{color} à utiliser. |
| 371 |
\end{description}\index{avecCrayon@\lstinline+avecCrayon+} |
| 372 |
\end{colourband} |
| 373 |
|
| 374 |
Cette macro est un raccourci pour le \emph{classique} \texttt{withpen |
| 375 |
pencircle scaled ... withcolor ...}. On peut d'ailleurs évidemment toujours |
| 376 |
utiliser les commandes \MP{} pour le dessin. |
| 377 |
|
| 378 |
|
| 379 |
|
| 380 |
|
| 381 |
On peut représenter les objets de type \typeGDD{point}. Pour cela, on dispose |
| 382 |
d'une commande qui trace un petit cercle coloré à l'endroit du point. La |
| 383 |
commande est la suivante : |
| 384 |
|
| 385 |
\begin{colourband} |
| 386 |
\macro|pointe(«point»)| |
| 387 |
\begin{description} |
| 388 |
\item[\meta{point}:] \typeGDD{point} ou \typeMP{pair} |
| 389 |
\end{description}\index{pointe@\lstinline+pointe+} |
| 390 |
\end{colourband} |
| 391 |
|
| 392 |
Cette macro utilise trois paramètres internes de \mpgeomdd pour la taille, la |
| 393 |
couleur et le type de marque utilisés |
| 394 |
(\lstinline+gddTaillePoint+\index{gddTaillePoint@\lstinline+gddTaillePoint+}, \lstinline+gddCouleurPoint+\index{gddCouleurPoint@\lstinline+gddCouleurPoint+} |
| 395 |
et \lstinline+gddPointeType+ \index{gddPointeType@\lstinline+gddPointeType+} |
| 396 |
). Ces paramètres peuvent être modifiés avec les commandes suivantes: |
| 397 |
\begin{colourband} |
| 398 |
\macro|ParametreTaillePoint(«n»)| |
| 399 |
\begin{description} |
| 400 |
\item[\meta{n}:] \typeMP{numeric}, valeur par défaut 3. |
| 401 |
\end{description} |
| 402 |
\index{ParametreTaillePoint@\lstinline+ParametreTaillePoint+} |
| 403 |
\end{colourband} |
| 404 |
|
| 405 |
\begin{colourband} |
| 406 |
\macro|ParametreCouleurPoint(«c»)| |
| 407 |
\begin{description} |
| 408 |
\item[\meta{c}:] \typeMP{color}, valeur par défaut \lstinline+white+. |
| 409 |
\end{description} |
| 410 |
\index{ParametreCouleurPoint@\lstinline+ParametreCouleurPoint+} |
| 411 |
\end{colourband} |
| 412 |
|
| 413 |
Il existe deux autres types de pointage de point : la simple croix et le simple |
| 414 |
disque. Pour choisir un autre type de pointage (en utilisant la même commande |
| 415 |
\lstinline+pointe+), on utilisera la commande suivante: |
| 416 |
\begin{colourband} |
| 417 |
\macro|ParametrePointeType(«s»)| |
| 418 |
\begin{description} |
| 419 |
\item[\meta{s}:] \typeMP{string}, peut valoir \lstinline+pointe+ |
| 420 |
(fonctionnement par défaut avec un cercle noir rempli d’une autre couleur, |
| 421 |
blanc par défaut), \lstinline+"croix"+ (pour une simple croix) ou |
| 422 |
\lstinline+"disque"+ (pour un disque plein). |
| 423 |
\end{description} |
| 424 |
\index{ParametrePointeType@\lstinline+ParametrePointeType+} |
| 425 |
\end{colourband} |
| 426 |
|
| 427 |
Il arrive régulièrement que l’on veuille pointer une liste de |
| 428 |
points\footnote{Sur une idée d’Alain Matthes.}. Pour cela, |
| 429 |
on dispose de la commande suivante: |
| 430 |
|
| 431 |
\begin{colourband} |
| 432 |
\macro|pointes(«pointA», «pointB», «pointC», etc.)| |
| 433 |
\begin{description} |
| 434 |
\item[\meta{pointA}, \meta{pointB}, etc.:] liste de \typeGDD{point} ou |
| 435 |
\typeMP{pair} séparés par des virgules. |
| 436 |
\end{description}\index{pointes@\lstinline+pointes+} |
| 437 |
\end{colourband} |
| 438 |
|
| 439 |
|
| 440 |
\subsection{Contenir les tracés} |
| 441 |
|
| 442 |
Il est souvent nécessaire de restreindre les tracés à une zone du plan $\R^2$. |
| 443 |
Pour cela, \mpgeomdd fournit la commande \lstinline+Fenetre+: |
| 444 |
\begin{colourband} |
| 445 |
\macro|Fenetre(«Xmin»,«Ymin»,«Xmax»,«Ymin»)| |
| 446 |
\index{Fenetre@\lstinline+Fenetre+} |
| 447 |
\end{colourband} |
| 448 |
Cette fonction trace un rectangle dont deux sommets opposés sont les points |
| 449 |
\lstinline|(Xmin,Ymin)| et \lstinline|(Xmax,Ymax)| avec la couleur \MP{} |
| 450 |
\lstinline+background+ et découpe l'image courante autour de ce cadre (avec la |
| 451 |
commande \MP{} \lstinline+clip currentpicture+). |
| 452 |
|
| 453 |
On pourra aussi restreindre les tracés à l’intérieur d’un chemin fermé issu |
| 454 |
d’un objet \mpgeomdd. Pour cela, on utilisera la commande suivante: |
| 455 |
\begin{colourband} |
| 456 |
\macro|gddClip(«Objet»)| |
| 457 |
\begin{description} |
| 458 |
\item[\meta{Objet}:] tout objet \mpgeomdd \enquote{fermé}. |
| 459 |
\end{description} |
| 460 |
\index{gddClip@\lstinline+gddClip+} |
| 461 |
\end{colourband} |
| 462 |
|
| 463 |
En interne, la macro \lstinline|Fenetre| modifie la variable \hologo{MetaPost} |
| 464 |
\lstinline+extra_endfig+. Pour vider cette chaîne de caractère, on pourra |
| 465 |
utiliser la commande suivante: |
| 466 |
\begin{colourband} |
| 467 |
\macro|FinFenetre| |
| 468 |
\index{FinFenetre@\lstinline+FinFenetre+} |
| 469 |
\end{colourband} |
| 470 |
|
| 471 |
\section{Les types}\label{sec:types} |
| 472 |
|
| 473 |
\mpgeomdd, fournit plusieurs types d'objets. Le type d'objet est |
| 474 |
stocké dans la table \variableGDD{gddT[]}, et les tables \variableGDD{gddA[]} |
| 475 |
à \variableGDD{gddF[]}, ainsi que la table \variableGDD{gddX} contiennent les propriétés des objets. |
| 476 |
|
| 477 |
Nous allons ici décrire chaque type de l'extension \mpgeomdd, |
| 478 |
leurs propriétés respectives, ainsi que des méthodes associées directement à |
| 479 |
l'objet. |
| 480 |
|
| 481 |
\subsection{Le type \typeGDD{point}} |
| 482 |
|
| 483 |
Ce type correspond au point de |
| 484 |
l'espace euclidien. |
| 485 |
|
| 486 |
\subsubsection{Constructeur} |
| 487 |
|
| 488 |
Pour être plus clair, voici la fonction principale |
| 489 |
pour créer un tel objet : |
| 490 |
% |
| 491 |
\begin{mpcode} |
| 492 |
vardef Point(expr a,b) = |
| 493 |
gddT[incr gddO] = "point"; |
| 494 |
gddA[gddO] = a; gddB[gddO] = b; gddO |
| 495 |
enddef; |
| 496 |
\end{mpcode} |
| 497 |
|
| 498 |
\begin{colourband} |
| 499 |
\macro|Point(«x»,«y»)|\return{\typeGDD{point}} |
| 500 |
\begin{description} |
| 501 |
\item[\meta{x}:] \typeMP{numeric} ; |
| 502 |
\item[\meta{y}:] \typeMP{numeric}. |
| 503 |
\end{description}\index{Point@\lstinline+Point+} |
| 504 |
\end{colourband} |
| 505 |
\bigskip |
| 506 |
|
| 507 |
|
| 508 |
Cette fonction \og{}retourne\fg{} le compteur \variableGDD{gdd0} et crée dans la |
| 509 |
table de type une entrée \typeGDD{point} et les attributs (coordonnées) |
| 510 |
correspondants \variableGDD{a} et \variableGDD{b} dans les tables |
| 511 |
\variableGDD{gddA} et \variableGDD{gddB}. |
| 512 |
|
| 513 |
Avec un tel type de fonctionnement, la plupart des manipulations se |
| 514 |
font sur des \typeMP{numeric}s. En effet, pour déclarer un |
| 515 |
\typeGDD{point}, il suffit d'écrire |
| 516 |
\begin{mpcode} |
| 517 |
A = Point(2,3); |
| 518 |
\end{mpcode} |
| 519 |
\variableGDD{A} prend alors la valeur courante de \variableGDD{gddO}. C'est |
| 520 |
l'identifiant du point. |
| 521 |
|
| 522 |
On peut aussi définir un \typeGDD{point} par ses coordonnées \emph{polaires} |
| 523 |
avec la commande suivante. |
| 524 |
|
| 525 |
\begin{colourband} |
| 526 |
\macro|PointPolaire(«r»,«a»)|\return{\typeGDD{point}} |
| 527 |
\begin{description} |
| 528 |
\item[\meta{r}:] \typeMP{numeric}, module du point; |
| 529 |
\item[\meta{a}:] \typeMP{numeric}, angle par rapport à l'axe des abscisses. |
| 530 |
\end{description}\index{PointPolaire@\lstinline+PointPolaire+} |
| 531 |
\end{colourband} |
| 532 |
\bigskip |
| 533 |
|
| 534 |
|
| 535 |
|
| 536 |
On peut définir un point dans un repère défini lui par un point |
| 537 |
d'origine et deux vecteurs avec la fonction suivante: |
| 538 |
\begin{colourband} |
| 539 |
\macro|PointDansRepere(«x»,«y»,«o»,«i»,«j»)|\return{\typeGDD{point}} |
| 540 |
\begin{description} |
| 541 |
\item[\meta{x}:] \typeMP{numeric} ; |
| 542 |
\item[\meta{y}:] \typeMP{numeric} ; |
| 543 |
\item[\meta{o}:] \typeGDD{point} d'origine du repère ; |
| 544 |
\item[\meta{i}:] \typeGDD{vecteur} (ou \typeGDD{point}) définissant l'axe des abscisses ; |
| 545 |
\item[\meta{j}:] \typeGDD{vecteur} (ou \typeGDD{point}) définissant l'axe des ordonnées. |
| 546 |
\end{description}\index{PointDansRepere@\lstinline+PointDansRepere+} |
| 547 |
\end{colourband} |
| 548 |
|
| 549 |
\bigskip |
| 550 |
|
| 551 |
Le code suivant illustre l'utilisation de cette commande (avec des |
| 552 |
\typeGDD{point}s au lieu de \typeGDD{vecteur}s, type décrit plus tard). |
| 553 |
\begin{mpcode} |
| 554 |
O = Point(0,0); |
| 555 |
I = Point(2,0); |
| 556 |
J = Point(0,3); |
| 557 |
A = PointDansRepere(2,3,O,I,J); |
| 558 |
\end{mpcode} |
| 559 |
|
| 560 |
|
| 561 |
\subsubsection{Macros associées} |
| 562 |
|
| 563 |
On peut récupérer l'abscisse et l'ordonnée d'un point avec les commandes |
| 564 |
suivantes : |
| 565 |
\begin{colourband} |
| 566 |
\macro|Abscisse(«a»)|\return{\typeMP{numeric}} |
| 567 |
\begin{description} |
| 568 |
\item[\meta{a}:] \typeGDD{point}, \typeGDD{vecteur} ou \typeMP{pair}. |
| 569 |
\end{description}\index{Abscisse@\lstinline+Abscisse+} |
| 570 |
\end{colourband} |
| 571 |
|
| 572 |
\begin{colourband} |
| 573 |
\macro|Ordonnee(«a»)|\return{\typeMP{numeric}} |
| 574 |
\begin{description} |
| 575 |
\item[\meta{a}:] \typeGDD{point}, \typeGDD{vecteur} ou \typeMP{pair}. |
| 576 |
\end{description}\index{Ordonnee@\lstinline+Ordonnee+} |
| 577 |
\end{colourband} |
| 578 |
|
| 579 |
On pourra ajouter les abscisses, les ordonnées ou bien, à la manière des |
| 580 |
vecteurs, des points entre eux avec les commandes suivantes. |
| 581 |
\begin{colourband} |
| 582 |
\macro|AdditionAbscisses(«a»,«b»)|\return{\typeMP{numeric}} |
| 583 |
\begin{description} |
| 584 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 585 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}. |
| 586 |
\end{description}\index{AdditionAbscisses@\lstinline+AdditionAbscisses+} |
| 587 |
\end{colourband} |
| 588 |
\begin{colourband} |
| 589 |
\macro|AdditionOrdonnee(«a»,«b»)|\return{\typeMP{numeric}} |
| 590 |
\begin{description} |
| 591 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 592 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}. |
| 593 |
\end{description}\index{AdditionOrdonnee@\lstinline+AdditionOrdonnee+} |
| 594 |
\end{colourband} |
| 595 |
et |
| 596 |
\begin{colourband} |
| 597 |
\macro|Addition(«a»,«b»)|\return{\typeGDD{point}} |
| 598 |
\begin{description} |
| 599 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 600 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}. |
| 601 |
\end{description}\index{Addition@\lstinline+Addition+} |
| 602 |
\end{colourband} |
| 603 |
|
| 604 |
On peut aussi calculer la longueur entre deux points grâce à la commande |
| 605 |
suivante: |
| 606 |
\begin{colourband} |
| 607 |
\macro|Longueur(«a»,«b»)|\return{\typeMP{numeric}} |
| 608 |
\begin{description} |
| 609 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 610 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}. |
| 611 |
\end{description}\index{Longueur@\lstinline+Longueur+} |
| 612 |
\end{colourband} |
| 613 |
|
| 614 |
On peut calculer le point équidistant de deux points, le milieu : |
| 615 |
\begin{colourband} |
| 616 |
\macro|Milieu(«a»,«b»)|\return{\typeGDD{point}} |
| 617 |
\begin{description} |
| 618 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 619 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}. |
| 620 |
\end{description}\index{Milieu@\lstinline+Milieu+} |
| 621 |
\end{colourband} |
| 622 |
|
| 623 |
On peut réaliser la rotation d'un point autour de l'origine $(0,0)$ avec la |
| 624 |
commande suivante: |
| 625 |
\begin{colourband} |
| 626 |
\macro|Rotation(«a»,«b»)|\return{\typeGDD{point}} |
| 627 |
\begin{description} |
| 628 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 629 |
\item[\meta{b}:] \typeMP{numeric}, l'angle de rotation en radian. |
| 630 |
\end{description}\index{Rotation@\lstinline+Rotation+} |
| 631 |
\end{colourband} |
| 632 |
|
| 633 |
Si on veut réaliser la rotation d'un point autour d'un autre, on utilisera la |
| 634 |
commande suivante: |
| 635 |
\begin{colourband} |
| 636 |
\macro|RotationCentre(«a»,«b»,«c»)|\return{\typeGDD{point}} |
| 637 |
\begin{description} |
| 638 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 639 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}, centre de rotation; |
| 640 |
\item[\meta{c}:] \typeMP{numeric}, l'angle de rotation en radian. |
| 641 |
\end{description}\index{RotationCentre@\lstinline+RotationCentre+} |
| 642 |
\end{colourband} |
| 643 |
|
| 644 |
On peut calculer l'isobarycentre d'une liste de points (ou de \typeMP{pair} de \MP) avec la commande suivante. |
| 645 |
\begin{colourband} |
| 646 |
\macro|IsoBarycentre(«a»,«b»,«c», etc.)|\return{\typeGDD{point}} |
| 647 |
\begin{description} |
| 648 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}; |
| 649 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair} ; |
| 650 |
\item[] etc. |
| 651 |
\end{description}\index{IsoBarycentre@\lstinline+IsoBarycentre+} |
| 652 |
\end{colourband} |
| 653 |
|
| 654 |
On peut calculer le barycentre d'une liste de points associés à des poids (mais |
| 655 |
ici, il n'est pas possible d'utiliser des \typeMP{pair} de \MP). |
| 656 |
\begin{colourband} |
| 657 |
\macro|Barycentre((«A»,«a»),(«B»,«b»),(«C»,«c»), etc.)|\return{\typeGDD{point}} |
| 658 |
\begin{description} |
| 659 |
\item[\meta{A}:] \typeGDD{point} ; |
| 660 |
\item[\meta{a}:] \typeMP{numeric}, poids associé à \meta{A} ; |
| 661 |
\item[\meta{B}:] \typeGDD{point} ; |
| 662 |
\item[\meta{b}:] \typeMP{numeric}, poids associé à \meta{B} ; |
| 663 |
\item[] etc. |
| 664 |
\end{description}\index{Barycentre@\lstinline+Barycentre+} |
| 665 |
\end{colourband} |
| 666 |
|
| 667 |
|
| 668 |
On peut déterminer la bissectrice d'un secteur angulaire défini par trois |
| 669 |
points. La fonction retourne une \typeGDD{droite}. |
| 670 |
\begin{colourband} |
| 671 |
\macro|Bissectrice(«A»,«B»,«C»)|\return{\typeGDD{droite}} |
| 672 |
\begin{description} |
| 673 |
\item[\meta{A}:] \typeGDD{point} ; |
| 674 |
\item[\meta{B}:] \typeGDD{point} ; |
| 675 |
\item[\meta{C}:] \typeGDD{point}. |
| 676 |
\end{description}\index{Bissectrice@\lstinline+Bissectrice+} |
| 677 |
\end{colourband} |
| 678 |
|
| 679 |
\begin{ExempleMP} |
| 680 |
input geom2d; |
| 681 |
beginfig(1); |
| 682 |
A = Point(1,0); |
| 683 |
B = Point(0,0); |
| 684 |
C = Point(1,1); |
| 685 |
D = Bissectrice(A,B,C); |
| 686 |
trace D; |
| 687 |
marque.bot "A"; |
| 688 |
marque.bot "B"; |
| 689 |
marque.bot "C"; |
| 690 |
Fenetre(-0.5,-0.5,2,2); |
| 691 |
endfig; |
| 692 |
\end{ExempleMP} |
| 693 |
|
| 694 |
|
| 695 |
Le type \typeGDD{point} est évidemment lié au type \MP{} \typeMP{pair}. |
| 696 |
|
| 697 |
\mpgeomdd fournit des macros qui permettent de passer de \typeGDD{point} à |
| 698 |
\typeMP{pair} et réciproquement. |
| 699 |
\begin{colourband} |
| 700 |
\macro|PointTOPair(«a»,«b»)|\return{\typeMP{pair}} |
| 701 |
\begin{description} |
| 702 |
\item[\meta{a}:] \typeMP{numeric}, abscisse ; |
| 703 |
\item[\meta{b}:] \typeMP{numeric}, ordonnée. |
| 704 |
\end{description}\index{PointTOPair@\lstinline+PointTOPair+} |
| 705 |
\end{colourband} |
| 706 |
|
| 707 |
|
| 708 |
\begin{colourband} |
| 709 |
\macro|PairTOPoint(«p»)|\return{\typeGDD{point}} |
| 710 |
\begin{description} |
| 711 |
\item[\meta{p}:] \typeMP{pair}. |
| 712 |
\end{description}\index{PairTOPoint@\lstinline+PairTOPoint+} |
| 713 |
\end{colourband} |
| 714 |
|
| 715 |
Ces deux commandes sont complétées par deux autres qui assurent qu'un élément est |
| 716 |
d'un type donné: |
| 717 |
\begin{colourband} |
| 718 |
\macro|PairImp(«p»)|\return{\typeGDD{pair}} |
| 719 |
\begin{description} |
| 720 |
\item[\meta{p}:] \typeGDD{point} ou \typeMP{pair}. |
| 721 |
\end{description}\index{PairImp@\lstinline+PairImp+} |
| 722 |
\end{colourband} |
| 723 |
|
| 724 |
|
| 725 |
\begin{colourband} |
| 726 |
\macro|PointImp(«p»)|\return{\typeGDD{point}} |
| 727 |
\begin{description} |
| 728 |
\item[\meta{p}:] \typeGDD{point} ou \typeMP{pair}. |
| 729 |
\end{description}\index{PointImp@\lstinline+PointImp+} |
| 730 |
\end{colourband} |
| 731 |
|
| 732 |
On peut aussi récupérer un point le long d'un objet \mpgeomdd (décrit dans les |
| 733 |
sections suivantes). La macro suivante retourne un \typeGDD{point} le long du |
| 734 |
chemin (cyclique ou non) de l'objet le paramétrant entre 0 et 1. |
| 735 |
|
| 736 |
\begin{colourband} |
| 737 |
\macro|PointDe(«o»,«t»)|\return{\typeGDD{point}} |
| 738 |
\begin{description} |
| 739 |
\item[\meta{o}:] n'importe quel objet \mpgeomdd (même un \typeGDD{point} pour |
| 740 |
lequel lui-même est retourné); |
| 741 |
\item[\meta{t}:] \typeMP{numeric} compris entre 0 et 1 (qui paramètre le |
| 742 |
chemin de l'objet entre 0 et 1). |
| 743 |
\end{description}\index{PointDe@\lstinline+PointDe+} |
| 744 |
\end{colourband} |
| 745 |
|
| 746 |
|
| 747 |
|
| 748 |
\subsection{Le type \typeGDD{vecteur}} |
| 749 |
|
| 750 |
Ce type correspond aux vecteurs |
| 751 |
définis à l'aide de deux coordonnées de l'espace euclidien. |
| 752 |
|
| 753 |
\subsubsection{Constructeurs} |
| 754 |
|
| 755 |
La fonction |
| 756 |
créatrice d'un tel objet est celle-ci |
| 757 |
% |
| 758 |
\begin{mpcode} |
| 759 |
vardef Vecteur(expr a,b) = |
| 760 |
save n; n = incr gddO; |
| 761 |
gddT[n] = "vecteur"; gddA[n] = a; gddB[n] = b; n |
| 762 |
enddef; |
| 763 |
\end{mpcode} |
| 764 |
|
| 765 |
\begin{colourband} |
| 766 |
\macro|Vecteur(«a»,«b»)|\return{\typeGDD{vecteur}} |
| 767 |
\begin{description} |
| 768 |
\item[\meta{a}:] \typeMP{numeric} ; |
| 769 |
\item[\meta{b}:] \typeMP{numeric}. |
| 770 |
\end{description}\index{Vecteur@\lstinline+Vecteur+} |
| 771 |
\end{colourband} |
| 772 |
\bigskip |
| 773 |
|
| 774 |
Cette fonction a la même architecture que celle correspondante au |
| 775 |
\typeGDD{point} : elle retourne la valeur courante de \variableGDD{gddO} |
| 776 |
après incrémentation, puis affecte le type \typeGDD{vecteur} à |
| 777 |
l'entrée correspondante dans la table \variableGDD{gddT}. |
| 778 |
|
| 779 |
On peut aussi définir un vecteur à partir d'un \typeMP{pair} \MP. |
| 780 |
\begin{mpcode} |
| 781 |
vardef VecteurP(expr a) = |
| 782 |
save n; n = incr gddO; |
| 783 |
gddT[n] = "vecteur"; gddA[n] = xpart a; gddB[n] = ypart a; n |
| 784 |
enddef; |
| 785 |
\end{mpcode} |
| 786 |
|
| 787 |
\begin{colourband} |
| 788 |
\macro|VecteurP(«a»)|\return{\typeGDD{vecteur}} |
| 789 |
\begin{description} |
| 790 |
\item[\meta{a}:] \typeMP{pair}. |
| 791 |
\end{description}\index{VecteurP@\lstinline+VecteurP+} |
| 792 |
\end{colourband} |
| 793 |
\bigskip |
| 794 |
|
| 795 |
Un vecteur peut se définir alors comme ceci: |
| 796 |
\begin{ExempleMP} |
| 797 |
input geom2d; |
| 798 |
beginfig(1); |
| 799 |
AB = Vecteur(2,3); |
| 800 |
pair a; |
| 801 |
a := (3,2); |
| 802 |
A = VecteurP(a); |
| 803 |
trace AB; |
| 804 |
trace A; |
| 805 |
endfig; |
| 806 |
\end{ExempleMP} |
| 807 |
|
| 808 |
\subsubsection{Macros associées} |
| 809 |
|
| 810 |
Comme les objets de \mpgeomdd ne sont pas des \typeMP{numeric}s, les opérations classiques |
| 811 |
de l'espace vectoriel ne peuvent pas s'écrire avec les simples caractères |
| 812 |
\lstinline-+-, \lstinline+-+, et \lstinline-*-. |
| 813 |
|
| 814 |
\begin{colourband} |
| 815 |
\macro|AdditionVecteur(«a»,«b»)|\return{\typeGDD{vecteur}} |
| 816 |
\begin{description} |
| 817 |
\item[\meta{a}:] \typeGDD{vecteur} ; |
| 818 |
\item[\meta{b}:] \typeGDD{vecteur}. |
| 819 |
\end{description}\index{AdditionVecteur@\lstinline+AdditionVecteur+} |
| 820 |
\end{colourband} |
| 821 |
\bigskip |
| 822 |
|
| 823 |
|
| 824 |
\begin{colourband} |
| 825 |
\macro|SoustractionVecteur(«a»,«b»)|\return{\typeGDD{vecteur}} |
| 826 |
\begin{description} |
| 827 |
\item[\meta{a}:] \typeGDD{vecteur} ; |
| 828 |
\item[\meta{b}:] \typeGDD{vecteur}. |
| 829 |
\end{description}\index{SoustractionVecteur@\lstinline+SoustractionVecteur+} |
| 830 |
\end{colourband} |
| 831 |
\bigskip |
| 832 |
|
| 833 |
|
| 834 |
\begin{colourband} |
| 835 |
\macro|ScalaireVecteur(«k»,«b»)|\return{\typeGDD{vecteur}} |
| 836 |
\begin{description} |
| 837 |
\item[\meta{k}:] \typeMP{numeric} ; |
| 838 |
\item[\meta{b}:] \typeGDD{vecteur}. |
| 839 |
\end{description}\index{ScalaireVecteur@\lstinline+ScalaireVecteur+} |
| 840 |
\end{colourband} |
| 841 |
\bigskip |
| 842 |
|
| 843 |
On pourra alors faire les opérations classiques sur les vecteurs. |
| 844 |
|
| 845 |
\begin{ExempleMP} |
| 846 |
input geom2d; |
| 847 |
beginfig(1); |
| 848 |
AB = Vecteur(2,3); |
| 849 |
BC = Vecteur(1,0); |
| 850 |
AC = AdditionVecteur(AB,BC); |
| 851 |
kAC = ScalaireVecteur(3.0,AC); |
| 852 |
trace AB; |
| 853 |
trace BC; |
| 854 |
trace AC; |
| 855 |
endfig; |
| 856 |
\end{ExempleMP} |
| 857 |
|
| 858 |
On peut aussi calculer le produit scalaire de deux vecteurs avec la commande |
| 859 |
suivante. |
| 860 |
|
| 861 |
\begin{colourband} |
| 862 |
\macro|ProduitScalaire(«a»,«b»)|\return{\typeMP{numeric}} |
| 863 |
\begin{description} |
| 864 |
\item[\meta{a}:] \typeGDD{vecteur} ; |
| 865 |
\item[\meta{b}:] \typeGDD{vecteur}. |
| 866 |
\end{description}\index{ProduitScalaire@\lstinline+ProduitScalaire+} |
| 867 |
\end{colourband} |
| 868 |
\bigskip |
| 869 |
|
| 870 |
On peut aussi calculer la norme euclidienne d'un vecteur. |
| 871 |
\begin{colourband} |
| 872 |
\macro|Norme(«a»)|\return{\typeMP{numeric}} |
| 873 |
\begin{description} |
| 874 |
\item[\meta{a}:] \typeGDD{vecteur}. |
| 875 |
\end{description}\index{Norme@\lstinline+Norme+} |
| 876 |
\end{colourband} |
| 877 |
\bigskip |
| 878 |
|
| 879 |
La commande suivante permet d'obtenir l'angle, en radian, entre $[0,\uppi]$ formé |
| 880 |
entre deux vecteurs. Si on note $u$ et $v$ les deux vecteurs de $\R^2$, l'angle |
| 881 |
calculé par la commande suivante est obtenu avec la formule suivante : |
| 882 |
\[\theta = \arccos \left(\frac{u\cdot v}{\|u\|\|v\|}\right).\] |
| 883 |
|
| 884 |
\begin{colourband} |
| 885 |
\macro|VecteursAngle(«a»,«b»)|\return{\typeMP{numeric} (dans $[0,\uppi]$)} |
| 886 |
\begin{description} |
| 887 |
\item[\meta{a}:] \typeGDD{vecteur} ; |
| 888 |
\item[\meta{b}:] \typeGDD{vecteur}. |
| 889 |
\end{description}\index{VecteursAngle@\lstinline+VecteursAngle+} |
| 890 |
\end{colourband} |
| 891 |
\bigskip |
| 892 |
|
| 893 |
|
| 894 |
\subsection{Le type \typeGDD{segment}} |
| 895 |
Les segments sont |
| 896 |
définis par deux points de $\R^2$. |
| 897 |
|
| 898 |
|
| 899 |
\subsubsection{Constructeur} |
| 900 |
La fonction créatrice de cet objet est |
| 901 |
celle-ci |
| 902 |
\begin{mpcode} |
| 903 |
vardef Segment (expr a,b) = |
| 904 |
save n; n = incr gddO; |
| 905 |
gddT[n] = "segment"; gddA[n] = PointImp(a); gddB[n] = PointImp(b); n |
| 906 |
enddef; |
| 907 |
\end{mpcode} |
| 908 |
|
| 909 |
\begin{colourband} |
| 910 |
\macro|Segment(«a»,«b»)|\return{\typeGDD{segment}} |
| 911 |
\begin{description} |
| 912 |
\item[\meta{a}:] \typeGDD{point} ; |
| 913 |
\item[\meta{b}:] \typeGDD{point}. |
| 914 |
\end{description}\index{Segment@\lstinline+Segment+} |
| 915 |
\end{colourband} |
| 916 |
|
| 917 |
\bigskip |
| 918 |
|
| 919 |
Un segment se définit alors comme ceci: |
| 920 |
\begin{ExempleMP} |
| 921 |
input geom2d; |
| 922 |
beginfig(1); |
| 923 |
A = Point(2,3); |
| 924 |
B = Point(4,5); |
| 925 |
C = Point(2,1); |
| 926 |
AB = Segment(A,B); |
| 927 |
BC = Segment(B,C); |
| 928 |
AC = Segment(A,C); |
| 929 |
fleche AB; |
| 930 |
fleche BC; |
| 931 |
fleche AC; |
| 932 |
endfig; |
| 933 |
\end{ExempleMP} |
| 934 |
|
| 935 |
\subsubsection{Macros associées} |
| 936 |
|
| 937 |
On peut calculer la longueur d'un segment avec la macro suivante. |
| 938 |
\begin{colourband} |
| 939 |
\macro|LongueurSegment(«a»)|\return{\typeMP{numeric}} |
| 940 |
\begin{description} |
| 941 |
\item[\meta{a}:] \typeGDD{segment}. |
| 942 |
\end{description}\index{LongueurSegment@\lstinline+LongueurSegment+} |
| 943 |
\end{colourband} |
| 944 |
|
| 945 |
On peut aussi convertir un segment en vecteur avec la macro suivante qui fait la |
| 946 |
différence des coordonnées des deux points définissant le segment. |
| 947 |
\begin{colourband} |
| 948 |
\macro|SegmentTOVecteur(«a»)|\return{\typeGDD{vecteur}} |
| 949 |
\begin{description} |
| 950 |
\item[\meta{a}:] \typeGDD{segment}. |
| 951 |
\end{description}\index{SegmentTOVecteur@\lstinline+SegmentTOVecteur+} |
| 952 |
\end{colourband} |
| 953 |
|
| 954 |
|
| 955 |
|
| 956 |
\subsection{Le type \typeGDD{droite}} |
| 957 |
Une droite est simplement définie par |
| 958 |
deux points. |
| 959 |
|
| 960 |
\subsubsection{Constructeur} |
| 961 |
|
| 962 |
Ainsi la fonction créatrice de cet objet est la suivante |
| 963 |
\begin{mpcode} |
| 964 |
vardef Droite (expr a,b) = |
| 965 |
save n; n = incr gddO; |
| 966 |
gddT[n] = "droite"; gddA[n] = PointImp(a); gddB[n] = PointImp(b); n |
| 967 |
enddef; |
| 968 |
\end{mpcode} |
| 969 |
\begin{colourband} |
| 970 |
\macro|Droite(«a»,«b»)|\return{\typeGDD{droite}} |
| 971 |
\begin{description} |
| 972 |
\item[\meta{a}:] \typeGDD{point} ; |
| 973 |
\item[\meta{b}:] \typeGDD{point}. |
| 974 |
\end{description}\index{Droite@\lstinline+Droite+} |
| 975 |
\end{colourband} |
| 976 |
\bigskip |
| 977 |
|
| 978 |
Lors de la représentation des droites (voir section~\ref{sec:trace}), le |
| 979 |
caractère \emph{infini} de la droite est géré par la variable globale |
| 980 |
\lstinline+gddExtensionDroite+ |
| 981 |
\index{gddExtensionDroite@\lstinline+gddExtensionDroite+} |
| 982 |
qui vaut 10 par défaut. |
| 983 |
|
| 984 |
|
| 985 |
|
| 986 |
On pourra la modifier avec la commande suivante: |
| 987 |
\begin{colourband} |
| 988 |
\macro|Set(«d»)| |
| 989 |
\begin{description} |
| 990 |
\item[\meta{d}:] \typeMP{numeric} (valeur par défaut 10). |
| 991 |
\end{description}\index{ParametreExtensionDroite@\lstinline+ParametreExtensionDroite+} |
| 992 |
\end{colourband} |
| 993 |
\bigskip |
| 994 |
|
| 995 |
|
| 996 |
\subsubsection{Macros associées} |
| 997 |
|
| 998 |
|
| 999 |
La macro suivante permet, sous forme d'un triplet, et donc d'une \typeMP{color}, |
| 1000 |
d'obtenir les coefficients d'une droite donnée. Pour une droite $(D)$, la macro |
| 1001 |
donne le triplet $(u,v,w)\in\R^3$ tel que $\forall (x,y)\in(D)$, $ux+vy+w=0$. |
| 1002 |
|
| 1003 |
\begin{colourband} |
| 1004 |
\macro|EquationDroite(«a»)|\return{\typeMP{color}} |
| 1005 |
\begin{description} |
| 1006 |
\item[\meta{a}:] \typeGDD{droite}. |
| 1007 |
\end{description}\index{EquationDroite@\lstinline+EquationDroite+} |
| 1008 |
\end{colourband} |
| 1009 |
|
| 1010 |
On peut calculer la projection d'un point sur une droite avec la commande |
| 1011 |
suivante. |
| 1012 |
|
| 1013 |
\begin{colourband} |
| 1014 |
\macro|ProjectionPointSurDroite(«p»,«a»)|\return{\typeGDD{point}} |
| 1015 |
\begin{description} |
| 1016 |
\item[\meta{p}:] \typeGDD{point} ; |
| 1017 |
\item[\meta{a}:] \typeGDD{droite}. |
| 1018 |
\end{description}\index{ProjectionPointSurDroite@\lstinline+ProjectionPointSurDroite+} |
| 1019 |
\end{colourband} |
| 1020 |
|
| 1021 |
On peut obtenir l'ordonnée relative d'un point sur une droite avec la macro |
| 1022 |
suivante. |
| 1023 |
\begin{colourband} |
| 1024 |
\macro|OrdonneeRelativePointDroite(«p»,«a»)|\return{\typeMP{numeric}} |
| 1025 |
\begin{description} |
| 1026 |
\item[\meta{p}:] \typeGDD{point} ; |
| 1027 |
\item[\meta{a}:] \typeGDD{droite}. |
| 1028 |
\end{description}\index{OrdonneeRelativePointDroite@\lstinline+OrdonneeRelativePointDroite+} |
| 1029 |
\end{colourband} |
| 1030 |
|
| 1031 |
Le calcul de la distance d'un point à une droite se fait avec la macro suivante. |
| 1032 |
\begin{colourband} |
| 1033 |
\macro|DistancePointDroite(«p»,«a»)|\return{\typeMP{numeric}} |
| 1034 |
\begin{description} |
| 1035 |
\item[\meta{p}:] \typeGDD{point} ; |
| 1036 |
\item[\meta{a}:] \typeGDD{droite}. |
| 1037 |
\end{description}\index{DistancePointDroite@\lstinline+DistancePointDroite+} |
| 1038 |
\end{colourband} |
| 1039 |
|
| 1040 |
La macro suivante permet d'obtenir la droite perpendiculaire à un droite passant |
| 1041 |
par un point. |
| 1042 |
\begin{colourband} |
| 1043 |
\macro|DroitePerpendiculaire(«a»,«p»)|\return{\typeGDD{droite}} |
| 1044 |
\begin{description} |
| 1045 |
\item[\meta{a}:] \typeGDD{droite} ; |
| 1046 |
\item[\meta{p}:] \typeGDD{point}. |
| 1047 |
\end{description}\index{DroitePerpendiculaire@\lstinline+DroitePerpendiculaire+} |
| 1048 |
\end{colourband} |
| 1049 |
|
| 1050 |
Sur le même modèle, la macro suivante permet d'obtenir la droite parallèle à une autre passant |
| 1051 |
par un point. |
| 1052 |
\begin{colourband} |
| 1053 |
\macro|DroiteParallele(«a»,«p»)|\return{\typeGDD{droite}} |
| 1054 |
\begin{description} |
| 1055 |
\item[\meta{a}:] \typeGDD{droite} ; |
| 1056 |
\item[\meta{p}:] \typeGDD{point}. |
| 1057 |
\end{description}\index{DroiteParallele@\lstinline+DroiteParallele+} |
| 1058 |
\end{colourband} |
| 1059 |
|
| 1060 |
On pourra obtenir le \typeGDD{point} d'intersection de deux droites avec la |
| 1061 |
macro suivante. |
| 1062 |
\begin{colourband} |
| 1063 |
\macro|IntersectionDroites(«a»,«b»)|\return{\typeGDD{point}} |
| 1064 |
\begin{description} |
| 1065 |
\item[\meta{a}:] \typeGDD{droite} ; |
| 1066 |
\item[\meta{b}:] \typeGDD{droite}. |
| 1067 |
\end{description}\index{IntersectionDroites@\lstinline+IntersectionDroites+} |
| 1068 |
\end{colourband} |
| 1069 |
|
| 1070 |
La macro suivante permet de reporter un point sur une droite avec une certaine |
| 1071 |
longueur (signée), à la manière d'un compas. |
| 1072 |
|
| 1073 |
\begin{colourband} |
| 1074 |
\macro|ReportSurDroite(«P»,«D»,«l»)|\return{\typeGDD{point}} |
| 1075 |
\begin{description} |
| 1076 |
\item[\meta{P}:] \typeGDD{point} ; |
| 1077 |
\item[\meta{D}:] \typeGDD{droite} ; |
| 1078 |
\item[\meta{l}:] \typeMP{numeric} (peut être négatif). |
| 1079 |
\end{description}\index{ReportSurDroite@\lstinline+ReportSurDroite+} |
| 1080 |
\end{colourband} |
| 1081 |
|
| 1082 |
Le côté du report par rapport au point \meta{P} dépend de la définition de |
| 1083 |
la droite : pour une droite définie par deux \typeGDD{point}s $A$ et $B$, alors |
| 1084 |
la direction du report sera suivant le vecteur $\overrightarrow{AB}$. Pour |
| 1085 |
changer de direction, il suffira de multiplier le paramètre de distance \meta{l} |
| 1086 |
par $-1$. |
| 1087 |
|
| 1088 |
Voici un exemple permettant d'illustrer l'utilisation de quelques commandes |
| 1089 |
relatives aux droites. |
| 1090 |
|
| 1091 |
\begin{ExempleMP} |
| 1092 |
input geom2d; |
| 1093 |
beginfig(1); |
| 1094 |
A = Point(0,0); |
| 1095 |
B = Point(3,2); |
| 1096 |
AB = Droite(A,B); |
| 1097 |
trace AB; |
| 1098 |
pointe A; |
| 1099 |
pointe B; |
| 1100 |
C = Point(0,2); |
| 1101 |
DC = DroitePerpendiculaire(AB,C); |
| 1102 |
trace DC; |
| 1103 |
pointe C; |
| 1104 |
D = ProjectionPointSurDroite(C,AB); |
| 1105 |
pointe D; |
| 1106 |
Fenetre(-2,-2,4,4); |
| 1107 |
endfig; |
| 1108 |
\end{ExempleMP} |
| 1109 |
|
| 1110 |
|
| 1111 |
|
| 1112 |
|
| 1113 |
|
| 1114 |
\subsection{Le type \typeGDD{cercle}} |
| 1115 |
Un cercle peut être défini par un point et un |
| 1116 |
rayon. |
| 1117 |
|
| 1118 |
\subsubsection{Constructeurs} |
| 1119 |
La fonction créatrice de base de cet objet est la suivante |
| 1120 |
\begin{mpcode} |
| 1121 |
vardef Cercle (expr a,b) = |
| 1122 |
save n; n = incr gddO; |
| 1123 |
gddT[n] = "cercle"; gddA[n] = PointImp(a); gddB[n] = b; n |
| 1124 |
enddef; |
| 1125 |
\end{mpcode} |
| 1126 |
\begin{colourband} |
| 1127 |
\macro|Cercle(«a»,«b»)|\return{\typeGDD{cercle}} |
| 1128 |
\begin{description} |
| 1129 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}, |
| 1130 |
centre du cercle ; |
| 1131 |
\item[\meta{b}:] \typeMP{numeric}, rayon du cercle. |
| 1132 |
\end{description}\index{Cercle@\lstinline+Cercle+} |
| 1133 |
\end{colourband} |
| 1134 |
\bigskip |
| 1135 |
|
| 1136 |
|
| 1137 |
Deux autres fonctions permettent de définir des cercles. La fonction |
| 1138 |
\foncGDD{CercleCP} définit le cercle par un centre et un point par lequel passe |
| 1139 |
le cercle. |
| 1140 |
\begin{colourband} |
| 1141 |
\macro|CercleCP(«a»,«b»)|\return{\typeGDD{cercle}} |
| 1142 |
\begin{description} |
| 1143 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}, |
| 1144 |
centre du cercle ; |
| 1145 |
\item[\meta{b}:] \typeGDD{point}, |
| 1146 |
tel que \meta{b}$-$\meta{a} est le rayon. |
| 1147 |
\end{description}\index{CercleCP@\lstinline+CercleCP+} |
| 1148 |
\end{colourband} |
| 1149 |
\bigskip |
| 1150 |
|
| 1151 |
|
| 1152 |
|
| 1153 |
On peut aussi définir un cercle par deux points définissant son diamètre. La |
| 1154 |
fonction correspondante est la suivante |
| 1155 |
|
| 1156 |
\begin{colourband} |
| 1157 |
\macro|CercleD(«a»,«b»)|\return{\typeGDD{cercle}} |
| 1158 |
\begin{description} |
| 1159 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair} ; |
| 1160 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}, |
| 1161 |
tel que $($\meta{a}$-$\meta{b}$)$ est le diamètre du cercle. |
| 1162 |
\end{description}\index{CercleD@\lstinline+CercleD+} |
| 1163 |
\end{colourband} |
| 1164 |
\bigskip |
| 1165 |
|
| 1166 |
On peut aussi définir un cercle comme le cercle qui passe par trois points avec |
| 1167 |
la macro suivante. |
| 1168 |
|
| 1169 |
\begin{colourband} |
| 1170 |
\macro|CercleTroisPoints(«a»,«b»,«c»)|\return{\typeGDD{cercle}} |
| 1171 |
\begin{description} |
| 1172 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair} ; |
| 1173 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair} ; |
| 1174 |
\item[\meta{c}:] \typeGDD{point} ou \typeMP{pair}. |
| 1175 |
\end{description}\index{CercleTroisPoints@\lstinline+CercleTroisPoints+} |
| 1176 |
\end{colourband} |
| 1177 |
\bigskip |
| 1178 |
|
| 1179 |
|
| 1180 |
|
| 1181 |
|
| 1182 |
\begin{ExempleMP} |
| 1183 |
input geom2d; |
| 1184 |
beginfig(1); |
| 1185 |
A = Point(3,1); |
| 1186 |
B = Point(0,2); |
| 1187 |
O = Point(0,0); |
| 1188 |
r = 1.0; |
| 1189 |
COr = Cercle(O,r); |
| 1190 |
COA = CercleCP(O,A); |
| 1191 |
CAB = CercleD(A,B); |
| 1192 |
COAB = CercleTroisPoints(O,A,B); |
| 1193 |
trace COr; |
| 1194 |
trace COA; |
| 1195 |
trace CAB; |
| 1196 |
trace COAB; |
| 1197 |
pointe A; pointe B; pointe O; |
| 1198 |
endfig; |
| 1199 |
\end{ExempleMP} |
| 1200 |
|
| 1201 |
\subsubsection{Macros associées} |
| 1202 |
|
| 1203 |
De nombreuses macros sont associées aux cercles. |
| 1204 |
|
| 1205 |
On pourra récupérer le rayon d'un cercle avec la commande suivante. |
| 1206 |
|
| 1207 |
|
| 1208 |
\begin{colourband} |
| 1209 |
\macro|Rayon(«a»)|\return{\typeMP{numeric}} |
| 1210 |
\begin{description} |
| 1211 |
\item[\meta{a}:] \typeGDD{cercle}. |
| 1212 |
\end{description}\index{Rayon@\lstinline+Rayon+} |
| 1213 |
\end{colourband} |
| 1214 |
\bigskip |
| 1215 |
|
| 1216 |
On pourra obtenir le centre (\typeGDD{point}) d'un cercle avec la commande : |
| 1217 |
\begin{colourband} |
| 1218 |
\macro|Centre(«a»)|\return{\typeGDD{point}} |
| 1219 |
\begin{description} |
| 1220 |
\item[\meta{a}:] \typeGDD{cercle}, \typeGDD{ellipse} ou \typeGDD{hyperbole}. |
| 1221 |
\end{description}\index{Centre@\lstinline+Centre+} |
| 1222 |
\end{colourband} |
| 1223 |
\bigskip |
| 1224 |
|
| 1225 |
On peut calculer l'intersection entre deux cercles grâce à la macro suivante. |
| 1226 |
|
| 1227 |
\begin{colourband} |
| 1228 |
\macro|IntersectionCercles(«a»,«b»)|\return{\typeGDD{point}} |
| 1229 |
\begin{description} |
| 1230 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1231 |
\item[\meta{b}:] \typeGDD{cercle}. |
| 1232 |
\end{description}\index{IntersectionCercles@\lstinline+IntersectionCercles+} |
| 1233 |
\end{colourband} |
| 1234 |
\bigskip |
| 1235 |
|
| 1236 |
Cette macro ne donnera qu'un seul point d'intersection. Pour obtenir les deux |
| 1237 |
points d'intersection, il faudra inverser l'ordre d'appel sur les cercles comme |
| 1238 |
l'exemple suivant l'illustre. |
| 1239 |
|
| 1240 |
\begin{ExempleMP} |
| 1241 |
input geom2d; |
| 1242 |
beginfig(1); |
| 1243 |
A = Point(0,0); |
| 1244 |
CA = Cercle(A,1); |
| 1245 |
B = Point(1.5,0); |
| 1246 |
CB = Cercle(B,2); |
| 1247 |
D1 = IntersectionCercles(CA,CB); |
| 1248 |
D2 = IntersectionCercles(CB,CA); |
| 1249 |
trace CA; trace CB; |
| 1250 |
pointe A; pointe B; pointe D1; pointe D2; |
| 1251 |
endfig; |
| 1252 |
\end{ExempleMP} |
| 1253 |
|
| 1254 |
Si il n'existe pas d'intersection, alors la compilation échouera avec l'erreur |
| 1255 |
\texttt{! Pythagorean subtraction X.XXXX+-+X.XXXX has been replaced by 0}. Si |
| 1256 |
les deux cercles sont confondus, alors l'erreur sera \texttt{! Division by zero.}. |
| 1257 |
|
| 1258 |
\mpgeomdd fournit aussi une macro permettant d'obtenir les intersections entre une |
| 1259 |
droite et un cercle. |
| 1260 |
|
| 1261 |
\begin{colourband} |
| 1262 |
\macro|IntersectionDroiteCercle(«d»,«c»,«n»)|\return{\typeGDD{point}} |
| 1263 |
\begin{description} |
| 1264 |
\item[\meta{d}:] \typeGDD{droite} ; |
| 1265 |
\item[\meta{c}:] \typeGDD{cercle} ; |
| 1266 |
\item[\meta{n}:] \typeMP{numeric} qui vaut 1 ou 2 suivant le point |
| 1267 |
d'intersection que l'on souhaite (s'il n'existe qu'un point d'intersection |
| 1268 |
alors les deux valeurs renvoient le même point). |
| 1269 |
\end{description}\index{IntersectionDroiteCercle@\lstinline+IntersectionDroiteCercle+} |
| 1270 |
\end{colourband} |
| 1271 |
\bigskip |
| 1272 |
|
| 1273 |
S'il n'existe pas d'intersection entre la droite et le cercle, vous obtiendrez |
| 1274 |
l'erreur \texttt{! Intersection between line and circle does not exist}. |
| 1275 |
|
| 1276 |
L'exemple suivant permet d'illuster cette macro. |
| 1277 |
\begin{ExempleMP} |
| 1278 |
input geom2d; |
| 1279 |
beginfig(1); |
| 1280 |
A = Point(2,2); |
| 1281 |
C_A = Cercle(A,1); |
| 1282 |
B = Point(0,1); |
| 1283 |
C = Point(4,2); |
| 1284 |
BC = Droite(B,C); |
| 1285 |
E1 = IntersectionDroiteCercle(BC,C_A,1); |
| 1286 |
trace C_A; |
| 1287 |
trace BC dashed evenly; |
| 1288 |
pointe A; pointe B; pointe C; pointe E1; |
| 1289 |
Fenetre(-0.5,-0.5,5,4); |
| 1290 |
endfig; |
| 1291 |
\end{ExempleMP} |
| 1292 |
|
| 1293 |
|
| 1294 |
|
| 1295 |
On peut obtenir les tangentes intérieures et extérieures communes à deux cercles |
| 1296 |
avec les deux macros suivantes. Là encore, comme il existe deux tangentes, pour |
| 1297 |
obtenir les deux, on inversera l'ordre d'appel des deux cercles. |
| 1298 |
|
| 1299 |
\begin{colourband} |
| 1300 |
\macro|TangenteCommuneExterieure(«a»,«b»)|\return{\typeGDD{droite}} |
| 1301 |
\begin{description} |
| 1302 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1303 |
\item[\meta{b}:] \typeGDD{cercle}. |
| 1304 |
\end{description}\index{TangenteCommuneExterieure@\lstinline+TangenteCommuneExterieure+} |
| 1305 |
\end{colourband} |
| 1306 |
\bigskip |
| 1307 |
|
| 1308 |
|
| 1309 |
\begin{colourband} |
| 1310 |
\macro|TangenteCommuneInterieure(«a»,«b»)|\return{\typeGDD{droite}} |
| 1311 |
\begin{description} |
| 1312 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1313 |
\item[\meta{b}:] \typeGDD{cercle}. |
| 1314 |
\end{description}\index{TangenteCommuneInterieure@\lstinline+TangenteCommuneInterieure+} |
| 1315 |
\end{colourband} |
| 1316 |
\bigskip |
| 1317 |
|
| 1318 |
L'exemple suivant illustre l'utilisation de ces deux macros. |
| 1319 |
\begin{ExempleMP}[sidebyside=false] |
| 1320 |
input geom2d; |
| 1321 |
beginfig(1); |
| 1322 |
C1 = Cercle((-2,0),2); |
| 1323 |
C2 = Cercle((1.5,0),1); |
| 1324 |
T1 = TangenteCommuneExterieure(C1,C2); |
| 1325 |
T2 = TangenteCommuneExterieure(C2,C1); |
| 1326 |
T3 = TangenteCommuneInterieure(C1,C2); |
| 1327 |
T4 = TangenteCommuneInterieure(C2,C1); |
| 1328 |
trace C1; trace C2; |
| 1329 |
trace T1; trace T2; |
| 1330 |
trace T3; trace T4; |
| 1331 |
|
| 1332 |
Fenetre(-5,-3,6,3); |
| 1333 |
endfig; |
| 1334 |
\end{ExempleMP} |
| 1335 |
|
| 1336 |
La macro suivante permet de calculer l'axe radical (\typeGDD{droite}) de deux |
| 1337 |
cercles\footnote{La méthode de construction a été largement inspirée du code de |
| 1338 |
T.~Thurston dans son document \emph{Drawing with \MP}~\cite{ctan-drawing-with-metapost}.}. |
| 1339 |
\begin{colourband} |
| 1340 |
\macro|AxeRadical(«a»,«b»)|\return{\typeGDD{droite}} |
| 1341 |
\begin{description} |
| 1342 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1343 |
\item[\meta{b}:] \typeGDD{cercle}. |
| 1344 |
\end{description}\index{AxeRadical@\lstinline+AxeRadical+} |
| 1345 |
\end{colourband} |
| 1346 |
\bigskip |
| 1347 |
|
| 1348 |
La macro suivante permet d'obtenir le centre radical de trois cercles. |
| 1349 |
\begin{colourband} |
| 1350 |
\macro|CentreRadical(«a»,«b»,«c»)|\return{\typeGDD{point}} |
| 1351 |
\begin{description} |
| 1352 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1353 |
\item[\meta{b}:] \typeGDD{cercle} ; |
| 1354 |
\item[\meta{c}:] \typeGDD{cercle}. |
| 1355 |
\end{description}\index{CentreRadical@\lstinline+CentreRadical+} |
| 1356 |
\end{colourband} |
| 1357 |
\bigskip |
| 1358 |
|
| 1359 |
La macro suivante permet de calculer l'axe de similitude de trois cercles. |
| 1360 |
\begin{colourband} |
| 1361 |
\macro|AxeDeSimilitude(«a»,«b»,«c»)|\return{\typeGDD{droite}} |
| 1362 |
\begin{description} |
| 1363 |
\item[\meta{a}:] \typeGDD{cercle} ; |
| 1364 |
\item[\meta{b}:] \typeGDD{cercle} ; |
| 1365 |
\item[\meta{c}:] \typeGDD{cercle}. |
| 1366 |
\end{description}\index{AxeDeSimilitude@\lstinline+AxeDeSimilitude+} |
| 1367 |
\end{colourband} |
| 1368 |
\bigskip |
| 1369 |
|
| 1370 |
\subsection{Le type \typeGDD{ellipse}} |
| 1371 |
\subsubsection{Constructeurs} |
| 1372 |
|
| 1373 |
Les ellipses peuvent être définies de plusieurs façons. Tout d'abord, on peut la |
| 1374 |
définir avec son centre, un des points de l'ellipse sur le grand axe (appelé |
| 1375 |
vertex), et un des points de l'ellipse sur le petit axe (appelé co-vertex). |
| 1376 |
Cependant, lors de la création d'une ellipse de nombreux attributs sont calculés. |
| 1377 |
|
| 1378 |
Le code du constructeur est le suivant: |
| 1379 |
\begin{mpcode} |
| 1380 |
vardef Ellipse(expr C,A,B) = |
| 1381 |
% C : centre |
| 1382 |
% A : vertex |
| 1383 |
% B : co-vertex |
| 1384 |
save n,a,b,c,e,_tmp,slope,_D,_K,_h,_ff; |
| 1385 |
pair _tmp; |
| 1386 |
n = incr gddO; |
| 1387 |
gddT[n] = "ellipse"; gddA[n] = PointImp(C); gddB[n] = PointImp(A); |
| 1388 |
gddC[n] = PointImp(B); |
| 1389 |
% calcul des deux foyers |
| 1390 |
a = Longueur(C,A); |
| 1391 |
b = Longueur(C,B); |
| 1392 |
c = sqrt(a**2-b**2); |
| 1393 |
e = c/a; |
| 1394 |
_tmp = e*(Pt(A)-Pt(C)); |
| 1395 |
% les foyers |
| 1396 |
gddD[n] = PairTOPoint(Pt(C)+_tmp); |
| 1397 |
gddE[n] = PairTOPoint(Pt(C)-_tmp); |
| 1398 |
gddX[n][1] = a; |
| 1399 |
gddX[n][2] = b; |
| 1400 |
gddX[n][3] = e; |
| 1401 |
% angle du demi grand axe |
| 1402 |
slope = angle(PairImp(A)-PairImp(C)); |
| 1403 |
gddX[n][4] = slope; |
| 1404 |
% directrices |
| 1405 |
_h = (a*a-c*c)/c; |
| 1406 |
% prejection sur la directice |
| 1407 |
_ff = Droite(gddE[n],gddD[n]); |
| 1408 |
_K = ReportSurDroite(gddD[n],_ff,_h); |
| 1409 |
_D = DroitePerpendiculaire(_ff,_K); |
| 1410 |
gddX[n][5] := _D; % on stock la directrice |
| 1411 |
gddX[n][6] := SymetrieCentrale(_D,gddA[n]); % on stock la deuxième directrice |
| 1412 |
n |
| 1413 |
enddef; |
| 1414 |
\end{mpcode} |
| 1415 |
|
| 1416 |
\begin{colourband} |
| 1417 |
\macro|Ellipse(«c»,«a»,«b»)|\return{\typeGDD{ellipse}} |
| 1418 |
\begin{description} |
| 1419 |
\item[\meta{c}:] \typeGDD{point} ou \typeMP{pair}, le centre ; |
| 1420 |
\item[\meta{a}:] \typeGDD{point} ou \typeMP{pair}, le vertex ; |
| 1421 |
\item[\meta{b}:] \typeGDD{point} ou \typeMP{pair}, le co-vertex. |
| 1422 |
\end{description}\index{Ellipse@\lstinline+Ellipse+} |
| 1423 |
\end{colourband} |
| 1424 |
\bigskip |
| 1425 |
|
| 1426 |
Cette macro s'utilise comme le montre l'exemple suivant. |
| 1427 |
\begin{ExempleMP} |
| 1428 |
input geom2d; |
| 1429 |
beginfig(1); |
| 1430 |
C = Point(0,0); |
| 1431 |
A = Point(3,1); |
| 1432 |
B = Rotation((1.5,0.5),Pi/2); |
| 1433 |
E = Ellipse(C,A,B); |
| 1434 |
trace E; |
| 1435 |
pointe A; pointe B; pointe C; |
| 1436 |
endfig; |
| 1437 |
\end{ExempleMP} |
| 1438 |
|
| 1439 |
On pourra définir une ellipse avec la donnée de ses deux foyers et du |
| 1440 |
demi-grand axe avec la commande suivante: |
| 1441 |
\begin{colourband} |
| 1442 |
\macro|EllipseF(«A»,«B»,«a»)|\return{\typeGDD{ellipse}} |
| 1443 |
\begin{description} |
| 1444 |
\item[\meta{A}:] \typeGDD{point} ou \typeMP{pair}, premier foyer ; |
| 1445 |
\item[\meta{B}:] \typeGDD{point} ou \typeMP{pair}, deuxième foyer ; |
| 1446 |
\item[\meta{a}:] \typeGDD{numeric}, le demi-grand axe. |
| 1447 |
\end{description}\index{EllipseF@\lstinline+EllipseF+} |
| 1448 |
\end{colourband} |
| 1449 |
\bigskip |
| 1450 |
|
| 1451 |
|
| 1452 |
Cette macro s'utilise comme le montre l'exemple suivant. |
| 1453 |
\begin{ExempleMP} |
| 1454 |
input geom2d; |
| 1455 |
beginfig(1); |
| 1456 |
F1 = Point(3,1); |
| 1457 |
F2 = Point(1.5,0.5); |
| 1458 |
E = EllipseF(F1,F2,1.7); |
| 1459 |
trace E; |
| 1460 |
pointe F1; pointe F2; |
| 1461 |
endfig; |
| 1462 |
\end{ExempleMP} |
| 1463 |
|
| 1464 |
On pourra aussi définir une ellipse à partir d’un foyer, de sa directrice et de |
| 1465 |
l’excentricité avec la commande suivante: |
| 1466 |
\begin{colourband} |
| 1467 |
\macro|EllipseFD(«F»,«D»,«e»)|\return{\typeGDD{ellipse}} |
| 1468 |
\begin{description} |
| 1469 |
\item[\meta{F}:] \typeGDD{point} ou \typeMP{pair}, un foyer ; |
| 1470 |
\item[\meta{D}:] \typeGDD{droite}, la directrice associée ; |
| 1471 |
\item[\meta{e}:] \typeGDD{numeric}, l’excentricité ($<1$). |
| 1472 |
\end{description}\index{EllipseFD@\lstinline+EllipseFD+} |
| 1473 |
\end{colourband} |
| 1474 |
\bigskip |
| 1475 |
|
| 1476 |
\subsubsection{Macros associées} |
| 1477 |
|
| 1478 |
On pourra obtenir le centre (\typeGDD{point}) d'une ellipse avec la commande : |
| 1479 |
\begin{colourband} |
| 1480 |
\macro|Centre(«a»)|\return{\typeGDD{point}} |
| 1481 |
\begin{description} |
| 1482 |
\item[\meta{a}:] \typeGDD{cercle}, \typeGDD{ellipse} ou \typeGDD{hyperbole}. |
| 1483 |
\end{description}\index{Centre@\lstinline+Centre+} |
| 1484 |
\end{colourband} |
| 1485 |
|
| 1486 |
On obtient le vertex et le co-vertex avec les commandes suivantes: |
| 1487 |
\begin{colourband} |
| 1488 |
\macro|Vertex(«a»)|\return{\typeGDD{point}} |
| 1489 |
\begin{description} |
| 1490 |
\item[\meta{a}:] \typeGDD{ellipse}. |
| 1491 |
\end{description}\index{Vertex@\lstinline+Vertex+} |
| 1492 |
\end{colourband} |
| 1493 |
\bigskip |
| 1494 |
|
| 1495 |
\begin{colourband} |
| 1496 |
\macro|CoVertex(«a»)|\return{\typeGDD{point}} |
| 1497 |
\begin{description} |
| 1498 |
\item[\meta{a}:] \typeGDD{ellipse}. |
| 1499 |
\end{description}\index{CoVertex@\lstinline+CoVertex+} |
| 1500 |
\end{colourband} |
| 1501 |
\bigskip |
| 1502 |
|
| 1503 |
La commande suivante permet d'obtenir les deux foyers selon l'entier passé en |
| 1504 |
argument. |
| 1505 |
\begin{colourband} |
| 1506 |
\macro|Foyer(«a»,«n»)|\return{\typeGDD{point}} |
| 1507 |
\begin{description} |
| 1508 |
\item[\meta{a}:] \typeGDD{ellipse} ; |
| 1509 |
\item[\meta{n}:] \typeMP{numeric}, entier qui vaut 1 ou 2 pour obtenir chaque |
| 1510 |
foyer. |
| 1511 |
\end{description}\index{Foyer@\lstinline+Foyer+} |
| 1512 |
\end{colourband} |
| 1513 |
\bigskip |
| 1514 |
|
| 1515 |
On peut obtenir le demi-grand axe et le demi-petit axe avec les commandes |
| 1516 |
suivantes. |
| 1517 |
\begin{colourband} |
| 1518 |
\macro|DemiGrandAxe(«a»)|\return{\typeMP{numeric}} |
| 1519 |
\begin{description} |
| 1520 |
\item[\meta{a}:] \typeGDD{ellipse}. |
| 1521 |
\end{description}\index{DemiGrandAxe@\lstinline+DemiGrandAxe+} |
| 1522 |
\end{colourband} |
| 1523 |
\bigskip |
| 1524 |
|
| 1525 |
|
| 1526 |
\begin{colourband} |
| 1527 |
\macro|DemiPetitAxe(«a»)|\return{\typeMP{numeric}} |
| 1528 |
\begin{description} |
| 1529 |
\item[\meta{a}:] \typeGDD{ellipse}. |
| 1530 |
\end{description}\index{DemiPetitAxe@\lstinline+DemiPetitAxe+} |
| 1531 |
\end{colourband} |
| 1532 |
\bigskip |
| 1533 |
|
| 1534 |
On obtient l'excentricité, souvent notée $e$, avec la commande suivante. |
| 1535 |
|
| 1536 |
\begin{colourband} |
| 1537 |
\macro|Excentricite(«a»)|\return{\typeMP{numeric}} |
| 1538 |
\begin{description} |
| 1539 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1540 |
\end{description}\index{Excentricite@\lstinline+Excentricite+} |
| 1541 |
\end{colourband} |
| 1542 |
\bigskip |
| 1543 |
|
| 1544 |
Pour obtenir l'inclinaison (coefficient directeur de la droite passant par les |
| 1545 |
foyers de l'ellipse), on utilisera la commande suivante. |
| 1546 |
|
| 1547 |
\begin{colourband} |
| 1548 |
\macro|Inclinaison(«a»)|\return{\typeMP{numeric}} |
| 1549 |
\begin{description} |
| 1550 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1551 |
\end{description}\index{Inclinaison@\lstinline+Inclinaison+} |
| 1552 |
\end{colourband} |
| 1553 |
\bigskip |
| 1554 |
|
| 1555 |
On peut obtenir les directrices de l'ellipse avec la commande suivante: |
| 1556 |
|
| 1557 |
\begin{colourband} |
| 1558 |
\macro|Directrice(«a»,«n»)|\return{\typeGDD{droite}} |
| 1559 |
\begin{description} |
| 1560 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole} |
| 1561 |
; |
| 1562 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), pour choisir l'une des deux |
| 1563 |
directrices. |
| 1564 |
\end{description}\index{Directrice@\lstinline+Directrice+} |
| 1565 |
\end{colourband} |
| 1566 |
\bigskip |
| 1567 |
|
| 1568 |
Pour obtenir la tangente (\typeGDD{droite}) à un point de l'ellipse, on |
| 1569 |
utilisera la commande suivante. |
| 1570 |
|
| 1571 |
\begin{colourband} |
| 1572 |
\macro|TangenteEllipse(«e»,«p»)|\return{\typeGDD{droite}} |
| 1573 |
\begin{description} |
| 1574 |
\item[\meta{e}:] \typeGDD{ellipse} ; |
| 1575 |
\item[\meta{p}:] \typeGDD{point} ou \typeMP{pair}. |
| 1576 |
\end{description}\index{TangenteEllipse@\lstinline+TangenteEllipse+} |
| 1577 |
\end{colourband} |
| 1578 |
\bigskip |
| 1579 |
|
| 1580 |
\begin{ExempleMP} |
| 1581 |
input geom2d; |
| 1582 |
beginfig(1); |
| 1583 |
F1 = Point(3,1); |
| 1584 |
F2 = Point(1.5,0.5); |
| 1585 |
E = EllipseF(F1,F2,2.4); |
| 1586 |
pointe F1; pointe F2; |
| 1587 |
trace E; |
| 1588 |
M' = PointDe(E,0.5); |
| 1589 |
D = TangenteEllipse(E,M'); |
| 1590 |
trace D; |
| 1591 |
pointe M'; |
| 1592 |
pointe Foyer(E,1); |
| 1593 |
pointe Foyer(E,2); |
| 1594 |
Fenetre(-0.2,-2.5,6,4); |
| 1595 |
endfig; |
| 1596 |
\end{ExempleMP} |
| 1597 |
|
| 1598 |
|
| 1599 |
Pour obtenir les tangentes (\typeGDD{droite}) passant par un point extérieur à |
| 1600 |
l'ellipse, on utilisera la commande suivante. Si le point choisi n'est pas |
| 1601 |
extérieur à l'ellipse, alors il y aura une erreur de compilation. |
| 1602 |
|
| 1603 |
\begin{colourband} |
| 1604 |
\macro|TangenteExterieureEllipse(«e»,«p»,«n»)|\return{\typeGDD{droite}} |
| 1605 |
\begin{description} |
| 1606 |
\item[\meta{e}:] \typeGDD{ellipse} ; |
| 1607 |
\item[\meta{p}:] \typeGDD{point} ou \typeGDD{pair} ; |
| 1608 |
\item[\meta{n}:] \typeMP{numeric} qui vaut 1 ou 2 pour choisir la tangente |
| 1609 |
parmi les deux possibles. |
| 1610 |
\end{description}\index{TangenteExterieureEllipse@\lstinline+TangenteExterieureEllipse+} |
| 1611 |
\end{colourband} |
| 1612 |
\bigskip |
| 1613 |
|
| 1614 |
Les points de tangence sont accessibles comme deuxième point de la définition de |
| 1615 |
la \typeGDD{droite} grâce à la table \variableGDD{gddB[]}. |
| 1616 |
|
| 1617 |
\begin{ExempleMP} |
| 1618 |
input geom2d; |
| 1619 |
beginfig(1); |
| 1620 |
F1 = Point(3,1); |
| 1621 |
F2 = Point(1.5,0.5); |
| 1622 |
E = EllipseF(F1,F2,2.4); |
| 1623 |
pointe F1; pointe F2; |
| 1624 |
trace E; |
| 1625 |
M = Point(4,3); |
| 1626 |
D1 = TangenteExterieureEllipse(E,M,1); |
| 1627 |
trace D1; |
| 1628 |
pointe gddB[D1]; |
| 1629 |
D2 = TangenteExterieureEllipse(E,M,2); |
| 1630 |
trace D2; |
| 1631 |
pointe gddB[D2]; |
| 1632 |
pointe M; |
| 1633 |
pointe Foyer(E,1); |
| 1634 |
pointe Foyer(E,2); |
| 1635 |
Fenetre(-0.2,-2.5,6,4); |
| 1636 |
endfig; |
| 1637 |
\end{ExempleMP} |
| 1638 |
|
| 1639 |
\subsection{Le type \typeGDD{parabole}} |
| 1640 |
|
| 1641 |
Le constructeur de base de la parabole définit cet objet à partir du foyer et |
| 1642 |
de la directrice. |
| 1643 |
|
| 1644 |
Le code du constructeur est le suivant: |
| 1645 |
\begin{mpcode} |
| 1646 |
vardef ParaboleFD(expr F,D) = |
| 1647 |
% F : foyer (point) |
| 1648 |
% D : directrice (droite) |
| 1649 |
save u, v, w, d, i, n,_tmp,slope; |
| 1650 |
pair _tmp; |
| 1651 |
n = incr gddO; |
| 1652 |
(u,v,w) = EquationDroite(D); |
| 1653 |
% ordonnée relative |
| 1654 |
d := u * gddA[F] + v * gddB[F] + w; |
| 1655 |
gddT[n] := "parabole"; |
| 1656 |
gddX[n][1] := D; % on stocke la directrice |
| 1657 |
gddX[n][2] := D; % on stocke la directrice (compatibilité avec hyperbole) |
| 1658 |
% sommet |
| 1659 |
_tmp := (((-d/2)*(u,v)) shifted PairImp(F)); |
| 1660 |
gddB[n] = PointImp(_tmp); |
| 1661 |
gddC[n] = PointImp(_tmp); |
| 1662 |
% le foyer (doublé pour compatibilité) |
| 1663 |
gddD[n] := F; |
| 1664 |
gddE[n] := F; |
| 1665 |
gddX[n][3] := 1.0; % excentricité |
| 1666 |
% angle du demi-grand axe |
| 1667 |
slope = angle(PairImp(gddA[D])-PairImp(gddB[D]))+90; |
| 1668 |
gddX[n][4] = slope; |
| 1669 |
i := -gddC2Dparam-1; |
| 1670 |
gddP[n] := ( |
| 1671 |
((i*(v,-u)+((i*i-d*d)/(2d))*(u,v)) |
| 1672 |
for i:= -gddC2Dparam upto gddC2Dparam: |
| 1673 |
..(i*(v,-u)+((i*i-d*d)/(2d))*(u,v)) |
| 1674 |
endfor)) shifted PairImp(F); |
| 1675 |
n |
| 1676 |
enddef; |
| 1677 |
\end{mpcode} |
| 1678 |
|
| 1679 |
\begin{colourband} |
| 1680 |
\macro|ParaboleFD(«f»,«d»)|\return{\typeGDD{chemin}} |
| 1681 |
\begin{description} |
| 1682 |
\item[\meta{f}:] est le foyer (\typeGDD{point}) de la parabole; |
| 1683 |
\item[\meta{d}:] est la directrice (\typeGDD{droite}) de la parabole. |
| 1684 |
\end{description} |
| 1685 |
\index{ParaboleFD@\lstinline+ParaboleFD+} |
| 1686 |
\end{colourband} |
| 1687 |
|
| 1688 |
Lors de la représentation d'une parabole, le caractère \emph{infini} est géré |
| 1689 |
par la variable globale \lstinline+gddC2Dparam+ qui vaut 15 par défaut. |
| 1690 |
|
| 1691 |
Pour la modifier, on utilisera la commande suivante: |
| 1692 |
\begin{colourband} |
| 1693 |
\macro|ParametreConiqueCoef(«n»)| |
| 1694 |
\begin{description} |
| 1695 |
\item[\meta{n}:] \typeMP{numeric}, paramètre pour le tracé des hyperboles et |
| 1696 |
paraboles (valeur par défaut 15). |
| 1697 |
\end{description} |
| 1698 |
\index{ParametreConiqueCoef@\lstinline+ParametreConiqueCoef+} |
| 1699 |
\end{colourband} |
| 1700 |
|
| 1701 |
\subsubsection{Fonctions associées} |
| 1702 |
|
| 1703 |
|
| 1704 |
On obtient l'excentricité, souvent notée $e$, avec la commande suivante. |
| 1705 |
|
| 1706 |
\begin{colourband} |
| 1707 |
\macro|Excentricite(«a»)|\return{\typeMP{numeric}} |
| 1708 |
\begin{description} |
| 1709 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1710 |
\end{description}\index{Excentricite@\lstinline+Excentricite+} |
| 1711 |
\end{colourband} |
| 1712 |
\bigskip |
| 1713 |
|
| 1714 |
|
| 1715 |
Pour obtenir l'inclinaison (coefficient directeur de la droite axe de symétrie |
| 1716 |
de la parabole), on utilisera la commande suivante: |
| 1717 |
|
| 1718 |
\begin{colourband} |
| 1719 |
\macro|Inclinaison(«a»)|\return{\typeMP{numeric}} |
| 1720 |
\begin{description} |
| 1721 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1722 |
\end{description}\index{Inclinaison@\lstinline+Inclinaison+} |
| 1723 |
\end{colourband} |
| 1724 |
\bigskip |
| 1725 |
|
| 1726 |
On peut obtenir le sommet de la parabole avec la commande suivante: |
| 1727 |
|
| 1728 |
\begin{colourband} |
| 1729 |
\macro|Sommet(«a»,«n»)|\return{\typeGDD{point}} |
| 1730 |
\begin{description} |
| 1731 |
\item[\meta{a}:] \typeGDD{parabole} ou \typeGDD{hyperbole} ; |
| 1732 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), argument utile pour l'hyperbole |
| 1733 |
qui possède deux sommets. Ici, peu importe la valeur de \meta{n}, l'unique |
| 1734 |
sommet sera donné. |
| 1735 |
\end{description}\index{Sommet@\lstinline+Sommet+} |
| 1736 |
\end{colourband} |
| 1737 |
\bigskip |
| 1738 |
|
| 1739 |
On peut obtenir la directrice de la parabole avec la commande suivante: |
| 1740 |
|
| 1741 |
\begin{colourband} |
| 1742 |
\macro|Directrice(«a»,«n»)|\return{\typeGDD{droite}} |
| 1743 |
\begin{description} |
| 1744 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole} |
| 1745 |
; |
| 1746 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), argument utile pour l'hyperbole |
| 1747 |
qui possède deux directrices. Ici, peu importe la valeur de \meta{n}, |
| 1748 |
l'unique directrice sera donnée. |
| 1749 |
\end{description}\index{Directrice@\lstinline+Directrice+} |
| 1750 |
\end{colourband} |
| 1751 |
\bigskip |
| 1752 |
|
| 1753 |
\begin{ExempleMP} |
| 1754 |
input geom2d; |
| 1755 |
beginfig(1); |
| 1756 |
A = Point(0,0); |
| 1757 |
B = Point(3,2); |
| 1758 |
AB = Droite(A,B); |
| 1759 |
F = Point(-1,1); |
| 1760 |
Para = ParaboleFD(F,AB); |
| 1761 |
trace AB; |
| 1762 |
trace Para; |
| 1763 |
pointe Sommet(Para,1); |
| 1764 |
pointe F; |
| 1765 |
Fenetre(-4,-5,2,5); |
| 1766 |
endfig; |
| 1767 |
\end{ExempleMP} |
| 1768 |
|
| 1769 |
|
| 1770 |
\subsection{Le type \typeGDD{hyperbole}} |
| 1771 |
|
| 1772 |
Le constructeur de base de l'hyperbole définit cet objet à partir du foyer et |
| 1773 |
de la directrice. |
| 1774 |
|
| 1775 |
Le code du constructeur est le suivant: |
| 1776 |
\begin{mpcode} |
| 1777 |
vardef HyperboleFD(expr F,D,e) = |
| 1778 |
% F : foyer (point) |
| 1779 |
% D : directrice (droite) |
| 1780 |
% e : exentricité (numeric) |
| 1781 |
% pm : +1 ou -1 pour les deux branches |
| 1782 |
save u, v, w, d, i, n,_tmp,slope,aa,bb; |
| 1783 |
pair _tmp; |
| 1784 |
n = incr gddO; |
| 1785 |
|
| 1786 |
(u,v,w) = EquationDroite(D); |
| 1787 |
d := u * gddA[F] + v * gddB[F] + w; |
| 1788 |
gddT[n] := "hyperbole"; |
| 1789 |
|
| 1790 |
% sommets |
| 1791 |
_tmp := -(d+1*sqrt(e*e*d*d))/(e*e-1)*(u,v)shifted (ProduitScalaire(F,Vecteur(v,-u))*(v,-u)); |
| 1792 |
gddB[n] := PointImp(_tmp); |
| 1793 |
_tmp := -(d-1*sqrt(e*e*d*d))/(e*e-1)*(u,v)shifted |
| 1794 |
(ProduitScalaire(F,Vecteur(v,-u))*(v,-u)); |
| 1795 |
gddC[n] := PointImp(_tmp); |
| 1796 |
% centre comme milieu des deux sommets |
| 1797 |
gddA[n] = Milieu(gddB[n],gddC[n]); |
| 1798 |
% le foyer (doublé pour compatibilité) |
| 1799 |
gddD[n] := F; |
| 1800 |
gddE[n] := RotationCentre(F, gddA[n], Pi); |
| 1801 |
gddX[n][3] := e; % excentricité |
| 1802 |
% directrices |
| 1803 |
gddX[n][1] := D; % on stocke la directrice |
| 1804 |
gddX[n][2] := Droite(RotationCentre(gddA[D], gddA[n], Pi),RotationCentre(gddB[D], gddA[n], Pi)); |
| 1805 |
% angle de l'axe |
| 1806 |
slope = angle(PairImp(gddA[D])-PairImp(gddB[D]))+90; |
| 1807 |
gddX[n][4] = slope; |
| 1808 |
% cercle principale |
| 1809 |
gddX[n][5] = CercleD(gddB[n],gddC[n]); |
| 1810 |
% asymptotes |
| 1811 |
aa = IntersectionDroiteCercle(D,gddX[n][5],1); |
| 1812 |
bb = IntersectionDroiteCercle(D,gddX[n][5],2); |
| 1813 |
gddX[n][6] = Droite(gddA[n],aa); |
| 1814 |
gddX[n][7] = Droite(gddA[n],bb); |
| 1815 |
% tracés des moitiés |
| 1816 |
i := -gddC2Dparam-1; |
| 1817 |
gddPX[n][1] := ( |
| 1818 |
( |
| 1819 |
(i*(v,-u)-(d+sqrt(e*e*d*d+i*i*(e*e-1)))/(e*e-1)*(u,v)) |
| 1820 |
for i:= -gddC2Dparam upto gddC2Dparam: |
| 1821 |
..(i*(v,-u)-(d+sqrt(e*e*d*d+i*i*(e*e-1)))/(e*e-1)*(u,v)) |
| 1822 |
endfor |
| 1823 |
) shifted (ProduitScalaire(F,Vecteur(v,-u))*(v,-u)) |
| 1824 |
); |
| 1825 |
gddPX[n][2] := ( |
| 1826 |
( |
| 1827 |
(i*(v,-u)-(d-sqrt(e*e*d*d+i*i*(e*e-1)))/(e*e-1)*(u,v)) |
| 1828 |
for i:= -gddC2Dparam upto gddC2Dparam: |
| 1829 |
..(i*(v,-u)-(d-sqrt(e*e*d*d+i*i*(e*e-1)))/(e*e-1)*(u,v)) |
| 1830 |
endfor |
| 1831 |
) shifted (ProduitScalaire(F,Vecteur(v,-u))*(v,-u)) |
| 1832 |
); |
| 1833 |
n |
| 1834 |
enddef; |
| 1835 |
\end{mpcode} |
| 1836 |
|
| 1837 |
On peut voir dans ce constructeur l'utilisation de la table de \typeMP{path} |
| 1838 |
étendu \variableGDD{gddPX[][]} qui permet d'associer plusieurs \typeMP{path}s à |
| 1839 |
un seul objet. |
| 1840 |
|
| 1841 |
\begin{colourband} |
| 1842 |
\macro|HyperboleFD(«f»,«d»,«e»)|\return{\typeGDD{hyperbole}} |
| 1843 |
\begin{description} |
| 1844 |
\item[\meta{f}:] est le foyer (\typeGDD{point}) de l’hyperbole; |
| 1845 |
\item[\meta{d}:] est la directrice (\typeGDD{droite}) de l’hyperbole; |
| 1846 |
\item[\meta{e}:] est l'excentricité de l'hyperbole. |
| 1847 |
\end{description} |
| 1848 |
\index{HyperboleFD@\lstinline+HyperboleFD+} |
| 1849 |
\end{colourband} |
| 1850 |
|
| 1851 |
On pourra aussi définir une hyperbole avec ses deux foyers et la distance entre |
| 1852 |
un sommet et le centre de l’hyperbole (définition bifocale). |
| 1853 |
|
| 1854 |
\begin{colourband} |
| 1855 |
\macro|HyperboleF(«f1»,«f2»,«a»)|\return{\typeGDD{hyperbole}} |
| 1856 |
\begin{description} |
| 1857 |
\item[\meta{f1}:] est un foyer (\typeGDD{point}) de l’hyperbole; |
| 1858 |
\item[\meta{f2}:] est le deuxième foyer (\typeGDD{point}) de l’hyperbole; |
| 1859 |
\item[\meta{a}:] est la moitié de la distance entre les deux sommets de l’hyperbole. |
| 1860 |
\end{description} |
| 1861 |
\index{HyperboleF@\lstinline+HyperboleF+} |
| 1862 |
\end{colourband} |
| 1863 |
|
| 1864 |
\subsubsection{Fonctions associées} |
| 1865 |
|
| 1866 |
On pourra obtenir le centre (\typeGDD{point}) d'une hyperbole avec la commande : |
| 1867 |
\begin{colourband} |
| 1868 |
\macro|Centre(«a»)|\return{\typeGDD{point}} |
| 1869 |
\begin{description} |
| 1870 |
\item[\meta{a}:] \typeGDD{cercle}, \typeGDD{ellipse} ou \typeGDD{hyperbole}. |
| 1871 |
\end{description}\index{Centre@\lstinline+Centre+} |
| 1872 |
\end{colourband} |
| 1873 |
|
| 1874 |
|
| 1875 |
On obtient l'excentricité, souvent notée $e$, avec la commande suivante. |
| 1876 |
|
| 1877 |
\begin{colourband} |
| 1878 |
\macro|Excentricite(«a»)|\return{\typeMP{numeric}} |
| 1879 |
\begin{description} |
| 1880 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1881 |
\end{description}\index{Excentricite@\lstinline+Excentricite+} |
| 1882 |
\end{colourband} |
| 1883 |
\bigskip |
| 1884 |
|
| 1885 |
|
| 1886 |
Pour obtenir l'inclinaison (coefficient directeur de la droite passant par les |
| 1887 |
foyers de l'hyperbole), on utilisera la commande suivante. |
| 1888 |
|
| 1889 |
\begin{colourband} |
| 1890 |
\macro|Inclinaison(«a»)|\return{\typeMP{numeric}} |
| 1891 |
\begin{description} |
| 1892 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole}. |
| 1893 |
\end{description}\index{Inclinaison@\lstinline+Inclinaison+} |
| 1894 |
\end{colourband} |
| 1895 |
\bigskip |
| 1896 |
|
| 1897 |
On peut obtenir les sommets de l'hyperbole avec la commande suivante: |
| 1898 |
|
| 1899 |
\begin{colourband} |
| 1900 |
\macro|Sommet(«a»,«n»)|\return{\typeGDD{point}} |
| 1901 |
\begin{description} |
| 1902 |
\item[\meta{a}:] \typeGDD{parabole} ou \typeGDD{hyperbole} ; |
| 1903 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), pour choisir l'un des deux sommets. |
| 1904 |
\end{description}\index{Sommet@\lstinline+Sommet+} |
| 1905 |
\end{colourband} |
| 1906 |
\bigskip |
| 1907 |
|
| 1908 |
On peut obtenir les directrices de l'hyperbole avec la commande suivante: |
| 1909 |
|
| 1910 |
\begin{colourband} |
| 1911 |
\macro|Directrice(«a»,«n»)|\return{\typeGDD{droite}} |
| 1912 |
\begin{description} |
| 1913 |
\item[\meta{a}:] \typeGDD{ellipse}, \typeGDD{parabole} ou \typeGDD{hyperbole} |
| 1914 |
; |
| 1915 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), pour choisir l'une des deux |
| 1916 |
directrices. |
| 1917 |
\end{description}\index{Directrice@\lstinline+Directrice+} |
| 1918 |
\end{colourband} |
| 1919 |
\bigskip |
| 1920 |
|
| 1921 |
Pour obtenir le \emph{cercle principal} de l'hyperbole, on pourra utiliser la |
| 1922 |
commande suivante: |
| 1923 |
|
| 1924 |
|
| 1925 |
\begin{colourband} |
| 1926 |
\macro|CerclePrincipale(«h»)|\return{\typeGDD{cercle}} |
| 1927 |
\begin{description} |
| 1928 |
\item[\meta{h}:] \typeGDD{hyperbole}. |
| 1929 |
\end{description}\index{CerclePrincipale@\lstinline+CerclePrincipale+} |
| 1930 |
\end{colourband} |
| 1931 |
\bigskip |
| 1932 |
|
| 1933 |
On pourra aussi obtenir les deux asymptotes de l'hyperbole avec la commande |
| 1934 |
suivante: |
| 1935 |
|
| 1936 |
\begin{colourband} |
| 1937 |
\macro|AsymptoteHyperbole(«h»,«n»)|\return{\typeGDD{droite}} |
| 1938 |
\begin{description} |
| 1939 |
\item[\meta{h}:] \typeGDD{hyperbole} ; |
| 1940 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), pour choisir l'une des deux |
| 1941 |
asymptotes. |
| 1942 |
\end{description}\index{AsymptoteHyperbole@\lstinline+AsymptoteHyperbole+} |
| 1943 |
\end{colourband} |
| 1944 |
\bigskip |
| 1945 |
|
| 1946 |
Parce qu'une hyperbole est constituée de deux parties disjointes, on ne peut |
| 1947 |
pas, comme pour les autres objets \mpgeomdd, utiliser directement la commande |
| 1948 |
\lstinline+trace+ directement sur l'objet. Il faudra utiliser la commande |
| 1949 |
suivante pour obtenir le \typeMP{path} associé à une des deux parties de |
| 1950 |
l'hyperbole. |
| 1951 |
|
| 1952 |
\begin{colourband} |
| 1953 |
\macro|DemiHyperbole(«h»,«n»)|\return{\typeGDD{path}} |
| 1954 |
\begin{description} |
| 1955 |
\item[\meta{h}:] \typeGDD{hyperbole} ; |
| 1956 |
\item[\meta{n}:] 1 ou 2 (\typeMP{numeric}), pour choisir l'une des deux |
| 1957 |
parties. |
| 1958 |
\end{description}\index{DemiHyperbole@\lstinline+DemiHyperbole+} |
| 1959 |
\end{colourband} |
| 1960 |
\bigskip |
| 1961 |
|
| 1962 |
|
| 1963 |
|
| 1964 |
\begin{ExempleMP} |
| 1965 |
input geom2d; |
| 1966 |
beginfig(1); |
| 1967 |
A = Point(0,0); |
| 1968 |
B = Point(3,2); |
| 1969 |
AB = Droite(A,B); |
| 1970 |
F = Point(-1,1); |
| 1971 |
Hyper = HyperboleFD(F,AB,1.5); |
| 1972 |
trace AB; |
| 1973 |
trace DemiHyperbole(Hyper,1); |
| 1974 |
trace DemiHyperbole(Hyper,2); |
| 1975 |
trace Directrice(Hyper,2); |
| 1976 |
trace CerclePrincipale(Hyper) dashed evenly; |
| 1977 |
trace AsymptoteHyperbole(Hyper,1) dashed evenly; |
| 1978 |
trace AsymptoteHyperbole(Hyper,2) dashed evenly; |
| 1979 |
pointe Centre(Hyper); |
| 1980 |
pointe Foyer(Hyper,1); |
| 1981 |
pointe Foyer(Hyper,2); |
| 1982 |
pointe Sommet(Hyper,1); |
| 1983 |
pointe Sommet(Hyper,2); |
| 1984 |
Fenetre(-3,-5,3,5); |
| 1985 |
endfig; |
| 1986 |
\end{ExempleMP} |
| 1987 |
|
| 1988 |
|
| 1989 |
\subsection{Le type \typeGDD{triangle}} |
| 1990 |
|
| 1991 |
Les triangles sont définis par trois |
| 1992 |
points de $\R^2$. |
| 1993 |
|
| 1994 |
\subsubsection{Constructeur} |
| 1995 |
La fonction créatrice de cet objet est la suivante |
| 1996 |
\begin{mpcode} |
| 1997 |
vardef Triangle (expr a,b,c) = |
| 1998 |
save n; n = incr gddO; gddT[n] = "triangle"; |
| 1999 |
gddA[n] = PointImp(a); gddB[n] = PointImp(b); gddC[n] = PointImp(c); n |
| 2000 |
enddef; |
| 2001 |
\end{mpcode} |
| 2002 |
|
| 2003 |
\begin{colourband} |
| 2004 |
\macro|Triangle(«a»,«b»,«c»)|\return{\typeMP{numeric}} |
| 2005 |
\begin{description} |
| 2006 |
\item[\meta{a}:] \typeGDD{point} ; |
| 2007 |
\item[\meta{b}:] \typeGDD{point} ; |
| 2008 |
\item[\meta{c}:] \typeGDD{point}. |
| 2009 |
\end{description}\index{Triangle@\lstinline+Triangle+} |
| 2010 |
\end{colourband} |
| 2011 |
|
| 2012 |
|
| 2013 |
\bigskip |
| 2014 |
|
| 2015 |
Ici, on voit l'appel à la troisième table \variableGDD{gddC} pour stocker le |
| 2016 |
troisième point. |
| 2017 |
|
| 2018 |
Un triangle se définit alors comme ceci: |
| 2019 |
\begin{ExempleMP} |
| 2020 |
input geom2d; |
| 2021 |
beginfig(1); |
| 2022 |
A = Point(3,1); |
| 2023 |
B = Point(1,3); |
| 2024 |
C = Point(0,0); |
| 2025 |
ABC = Triangle(A,B,C); |
| 2026 |
trace ABC; |
| 2027 |
endfig; |
| 2028 |
\end{ExempleMP} |
| 2029 |
|
| 2030 |
\subsubsection{Macros associées} |
| 2031 |
|
| 2032 |
La macro suivante permet de calculer l'aire d'un triangle. |
| 2033 |
\begin{colourband} |
| 2034 |
\macro|AireTriangle(«a»)|\return{\typeMP{numeric}} |
| 2035 |
\begin{description} |
| 2036 |
\item[\meta{a}:] \typeGDD{triangle}. |
| 2037 |
\end{description}\index{AireTriangle@\lstinline+AireTriangle+} |
| 2038 |
\end{colourband} |
| 2039 |
|
| 2040 |
On peut calculer aussi l'orthocentre d'un triangle avec la commande suivante. |
| 2041 |
\begin{colourband} |
| 2042 |
\macro|Orthocentre(«a»)|\return{\typeGDD{point}} |
| 2043 |
\begin{description} |
| 2044 |
\item[\meta{a}:] \typeGDD{triangle}. |
| 2045 |
\end{description}\index{Orthocentre@\lstinline+Orthocentre+} |
| 2046 |
\end{colourband} |
| 2047 |
|
| 2048 |
La macro suivante calcule le cercle inscrit d'un triangle. |
| 2049 |
\begin{colourband} |
| 2050 |
\macro|CercleInscrit(«a»)|\return{\typeGDD{cercle}} |
| 2051 |
\begin{description} |
| 2052 |
\item[\meta{a}:] \typeGDD{triangle}. |
| 2053 |
\end{description}\index{CercleInscrit@\lstinline+CercleInscrit+} |
| 2054 |
\end{colourband} |
| 2055 |
|
| 2056 |
On peut aussi obtenir le cercle circonscrit avec la macro suivante. |
| 2057 |
\begin{colourband} |
| 2058 |
\macro|CercleCirconscrit(«a»)|\return{\typeGDD{cercle}} |
| 2059 |
\begin{description} |
| 2060 |
\item[\meta{a}:] \typeGDD{triangle}. |
| 2061 |
\end{description}\index{CercleCirconscrit@\lstinline+CercleCirconscrit+} |
| 2062 |
\end{colourband} |
| 2063 |
|
| 2064 |
On peut aussi calculer les cercles exinscrits. Soient $A$, $B$ et $C$ trois points |
| 2065 |
définissant un triangle $ABC$\footnote{Évidemment, les points peuvent s'appeler |
| 2066 |
autrement.}. La commande suivante permet d'obtenir, au choix, un des trois |
| 2067 |
cercles exinscrits. |
| 2068 |
\begin{colourband} |
| 2069 |
\macro|CercleExinscrit(«a»,«n»)|\return{\typeGDD{cercle}} |
| 2070 |
\begin{description} |
| 2071 |
\item[\meta{a}:] \typeGDD{triangle} ; |
| 2072 |
\item[\meta{n}:] \typeMP{numeric} qui vaut 1, 2 ou 3. Si \meta{n}$=1$, c'est |
| 2073 |
le cercle exinscrit tangent au côté $[BC]$ du triangle, si \meta{n}$=2$, c'est |
| 2074 |
celui tangent au côté $[AC]$ et si \meta{n}$=3$, c'est celui tangent au côté $[AB]$. |
| 2075 |
\end{description}\index{CercleExinscrit@\lstinline+CercleExinscrit+} |
| 2076 |
\end{colourband} |
| 2077 |
|
| 2078 |
On peut aussi obtenir le cercle d'Euler d'un triangle avec la commande suivante. |
| 2079 |
\begin{colourband} |
| 2080 |
\macro|CercleEuler(«a»)|\return{\typeGDD{cercle}} |
| 2081 |
\begin{description} |
| 2082 |
\item[\meta{a}:] \typeGDD{triangle}. |
| 2083 |
\end{description}\index{CercleEuler@\lstinline+CercleEuler+} |
| 2084 |
\end{colourband} |
| 2085 |
|
| 2086 |
Voici un exemple d'illustration des quelques-unes des macros relatives aux |
| 2087 |
triangles. |
| 2088 |
\begin{ExempleMP} |
| 2089 |
input geom2d; |
| 2090 |
beginfig(1); |
| 2091 |
A = Point(3,1); |
| 2092 |
B = Point(1,3); |
| 2093 |
C = Point(0,0); |
| 2094 |
AB = Droite(A,B); |
| 2095 |
BC = Droite(B,C); |
| 2096 |
ABC = Triangle(A,B,C); |
| 2097 |
trace AB dashed evenly; |
| 2098 |
trace BC dashed evenly; |
| 2099 |
trace ABC avecCrayon(1.5,black); |
| 2100 |
Euler = CercleEuler(ABC); |
| 2101 |
trace Euler avecCrayon(1,DarkRed); |
| 2102 |
C_E1 = CercleExinscrit(ABC,2); |
| 2103 |
trace C_E1 avecCrayon(1,LightBlue); |
| 2104 |
C_C = CercleCirconscrit(ABC); |
| 2105 |
trace C_C avecCrayon(1,LightCoral); |
| 2106 |
Fenetre(-1,-4,4,4); |
| 2107 |
endfig; |
| 2108 |
\end{ExempleMP} |
| 2109 |
|
| 2110 |
\subsection{Le type \typeGDD{polygone}} |
| 2111 |
Les polygones sont définis par $N$ |
| 2112 |
points de $\R^2$. |
| 2113 |
|
| 2114 |
\subsubsection{Constructeurs} |
| 2115 |
|
| 2116 |
La fonction créatrice de cet objet est la suivante |
| 2117 |
\begin{mpcode} |
| 2118 |
vardef Polygone (text plist) = |
| 2119 |
save n,_point,i; n = incr gddO; gddT[n] = "polygone"; |
| 2120 |
i:=1; |
| 2121 |
for _point = plist: |
| 2122 |
gddX[gddO][i] = PointImp(_point); |
| 2123 |
i:=i+1; |
| 2124 |
endfor |
| 2125 |
gddA[n] = i-1; % nombre de côté |
| 2126 |
gddB[n] = IsoBarycentre(plist); % centre |
| 2127 |
n |
| 2128 |
enddef; |
| 2129 |
\end{mpcode} |
| 2130 |
|
| 2131 |
\begin{colourband} |
| 2132 |
\macro|Polygone(«liste»)|\return{\typeGDD{polygone}} |
| 2133 |
\begin{description} |
| 2134 |
\item[\meta{liste}:] est une liste de \typeGDD{point} ou de \typeMP{pair}. |
| 2135 |
\end{description}\index{Polygone@\lstinline+Polygone+} |
| 2136 |
\end{colourband} |
| 2137 |
|
| 2138 |
|
| 2139 |
\bigskip |
| 2140 |
|
| 2141 |
Ici, on voit l'appel à la \emph{double} table \variableGDD{gddX} pour stocker |
| 2142 |
les $N$ points. |
| 2143 |
|
| 2144 |
Un polygone se définit alors comme ceci: |
| 2145 |
\begin{ExempleMP} |
| 2146 |
input geom2d; |
| 2147 |
beginfig(1); |
| 2148 |
A = Point(2,0); |
| 2149 |
B = Point(3,1); |
| 2150 |
C = Point(0,2); |
| 2151 |
D = Point(0,0); |
| 2152 |
P = Polygone(A,B,C,D); |
| 2153 |
trace P; |
| 2154 |
endfig; |
| 2155 |
\end{ExempleMP} |
| 2156 |
|
| 2157 |
On pourra aussi construire des polygones réguliers avec la commande suivante. |
| 2158 |
\begin{colourband} |
| 2159 |
\macro|PolygoneRegulier(«N»,«rayon»,«rotation»,«translation»)|\return{\typeGDD{polygone}} |
| 2160 |
\begin{description} |
| 2161 |
\item[\meta{N}:] entier (\typeMP{numeric}) indiquant le nombre de points ; |
| 2162 |
\item[\meta{rayon}:] \typeMP{numeric}, rayon du cercle circonscrit ; |
| 2163 |
\item[\meta{rotation}:] \typeMP{numeric}, rotation du polygone ; |
| 2164 |
\item[\meta{translation}:] \typeGDD(point) ou \typeGDD{vecteur} (ou même |
| 2165 |
\typeMP{pair}), déplacement du centre du polygone. |
| 2166 |
\end{description}\index{PolygoneRegulier@\lstinline+PolygoneRegulier+} |
| 2167 |
\end{colourband} |
| 2168 |
|
| 2169 |
\begin{ExempleMP} |
| 2170 |
input geom2d; |
| 2171 |
beginfig(1); |
| 2172 |
P = PolygoneRegulier(7,3,0,origine); |
| 2173 |
trace P; |
| 2174 |
endfig; |
| 2175 |
\end{ExempleMP} |
| 2176 |
|
| 2177 |
\subsubsection{Macros associées} |
| 2178 |
|
| 2179 |
On pourra obtenir le nombre de côtés d'un polygone avec la commande suivante. |
| 2180 |
|
| 2181 |
\begin{colourband} |
| 2182 |
\macro|NombreCotesPolygone(«a»)|\return{\typeMP{numeric}} |
| 2183 |
\begin{description} |
| 2184 |
\item[\meta{a}:] \typeGDD{polygone}. |
| 2185 |
\end{description}\index{NombreCotesPolygone@\lstinline+NombreCotesPolygone+} |
| 2186 |
\end{colourband} |
| 2187 |
\bigskip |
| 2188 |
|
| 2189 |
On pourra avoir accès aux différents sommets du polygone, numérotés à partir de |
| 2190 |
1, avec la macro suivante. |
| 2191 |
|
| 2192 |
\begin{colourband} |
| 2193 |
\macro|PointPolygone(«a»,«i»)|\return{\typeGDD{point}} |
| 2194 |
\begin{description} |
| 2195 |
\item[\meta{a}:] \typeGDD{polygone} ; |
| 2196 |
\item[\meta{i}:] \typeMP{numeric}, entier plus grand que 1, permettant |
| 2197 |
d'accéder au $i$\ieme{} point du polygone. |
| 2198 |
\end{description}\index{PointPolygone@\lstinline+PointPolygone+} |
| 2199 |
\end{colourband} |
| 2200 |
\bigskip |
| 2201 |
|
| 2202 |
\subsection{Le type \typeGDD{chemin}} Pour ce type particulier, \mpgeomdd stocke |
| 2203 |
le \typeMP{path} dans la table \variableGDD{gddP} réservée. Ainsi la fonction |
| 2204 |
créatrice de ce type d'objet est la suivante |
| 2205 |
\begin{mpcode} |
| 2206 |
vardef Chemin (expr p) = |
| 2207 |
gddT[incr gddO] = "chemin"; gddP[gddO] = p; gddO |
| 2208 |
enddef; |
| 2209 |
\end{mpcode} |
| 2210 |
\begin{colourband} |
| 2211 |
\macro|Chemin(«p»)|\return{\typeGDD{chemin}} |
| 2212 |
\begin{description} |
| 2213 |
\item[\meta{p}:] un \typeMP{path} de \MP |
| 2214 |
\end{description}\index{Chemin@\lstinline+Chemin+} |
| 2215 |
\end{colourband} |
| 2216 |
|
| 2217 |
|
| 2218 |
\subsubsection{Macros associées} |
| 2219 |
|
| 2220 |
La macro suivante contruit, à partir d'une liste de \typeGDD{point}s, une ligne |
| 2221 |
brisée de type \typeGDD{chemin}. |
| 2222 |
|
| 2223 |
\begin{colourband} |
| 2224 |
\macro|LigneBrisee(«liste»)|\return{\typeGDD{chemin}} |
| 2225 |
\begin{description} |
| 2226 |
\item[\meta{liste}:] est une liste de \typeGDD{point} ou de \typeMP{pair}. |
| 2227 |
\end{description}\index{LigneBrisee@\lstinline+LigneBrisee+} |
| 2228 |
\end{colourband} |
| 2229 |
|
| 2230 |
|
| 2231 |
\subsection{Le type \typeGDD{courbe}} |
| 2232 |
|
| 2233 |
Pour ce type particulier, \mpgeomdd stocke |
| 2234 |
une chaine de caractère (un nom de fichier à exploiter avec l'extension |
| 2235 |
\fichier{graph.mp}) dans la table \variableGDD{gddS} réservée. |
| 2236 |
|
| 2237 |
\subsubsection{Constructeur} |
| 2238 |
|
| 2239 |
Ainsi la fonction |
| 2240 |
créatrice de ce type d'objet est la suivante |
| 2241 |
\begin{mpcode} |
| 2242 |
vardef CourbeDat (expr s) = |
| 2243 |
gddT[incr gddO] = "courbe"; gddS[gddO] = s; gddO |
| 2244 |
enddef; |
| 2245 |
\end{mpcode} |
| 2246 |
\begin{colourband} |
| 2247 |
\macro|CourbeDat(«s»)|\return{\typeGDD{courbe}} |
| 2248 |
\begin{description} |
| 2249 |
\item[\meta{s}:] un nom de fichier sous forme de \typeMP{string} de \MP |
| 2250 |
\end{description}\index{CourbeDat@\lstinline+CourbeDat+} |
| 2251 |
\end{colourband} |
| 2252 |
|
| 2253 |
\bigskip |
| 2254 |
|
| 2255 |
\section{Arc de cercle} |
| 2256 |
|
| 2257 |
Avec \mpgeomdd{}, quelques commandes permettent de travailler avec les arcs de |
| 2258 |
cercle. Tout d'abord, on peut décider de ne représenter qu'un arc de cercle d'un |
| 2259 |
\typeGDD{cercle} précédemment défini. Ceci se fait avec la commande suivante qui |
| 2260 |
prend en argument un \typeGDD{cercle} et deux angles en radian, et retourne un |
| 2261 |
\typeMP{path} de \MP{} correspondant à l'arc de cercle compris entre les deux |
| 2262 |
angles donnés (l'angle 0 étant parallèle à l'axe $Ox$). |
| 2263 |
|
| 2264 |
\begin{colourband} |
| 2265 |
\macro|gddTraceArcDeCercle(«C»,«a»,«b»)|\return{\typeMP{path}} |
| 2266 |
\begin{description} |
| 2267 |
\item[\meta{C}:] \typeGDD{cercle} dont on souhaite représenter un arc ; |
| 2268 |
\item[\meta{a}:] premier angle en radian (\typeMP{numeric}) ; |
| 2269 |
\item[\meta{b}:] deuxième angle en radian (\typeMP{numeric}). |
| 2270 |
\end{description}\index{gddTraceArcDeCercle@\lstinline+gddTraceArcDeCercle+} |
| 2271 |
\end{colourband} |
| 2272 |
|
| 2273 |
\begin{ExempleMP} |
| 2274 |
input geom2d; |
| 2275 |
beginfig(1); |
| 2276 |
C = Cercle(origine,2); |
| 2277 |
trace C; |
| 2278 |
trace gddTraceArcDeCercle(C,Pi/3,Pi) avecCrayon(2,DarkRed); |
| 2279 |
endfig; |
| 2280 |
\end{ExempleMP} |
| 2281 |
|
| 2282 |
On peut aussi définir un objet \typeGDD{chemin}. Pour cela on pourra utiliser |
| 2283 |
les deux commandes suivantes. La première permet de définir un arc de cercle à |
| 2284 |
partir d'un point, d'un rayon et de deux angles. |
| 2285 |
|
| 2286 |
\begin{colourband} |
| 2287 |
\macro|Arc(«P»,«r»,«a»,«b»)|\return{\typeGDD{chemin}} |
| 2288 |
\begin{description} |
| 2289 |
\item[\meta{P}:] \typeGDD{point} ou \typeMP{pair} centre de l'arc de cercle ; |
| 2290 |
\item[\meta{r}:] rayon de l'arc de cercle (\typeMP{numeric}) ; |
| 2291 |
\item[\meta{a}:] premier angle en radian (\typeMP{numeric}) ; |
| 2292 |
\item[\meta{b}:] premier angle en radian (\typeMP{numeric}). |
| 2293 |
\end{description}\index{Arc@\lstinline+Arc+} |
| 2294 |
\end{colourband} |
| 2295 |
|
| 2296 |
|
| 2297 |
\begin{ExempleMP} |
| 2298 |
input geom2d; |
| 2299 |
beginfig(1); |
| 2300 |
A = Point(2,2); |
| 2301 |
Ac = Arc(A,2,Pi/3,Pi); |
| 2302 |
pointe A; |
| 2303 |
trace Ac; |
| 2304 |
endfig; |
| 2305 |
\end{ExempleMP} |
| 2306 |
|
| 2307 |
La deuxième commande définissant un \typeGDD{chemin} est la suivante. Elle prend |
| 2308 |
comme arguments trois points, notons les $C$, $A$ et $B$ : le centre de l'arc de |
| 2309 |
cercle $C$, et les points $A$ et $B$. Elle prend ensuite comme argument le rayon |
| 2310 |
de l'arc défini entre les segments $[C,A]$ et $[C,B]$. |
| 2311 |
|
| 2312 |
\begin{colourband} |
| 2313 |
\macro|ArcEntrePoints(«P»,«r»,«A»,«B»,«s»)|\return{\typeGDD{chemin}} |
| 2314 |
\begin{description} |
| 2315 |
\item[\meta{P}:] \typeGDD{point} ou \typeMP{pair} centre de l'arc de cercle ; |
| 2316 |
\item[\meta{r}:] rayon de l'arc de cercle (\typeMP{numeric}) ; |
| 2317 |
\item[\meta{A}:] premier \typeGDD{point} ou \typeMP{pair} ; |
| 2318 |
\item[\meta{B}:] deuxième \typeGDD{point} ou \typeMP{pair} ; |
| 2319 |
\item[\meta{s}:] \typeMP{numeric}, $-1$ ou $1$ suivant le sens choisi. |
| 2320 |
\end{description}\index{ArcEntrePoints@\lstinline+ArcEntrePoints+} |
| 2321 |
\end{colourband} |
| 2322 |
|
| 2323 |
\begin{ExempleMP} |
| 2324 |
input geom2d; |
| 2325 |
beginfig(1); |
| 2326 |
C = Point(0,0); |
| 2327 |
A = Point(2,2); |
| 2328 |
B = Point(0,3); |
| 2329 |
Cab = ArcEntrePoints(C,1,A,B,1); |
| 2330 |
Cba = ArcEntrePoints(C,1,A,B,-1); |
| 2331 |
trace Segment(C,A); |
| 2332 |
trace Segment(C,B); |
| 2333 |
pointe A; pointe B; pointe C; |
| 2334 |
fleche Cab; |
| 2335 |
fleche Cba avecCrayon(1,DarkRed); |
| 2336 |
endfig; |
| 2337 |
\end{ExempleMP} |
| 2338 |
|
| 2339 |
\section{Quelques macros} |
| 2340 |
|
| 2341 |
Cette section regroupe quelques macros qui ne sont pas spécifiques à un type. |
| 2342 |
\bigskip |
| 2343 |
|
| 2344 |
La macro suivante permet de calculer un point d’intersection entre deux objets |
| 2345 |
\mpgeomdd. C’est en réalité une surcouche à la primitive \MP{} |
| 2346 |
\lstinline|intersectionpoint| appliquée sur les objets \emph{tracés} (avec |
| 2347 |
\lstinline+gddTraceObjet+). |
| 2348 |
\begin{colourband} |
| 2349 |
\macro|PointIntersection(«o»,«b»)|\return{\typeGDD{point}} |
| 2350 |
\begin{description} |
| 2351 |
\item[\meta{o}:] un objet \mpgeomdd ; |
| 2352 |
\item[\meta{b}:] un objet \mpgeomdd. |
| 2353 |
\end{description}\index{PointIntersection@\lstinline+PointIntersection+} |
| 2354 |
\end{colourband} |
| 2355 |
|
| 2356 |
\section{Quelques transformations} |
| 2357 |
|
| 2358 |
\subsection{Homothétie} |
| 2359 |
|
| 2360 |
On peut réaliser une homothétie sur n'importe quel objet \mpgeomdd avec la commande |
| 2361 |
suivante. |
| 2362 |
|
| 2363 |
\begin{colourband} |
| 2364 |
\macro|Homothetie(«p»,«o»,«k»)|\return{du même type que \meta{p}} |
| 2365 |
\begin{description} |
| 2366 |
\item[\meta{p}:] un objet \mpgeomdd ; |
| 2367 |
\item[\meta{o}:] \typeGDD{point} ou \typeMP{pair}, centre de l'homothétie ; |
| 2368 |
\item[\meta{k}:] \typeMP{numeric}, facteur de l'homothétie. |
| 2369 |
\end{description}\index{Homothetie@\lstinline+Homothetie+} |
| 2370 |
\end{colourband} |
| 2371 |
|
| 2372 |
\begin{ExempleMP} |
| 2373 |
input geom2d; |
| 2374 |
beginfig(1); |
| 2375 |
A = Point(1,2); |
| 2376 |
B = Point(0,2); |
| 2377 |
C_B = Cercle(B,1); |
| 2378 |
T = Triangle((1,1),(0,0),(0,1)); |
| 2379 |
C_H = Homothetie(C_B, A, 2); |
| 2380 |
T_H = Homothetie(T, A ,-1); |
| 2381 |
trace C_B; trace C_H; |
| 2382 |
trace T; trace T_H; |
| 2383 |
pointe A; pointe B; |
| 2384 |
endfig; |
| 2385 |
\end{ExempleMP} |
| 2386 |
|
| 2387 |
\subsection{Symétrie axiale} |
| 2388 |
|
| 2389 |
On peut réaliser une symétrie axiale sur n'importe quel objet \mpgeomdd avec la |
| 2390 |
commande suivante. |
| 2391 |
|
| 2392 |
\begin{colourband} |
| 2393 |
\macro|SymetrieAxiale(«p»,«d»)|\return{du même type que \meta{p}} |
| 2394 |
\begin{description} |
| 2395 |
\item[\meta{p}:] un objet \mpgeomdd ; |
| 2396 |
\item[\meta{d}:] \typeGDD{droite} définissant l'axe de symétrie. |
| 2397 |
\end{description}\index{SymetrieAxiale@\lstinline+SymetrieAxiale+} |
| 2398 |
\end{colourband} |
| 2399 |
|
| 2400 |
\begin{ExempleMP} |
| 2401 |
input geom2d; |
| 2402 |
beginfig(1); |
| 2403 |
A = Point(1,2); |
| 2404 |
B = Point(0,2); |
| 2405 |
C_B = Cercle(B,1); |
| 2406 |
T = Triangle((1,1),(0,0),(0,1)); |
| 2407 |
D = Droite((-1,0),(3,-1)); |
| 2408 |
C_H = SymetrieAxiale(C_B, D); |
| 2409 |
T_H = SymetrieAxiale(T, D); |
| 2410 |
trace C_B; trace C_H; |
| 2411 |
trace T; trace T_H; |
| 2412 |
trace D; |
| 2413 |
pointe A; pointe B; |
| 2414 |
Fenetre(-2.5,-3.5,3,3.2); |
| 2415 |
endfig; |
| 2416 |
\end{ExempleMP} |
| 2417 |
|
| 2418 |
\subsection{Symétrie centrale} |
| 2419 |
|
| 2420 |
On peut réaliser une symétrie centrale sur n'importe quel objet \mpgeomdd avec la |
| 2421 |
commande suivante. |
| 2422 |
|
| 2423 |
\begin{colourband} |
| 2424 |
\macro|SymetrieCentrale(«p»,«d»)|\return{du même type que \meta{p}} |
| 2425 |
\begin{description} |
| 2426 |
\item[\meta{p}:] un objet \mpgeomdd ; |
| 2427 |
\item[\meta{d}:] \typeGDD{point} définissant le centre de symétrie. |
| 2428 |
\end{description}\index{SymetrieCentrale@\lstinline+SymetrieCentrale+} |
| 2429 |
\end{colourband} |
| 2430 |
|
| 2431 |
\begin{ExempleMP} |
| 2432 |
input geom2d; |
| 2433 |
beginfig(1); |
| 2434 |
A = Point(1,2); |
| 2435 |
B = Point(0,2); |
| 2436 |
C_B = Cercle(B,1); |
| 2437 |
T = Triangle((1,1),(0,0),(0,1)); |
| 2438 |
D = Point(-1,0); |
| 2439 |
C_H = SymetrieCentrale(C_B, D); |
| 2440 |
T_H = SymetrieCentrale(T, D); |
| 2441 |
trace C_B; trace C_H; |
| 2442 |
trace T; trace T_H; |
| 2443 |
pointe D; |
| 2444 |
pointe A; pointe B; |
| 2445 |
Fenetre(-3.5,-3.5,3,3.2); |
| 2446 |
endfig; |
| 2447 |
\end{ExempleMP} |
| 2448 |
|
| 2449 |
\subsection{Inversion} |
| 2450 |
|
| 2451 |
On peut calculer l'inversion d'un point, d'un cercle ou d'une droite par rapport à un cercle avec la macro |
| 2452 |
suivante. |
| 2453 |
\begin{colourband} |
| 2454 |
\macro|Inversion(«p»,«c»)|\return{\typeGDD{point}} |
| 2455 |
\begin{description} |
| 2456 |
\item[\meta{p}:] \typeGDD{point}, \typeGDD{cercle} ou \typeGDD{droite} ; |
| 2457 |
\item[\meta{c}:] \typeGDD{cercle}. |
| 2458 |
\end{description}\index{Inversion@\lstinline+Inversion+} |
| 2459 |
\end{colourband} |
| 2460 |
\bigskip |
| 2461 |
|
| 2462 |
\begin{ExempleMP} |
| 2463 |
input geom2d; |
| 2464 |
beginfig(1); |
| 2465 |
A = Point(2,2); |
| 2466 |
C = Cercle(A,2); |
| 2467 |
trace C; |
| 2468 |
marque.rt "A"; |
| 2469 |
B = Point(-0.5,1); |
| 2470 |
D = Inversion(B,C); |
| 2471 |
drawoptions(withcolor DarkRed); |
| 2472 |
marque.rt "B"; marque.rt "D"; |
| 2473 |
|
| 2474 |
drawoptions(withcolor DarkBlue); |
| 2475 |
E = Point(3,1); |
| 2476 |
CE = Cercle(E,0.5); |
| 2477 |
trace CE; |
| 2478 |
marque.rt "E"; |
| 2479 |
iCE = Inversion(CE,C); |
| 2480 |
trace iCE; |
| 2481 |
|
| 2482 |
|
| 2483 |
drawoptions(withcolor DarkGreen); |
| 2484 |
d = Droite((3,3),(4,2)); |
| 2485 |
trace d; |
| 2486 |
Cd = Inversion(d,C); |
| 2487 |
trace Cd; |
| 2488 |
Fenetre(-1,-1,5.5,6); |
| 2489 |
endfig; |
| 2490 |
\end{ExempleMP} |
| 2491 |
|
| 2492 |
\subsection{Similitude à centre (directe)} |
| 2493 |
|
| 2494 |
On peut calculer la similitude à centre d’un point de rapport donnée. Cela se |
| 2495 |
fera avec la macro suivante. |
| 2496 |
|
| 2497 |
\begin{colourband} |
| 2498 |
\macro|SimilitudeACentre(«p»,«d»,«a»,«k»)|\return{du même type que \meta{p}} |
| 2499 |
\begin{description} |
| 2500 |
\item[\meta{p}:] un objet \mpgeomdd ; |
| 2501 |
\item[\meta{d}:] \typeGDD{point} définissant le centre de la similitude; |
| 2502 |
\item[\meta{a}:] angle en radian (\typeMP{numeric}) de la similitude; |
| 2503 |
\item[\meta{k}:] facteur (\typeMP{numeric}) de la similitude. |
| 2504 |
\end{description}\index{SimilitudeACentre@\lstinline+SimilitudeACentre+} |
| 2505 |
\end{colourband} |
| 2506 |
|
| 2507 |
\begin{ExempleMP} |
| 2508 |
input geom2d; |
| 2509 |
beginfig(1); |
| 2510 |
A = Point(1,2); |
| 2511 |
B = Point(0,2); |
| 2512 |
C_B = Cercle(B,1); |
| 2513 |
facteurSimi = 0.4; |
| 2514 |
angleSimi = Pi/3; |
| 2515 |
T = Triangle((1,1),(0,0),(0,1)); |
| 2516 |
D = Point(-1,0); |
| 2517 |
C_H = SimilitudeACentre(C_B, D,angleSimi,facteurSimi); |
| 2518 |
T_H = SimilitudeACentre(T, D,angleSimi,facteurSimi); |
| 2519 |
trace C_B; trace C_H; |
| 2520 |
trace T; trace T_H; |
| 2521 |
marque.bot "D"; |
| 2522 |
Fenetre(-3.5,-3.5,3,3.2); |
| 2523 |
endfig; |
| 2524 |
\end{ExempleMP} |
| 2525 |
|
| 2526 |
\section{Annotations et labels} |
| 2527 |
|
| 2528 |
\subsection{Signes} |
| 2529 |
|
| 2530 |
\mpgeomdd fournit la macro suivante pour marquer un angle droit formé par trois |
| 2531 |
points: |
| 2532 |
\begin{colourband} |
| 2533 |
\macro|SigneOrtho(«a»,«b»,«c»,«x»)| |
| 2534 |
\begin{description} |
| 2535 |
\item[\meta{a},\meta{b},\meta{c}:] sont les trois \typeGDD{point}s formant |
| 2536 |
l'angle droit $\widehat{ABC}$ ; |
| 2537 |
\item[\meta{x}:] est la \og{}taille\fg{} (\typeMP{numeric}) du signe d'orthogonalité. |
| 2538 |
\end{description}\index{SigneOrtho@\lstinline+SigneOrtho+} |
| 2539 |
\end{colourband} |
| 2540 |
|
| 2541 |
On peut aussi réaliser des marques entre deux points ou sur un segment, un |
| 2542 |
vecteur, ou tout type d'objet. Pour cela, la première macro est la suivante: |
| 2543 |
\begin{colourband} |
| 2544 |
\macro|Marque(«a»,«b»,«n»)| |
| 2545 |
\begin{description} |
| 2546 |
\item[\meta{a}:] premier \typeGDD{point} formant |
| 2547 |
le segment à marquer; |
| 2548 |
\item[\meta{b}:] deuxième \typeGDD{point} formant |
| 2549 |
le segment à marquer; |
| 2550 |
\item[\meta{n}:] est le type (\typeMP{numeric}) de marque, il y en a quatre |
| 2551 |
\meta{n}$=1$, $2$, $3$ ou $4$. |
| 2552 |
\end{description}\index{Marque@\lstinline+Marque+} |
| 2553 |
\end{colourband} |
| 2554 |
|
| 2555 |
On peut aussi marquer n'importe quel type de trait avec la macro suivante: |
| 2556 |
\begin{colourband} |
| 2557 |
\macro|MarqueTrait(«a»,«n»)| |
| 2558 |
\begin{description} |
| 2559 |
\item[\meta{a}:] est n'importe quel objet \mpgeomdd ou même un \typeMP{path} \MP; |
| 2560 |
\item[\meta{n}:] est le type (\typeMP{numeric}) de marque, il y en a quatre |
| 2561 |
\meta{n}$=1$, $2$, $3$ ou $4$. |
| 2562 |
\end{description}\index{MarqueTrait@\lstinline+MarqueTrait+} |
| 2563 |
\end{colourband} |
| 2564 |
|
| 2565 |
|
| 2566 |
\begin{ExempleMP} |
| 2567 |
input geom2d; |
| 2568 |
beginfig(1); |
| 2569 |
A = Point(4,0); |
| 2570 |
B = Point(0,0); |
| 2571 |
C = Point(0,2); |
| 2572 |
trace Segment(B,A); |
| 2573 |
trace Segment(B,C); |
| 2574 |
marque.bot "A"; |
| 2575 |
marque.bot "B"; |
| 2576 |
marque.lft "C"; |
| 2577 |
trace SigneOrtho(A,B,C,0.5); |
| 2578 |
trace Marque(A,B,1); |
| 2579 |
trace MarqueTrait(Segment(B,C),3); |
| 2580 |
endfig; |
| 2581 |
\end{ExempleMP} |
| 2582 |
|
| 2583 |
|
| 2584 |
\subsection{Labels} |
| 2585 |
|
| 2586 |
Comme le code produit avec \mpgeomdd est un code \MP{}\cite{ctan-metapost}, on peut utiliser les outils |
| 2587 |
classiques de labélisation. Cependant, pour permettre plus de flexibilité (et |
| 2588 |
notamment une compatibilité avec \hologo{LuaLaTeX} et |
| 2589 |
\package{luamplib}~\cite{ctan-luamplib} ou |
| 2590 |
\package{minim-mp}~\cite{ctan-minim-mp}), si le code est compilé avec \MP{}, |
| 2591 |
alors le package~\package{latexmp}~\cite{ctan-latexmp} est chargé et fournit la |
| 2592 |
commande \lstinline+textext()+. |
| 2593 |
|
| 2594 |
De plus, \mpgeomdd fournit quelques commandes pour se faciliter la vie. |
| 2595 |
|
| 2596 |
On peut marquer les points avec la commande suivante. Cette commande |
| 2597 |
\emph{pointe} le point (avec la commande \lstinline+pointe+, voir |
| 2598 |
section~\ref{sec:trace}) et inscrit un label. |
| 2599 |
\begin{colourband} |
| 2600 |
\macro|marque.«place» "«nom»"| |
| 2601 |
\begin{description} |
| 2602 |
\item[\meta{place}:] peut être les classiques placements de \MP{} : |
| 2603 |
\lstinline+top+, \lstinline+bot+, \lstinline+rt+, |
| 2604 |
\lstinline+lft+,+\lstinline+urt+, \lstinline+ulft+, \lstinline+lrt+, \lstinline+llft+. |
| 2605 |
\item[\meta{nom}:] entre double quote, doit être un nom de variable de |
| 2606 |
point. Le nom sera composé en mode mathématique (entre \lstinline+$+). Si le |
| 2607 |
nom contient un \lstinline+_+, tout ce qui sera après sera mis en |
| 2608 |
indice (ex. \lstinline+A_be+ deviendra $A_{be}$). Si le nom est |
| 2609 |
\lstinline+alpha+, \lstinline+beta+, \lstinline+gamma+ ou \lstinline+delta+, |
| 2610 |
alors le résultat donnera la lettre grecque composée en mode mathématique. |
| 2611 |
\end{description}\index{marque@\lstinline+marque+} |
| 2612 |
\end{colourband} |
| 2613 |
|
| 2614 |
|
| 2615 |
\mpgeomdd fournit aussi une adaptation au classique \lstinline+label+ de \MP{}. |
| 2616 |
|
| 2617 |
\begin{colourband} |
| 2618 |
\macro|gddLabel.«place»(«materiel»,«point»)| |
| 2619 |
\begin{description} |
| 2620 |
\item[\meta{place}:] peut être les classiques placements de \MP{} : |
| 2621 |
\lstinline+top+, \lstinline+bot+, \lstinline+rt+, |
| 2622 |
\lstinline+lft+,+\lstinline+urt+, \lstinline+ulft+, \lstinline+lrt+, \lstinline+llft+. |
| 2623 |
\item[\meta{materiel}:] classiquement ce qu'on donne à \lstinline+label+, une |
| 2624 |
chaîne de caractères, ou une \typeMP{picture} (qui peut-être produite par |
| 2625 |
exemple avec \lstinline+btex ... etex+ ou, puisque \package{latexmp} est |
| 2626 |
chargé par \mpgeomdd, \lstinline+textext()+). |
| 2627 |
\item[\meta{point}:] doit être un \typeGDD{point} de \mpgeomdd. |
| 2628 |
\end{description}\index{gddLabel@\lstinline+gddLabel+} |
| 2629 |
\end{colourband} |
| 2630 |
|
| 2631 |
On peut aussi étiquetter un \typeGDD{chemin}, une \typeGDD{courbe} ou un |
| 2632 |
\typeMP{path} avec la macro suivante: |
| 2633 |
|
| 2634 |
\begin{colourband} |
| 2635 |
\macro|EtiquetteChemin.«place»(«materiel»,«chemin»,«position»)| |
| 2636 |
\begin{description} |
| 2637 |
\item[\meta{place}:] peut être les classiques placements de \MP{} : |
| 2638 |
\lstinline+top+, \lstinline+bot+, \lstinline+rt+, |
| 2639 |
\lstinline+lft+,+\lstinline+urt+, \lstinline+ulft+, \lstinline+lrt+, \lstinline+llft+. |
| 2640 |
\item[\meta{materiel}:] classiquement ce qu'on donne à \lstinline+label+, une |
| 2641 |
chaîne de caractères, ou une \typeMP{picture} (qui peut-être produite par |
| 2642 |
exemple avec \lstinline+btex ... etex+ ou, puisque \package{latexmp} est |
| 2643 |
chargé par \mpgeomdd, \lstinline+textext()+). |
| 2644 |
\item[\meta{chemin}:] doit être un \typeGDD{chemin}, une \typeGDD{courbe}, ou |
| 2645 |
un \typeMP{path}. |
| 2646 |
\end{description}\index{EtiquetteChemin@\lstinline+EtiquetteChemin+} |
| 2647 |
\end{colourband} |
| 2648 |
|
| 2649 |
|
| 2650 |
|
| 2651 |
\begin{ExempleMP} |
| 2652 |
input geom2d; |
| 2653 |
beginfig(1); |
| 2654 |
A = Point(0,0); |
| 2655 |
B_23 = Point(3,3); |
| 2656 |
alpha = Point(0,2); |
| 2657 |
trace Segment(A,B_23); |
| 2658 |
C = Milieu(A,B_23); |
| 2659 |
pointe C; |
| 2660 |
gddLabel.top(textext("Milieu"),C); |
| 2661 |
marque.top "A"; |
| 2662 |
marque.urt "B_23"; |
| 2663 |
marque.llft "alpha"; |
| 2664 |
P = Chemin(Pt(A)..Pt(alpha)..Pt(B_23)); |
| 2665 |
trace P; |
| 2666 |
EtiquetteChemin.top("Test",P,0.6); |
| 2667 |
endfig; |
| 2668 |
\end{ExempleMP} |
| 2669 |
|
| 2670 |
|
| 2671 |
\section{Repère} |
| 2672 |
|
| 2673 |
\mpgeomdd fournit un ensemble de commandes permettant de faciliter le dessin de |
| 2674 |
repère. |
| 2675 |
|
| 2676 |
La commande principale est la définition du repère, c'est-à-dire la boîte dans |
| 2677 |
laquelle le dessin sera représenté. |
| 2678 |
\begin{colourband} |
| 2679 |
\macro|Repere(«l»,«h»,«ox»,«oy»,«ux»,«uy»)| |
| 2680 |
\begin{description} |
| 2681 |
\item[\meta{l}:] \typeMP{numeric}, largeur du repère (en unité \lstinline+gddU+) ; |
| 2682 |
\item[\meta{h}:] \typeMP{numeric}, hauteur du repère (en unité \lstinline+gddU+) ; |
| 2683 |
\item[\meta{ox}:] \typeMP{numeric}, distance (en unité \lstinline+gddU+) de |
| 2684 |
l'origine (\typeGDD{point} $(0,0)$) par rapport au bord gauche ; |
| 2685 |
\item[\meta{oy}:] \typeMP{numeric}, distance (en unité \lstinline+gddU+) de |
| 2686 |
l'origine (\typeGDD{point} $(0,0)$) par rapport au bord bas ; |
| 2687 |
\item[\meta{ux}:] \typeMP{numeric}, unité de l'axe $(Ox)$ (en unité \lstinline+gddU+) ; |
| 2688 |
\item[\meta{uy}:] \typeMP{numeric}, unité de l'axe $(Oy)$ (en unité \lstinline+gddU+). |
| 2689 |
\end{description}\index{Repere@\lstinline+Repere+} |
| 2690 |
\end{colourband} |
| 2691 |
|
| 2692 |
Cette commande ne retourne, ni ne trace rien. Elle sert à spécifier quelques |
| 2693 |
variables internes de définition du dessin. Elle modifie d'ailleurs le |
| 2694 |
comportement de la macro \lstinline+gddEnPlace+ (voir |
| 2695 |
page~\pageref{gddEnPlace}). Noter que cette commande impose le fait que |
| 2696 |
l'origine (c'est-à-dire le \typeGDD{point} $(0,0)$) soit à l'intérieur du |
| 2697 |
repère. |
| 2698 |
|
| 2699 |
Cette macro s'accompagne de deux autres, elles aussi \emph{silencieuses}, ne |
| 2700 |
servant qu'à : |
| 2701 |
\begin{itemize} |
| 2702 |
\item sauvegarder la \typeMP{picture} courante ; |
| 2703 |
\item construire une \typeMP{picture} avec le contenu se trouvant entre |
| 2704 |
\lstinline+Debut+ et \lstinline+Fin+ ; |
| 2705 |
\item rogner (avec \lstinline+clip+) la \typeMP{picture} aux cadre du repère |
| 2706 |
construit ; |
| 2707 |
\item ajouter la \typeMP{picture} courant à celle sauvegarder ; |
| 2708 |
\item enfin rétablir le |
| 2709 |
fonctionnement de \lstinline+gddEnPlace+ comme avant l'utilisation de |
| 2710 |
\lstinline+Repere+. |
| 2711 |
\end{itemize} |
| 2712 |
|
| 2713 |
Ces deux commandes sont appelées \lstinline+Debut+ et |
| 2714 |
\lstinline+Fin+. |
| 2715 |
|
| 2716 |
\begin{colourband} |
| 2717 |
\macro|Debut| |
| 2718 |
\index{Debut@\lstinline+Debut+} |
| 2719 |
\end{colourband} |
| 2720 |
|
| 2721 |
|
| 2722 |
\begin{colourband} |
| 2723 |
\macro|Fin| |
| 2724 |
\index{Fin@\lstinline+Fin+} |
| 2725 |
\end{colourband} |
| 2726 |
|
| 2727 |
Ainsi, il est très simple d'illustrer le fait qu'à un changement de base |
| 2728 |
orthogonale prêt, un cercle est une ellipse. |
| 2729 |
|
| 2730 |
\begin{ExempleMP} |
| 2731 |
input geom2d; |
| 2732 |
beginfig(1); |
| 2733 |
A = Point(1,1); |
| 2734 |
CA = Cercle(A,2); |
| 2735 |
Repere(5,5,1,1,1,0.5); |
| 2736 |
Debut; |
| 2737 |
trace CA; |
| 2738 |
Fin; |
| 2739 |
endfig; |
| 2740 |
\end{ExempleMP} |
| 2741 |
|
| 2742 |
On dispose de deux commandes pour tracer les axes du repère. La première trace |
| 2743 |
les axes passant par l'origine. |
| 2744 |
\begin{colourband} |
| 2745 |
\macro|Axes|\indication{trace un ensemble d'éléments sur le repère} |
| 2746 |
\index{Axes@\lstinline+Axes+} |
| 2747 |
\end{colourband} |
| 2748 |
|
| 2749 |
Cette commande inscrit aussi les labels des axes des abscisses et des ordonnées |
| 2750 |
qui sont stockées dans les variables globales dédiées suivantes: |
| 2751 |
\begin{colourband} |
| 2752 |
\macro|gddXlabel|\indication{\typeMP{string}, valeur par défaut \lstinline+"$x$"+} |
| 2753 |
\index{gddXlabel@\lstinline+gddXlabel+} |
| 2754 |
\end{colourband} |
| 2755 |
|
| 2756 |
\begin{colourband} |
| 2757 |
\macro|gddYlabel|\indication{\typeMP{string}, valeur par défaut \lstinline+"$y$"+} |
| 2758 |
\index{gddYlabel@\lstinline+gddYlabel+} |
| 2759 |
\end{colourband} |
| 2760 |
|
| 2761 |
Attention, ces commandes doivent s'utiliser avant l'appel à \lstinline+Debut+. |
| 2762 |
|
| 2763 |
L'exemple suivant permet d'illustrer le tracé des axes. |
| 2764 |
|
| 2765 |
\begin{ExempleMP} |
| 2766 |
input geom2d; |
| 2767 |
beginfig(1); |
| 2768 |
A = Point(1,1); |
| 2769 |
CA = Cercle(A,2); |
| 2770 |
Repere(5,5,1,1,1,1); |
| 2771 |
gddYlabel:="$z$"; |
| 2772 |
Axes; |
| 2773 |
Debut; |
| 2774 |
trace CA; |
| 2775 |
Fin; |
| 2776 |
endfig; |
| 2777 |
\end{ExempleMP} |
| 2778 |
|
| 2779 |
On pourra aussi définir un repère en utilisant une syntaxe permettant de |
| 2780 |
spécifier les abscisses et les ordonnées extrémales. |
| 2781 |
|
| 2782 |
\begin{colourband} |
| 2783 |
\macro|RepereMinMax(«xmin»,«xmax»,«ymin»,«ymax»,«ux»,«uy»)| |
| 2784 |
\begin{description} |
| 2785 |
\item[\meta{xmin}:] \typeMP{numeric}, abscisse minimum (en unité \lstinline+gddU+). |
| 2786 |
\item[\meta{xmax}:] \typeMP{numeric}, abscisse maximum (en unité \lstinline+gddU+). |
| 2787 |
\item[\meta{ymin}:] \typeMP{numeric}, ordonnée minimum (en unité \lstinline+gddU+). |
| 2788 |
\item[\meta{ymax}:] \typeMP{numeric}, ordonnée maximum (en unité \lstinline+gddU+). |
| 2789 |
\item[\meta{ux}:] \typeMP{numeric}, unité de l'axe $(Ox)$ (en unité \lstinline+gddU+). |
| 2790 |
\item[\meta{uy}:] \typeMP{numeric}, unité de l'axe $(Oy)$ (en unité \lstinline+gddU+). |
| 2791 |
\end{description}\index{RepereMinMax@\lstinline+RepereMinMax+} |
| 2792 |
\end{colourband} |
| 2793 |
|
| 2794 |
\begin{ExempleMP} |
| 2795 |
input geom2d; |
| 2796 |
beginfig(1); |
| 2797 |
A = Point(1,1); |
| 2798 |
CA = Cercle(A,2); |
| 2799 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2800 |
Axes; |
| 2801 |
Debut; |
| 2802 |
trace CA; |
| 2803 |
Fin; |
| 2804 |
endfig; |
| 2805 |
\end{ExempleMP} |
| 2806 |
|
| 2807 |
\mpgeomdd fournit aussi de quoi tracer les axes sur le bord du cadre avec la |
| 2808 |
commande suivante. |
| 2809 |
\begin{colourband} |
| 2810 |
\macro|AxesBords|\indication{trace un ensemble d'éléments sur le repère} |
| 2811 |
\index{AxesBords@\lstinline+AxesBords+} |
| 2812 |
\end{colourband} |
| 2813 |
|
| 2814 |
\begin{ExempleMP} |
| 2815 |
input geom2d; |
| 2816 |
beginfig(1); |
| 2817 |
A = Point(1,1); |
| 2818 |
CA = Cercle(A,2); |
| 2819 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2820 |
AxesBords; |
| 2821 |
Debut; |
| 2822 |
trace CA; |
| 2823 |
Fin; |
| 2824 |
endfig; |
| 2825 |
\end{ExempleMP} |
| 2826 |
|
| 2827 |
Les commandes suivantes permettent de graduer les axes (classiques ou sur le |
| 2828 |
bord). Là encore, ce sont des commandes qui n'ont pas d'arguments ni ne |
| 2829 |
retournent rien et qui tracent. |
| 2830 |
|
| 2831 |
\begin{colourband} |
| 2832 |
\macro|Graduations|\indication{trace un ensemble d'éléments sur le repère} |
| 2833 |
\index{Graduations@\lstinline+Graduations+} |
| 2834 |
\end{colourband} |
| 2835 |
|
| 2836 |
|
| 2837 |
\begin{colourband} |
| 2838 |
\macro|GraduationsBords|\indication{trace un ensemble d'éléments sur le repère} |
| 2839 |
\index{GraduationsBords@\lstinline+GraduationsBords+} |
| 2840 |
\end{colourband} |
| 2841 |
|
| 2842 |
On utilisera la version en cohérence avec les axes choisis. |
| 2843 |
|
| 2844 |
\begin{ExempleMP} |
| 2845 |
input geom2d; |
| 2846 |
beginfig(1); |
| 2847 |
A = Point(1,1); |
| 2848 |
CA = Cercle(A,2); |
| 2849 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2850 |
AxesBords; |
| 2851 |
GraduationsBords; |
| 2852 |
Debut; |
| 2853 |
trace CA; |
| 2854 |
Fin; |
| 2855 |
endfig; |
| 2856 |
\end{ExempleMP} |
| 2857 |
|
| 2858 |
Si on désire marquer les unités, \mpgeomdd{} propose la macro suivante (qui n'est |
| 2859 |
utilisable que si l'on ne place pas les axes sur le bord). |
| 2860 |
\begin{colourband} |
| 2861 |
\macro|Unites(«unité»)|\indication{trace un ensemble d'éléments sur le repère} |
| 2862 |
\begin{description} |
| 2863 |
\item[\meta{unité}:] \typeMP{numeric}, valeur à inscrire sur les deux axes. |
| 2864 |
\end{description} |
| 2865 |
\index{Unites@\lstinline+Unites+} |
| 2866 |
\end{colourband} |
| 2867 |
|
| 2868 |
\begin{ExempleMP} |
| 2869 |
input geom2d; |
| 2870 |
beginfig(1); |
| 2871 |
A = Point(1,1); |
| 2872 |
CA = Cercle(A,2); |
| 2873 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2874 |
Axes; |
| 2875 |
Debut; |
| 2876 |
Graduations; |
| 2877 |
Unites(2); |
| 2878 |
trace CA; |
| 2879 |
Fin; |
| 2880 |
endfig; |
| 2881 |
\end{ExempleMP} |
| 2882 |
|
| 2883 |
On peut aussi ajouter une grille sur notre repère avec la macro suivante. |
| 2884 |
\begin{colourband} |
| 2885 |
\macro|GrilleRepere|\indication{trace un ensemble d'éléments sur le repère} |
| 2886 |
\index{GrilleRepere@\lstinline+GrilleRepere+} |
| 2887 |
\end{colourband} |
| 2888 |
Dans l'exemple suivant, on règle la couleur de la grille avec la commande |
| 2889 |
\hologo{MetaPost} \lstinline+drawoptions+. |
| 2890 |
\begin{ExempleMP} |
| 2891 |
input geom2d; |
| 2892 |
beginfig(1); |
| 2893 |
A = Point(1,1); |
| 2894 |
CA = Cercle(A,2); |
| 2895 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2896 |
drawoptions(withcolor LightGrey); |
| 2897 |
GrilleRepere; |
| 2898 |
drawoptions(); |
| 2899 |
Axes; |
| 2900 |
Debut; |
| 2901 |
Graduations; |
| 2902 |
Unites(1); |
| 2903 |
trace CA; |
| 2904 |
Fin; |
| 2905 |
endfig; |
| 2906 |
\end{ExempleMP} |
| 2907 |
On pourra aussi ajouter un cadre au repère avec la macro suivante. |
| 2908 |
\begin{colourband} |
| 2909 |
\macro|CadreRepere|\return{\typeMP{path}} |
| 2910 |
\index{CadreRepere@\lstinline+CadreRepere+} |
| 2911 |
\end{colourband} |
| 2912 |
Dans l'exemple suivant, on règle la couleur de la grille avec la commande |
| 2913 |
\hologo{MetaPost} \lstinline+drawoptions+. |
| 2914 |
\begin{ExempleMP} |
| 2915 |
input geom2d; |
| 2916 |
beginfig(1); |
| 2917 |
A = Point(1,1); |
| 2918 |
CA = Cercle(A,2); |
| 2919 |
RepereMinMax(-1,4,-1,4,1,1); |
| 2920 |
drawoptions(withcolor LightGrey); |
| 2921 |
GrilleRepere; |
| 2922 |
drawoptions(); |
| 2923 |
Axes; |
| 2924 |
Debut; |
| 2925 |
Graduations; |
| 2926 |
Unites(1); |
| 2927 |
trace CA; |
| 2928 |
trace CadreRepere withcolor OrangeRed; |
| 2929 |
Fin; |
| 2930 |
endfig; |
| 2931 |
\end{ExempleMP} |
| 2932 |
|
| 2933 |
\section{Quelques constantes et fonctions mathématiques} |
| 2934 |
|
| 2935 |
\mpgeomdd définit deux constantes mathématiques \lstinline+Pi+ et \lstinline+_E+ |
| 2936 |
\index{Pi@\lstinline+Pi+}\index{_E@\lstinline+_E+} pour les constantes |
| 2937 |
$\uppi\simeq 3.14159265$ et $\mathrm{e}=2.71828183$. |
| 2938 |
|
| 2939 |
De plus, le package définit quelques fonctions mathématiques de la variable |
| 2940 |
réelle : |
| 2941 |
\begin{colourband} |
| 2942 |
\macro|sin(«x»)| \index{sin@\lstinline+sin+} |
| 2943 |
\macro|cos(«x»)| \index{cos@\lstinline+cos+} |
| 2944 |
\macro|tan(«x»)| \index{tan@\lstinline+tan+} |
| 2945 |
\macro|exp(«x»)| \index{exp@\lstinline+exp+} |
| 2946 |
\macro|ln(«x»)| \index{ln@\lstinline+ln+} |
| 2947 |
\macro|ch(«x»)| \index{ch@\lstinline+ch+} |
| 2948 |
\macro|sh(«x»)| \index{sh@\lstinline+sh+} |
| 2949 |
\macro|th(«x»)| \index{th@\lstinline+th+} |
| 2950 |
\macro|arcsin(«x»)| \index{arcsin@\lstinline+arcsin+} |
| 2951 |
\macro|arccos(«x»)| \index{arccos@\lstinline+arccos+} |
| 2952 |
\macro|arctan(«x»)| \index{arctan@\lstinline+arctan+} |
| 2953 |
\end{colourband} |
| 2954 |
|
| 2955 |
\section{Représentation de courbes et de fonctions} |
| 2956 |
|
| 2957 |
\mpgeomdd{} fournit aussi quelques macros facilitant la représentation simple de |
| 2958 |
courbes et de fonctions mathématiques. |
| 2959 |
|
| 2960 |
\subsection{Fonction de la variable réelle} |
| 2961 |
|
| 2962 |
Pour représenter une fonction de la variable réelle, on utilisera la macro |
| 2963 |
suivante: |
| 2964 |
\begin{colourband} |
| 2965 |
\macro|Representation(«fonction»)(«ti»,«tf»,«n»)|\return{\typeMP{path}} |
| 2966 |
\begin{description} |
| 2967 |
\item[\meta{fonction}:] est une macro \MP{} qui définit la fonction |
| 2968 |
mathématique d'une variable réelle que l'on souhaite représenter ; |
| 2969 |
\item[\meta{ti}:] est la valeur (\typeMP{numeric}) initiale de la variable à |
| 2970 |
partir de laquelle on souhaite construire la représentation de la fonction ; |
| 2971 |
\item[\meta{tf}:] est la valeur (\typeMP{numeric}) finale de la variable |
| 2972 |
jusqu'à laquelle on souhaite construire la représentation de la fonction ; |
| 2973 |
\item[\meta{n}:] est le nombre de pas (\typeMP{numeric}) utilisé pour la |
| 2974 |
discrétisation de la représentation. |
| 2975 |
\end{description} |
| 2976 |
\index{Representation@\lstinline+Representation+} |
| 2977 |
\end{colourband} |
| 2978 |
|
| 2979 |
\begin{ExempleMP} |
| 2980 |
input geom2d; |
| 2981 |
beginfig(1); |
| 2982 |
RepereMinMax(-2Pi,2Pi,-1.1,1.1,0.4,1); |
| 2983 |
Axes; |
| 2984 |
Debut; |
| 2985 |
Graduations; |
| 2986 |
trace Representation(cos,-2Pi,2Pi,100); |
| 2987 |
Fin; |
| 2988 |
endfig; |
| 2989 |
\end{ExempleMP} |
| 2990 |
|
| 2991 |
\subsection{Courbe paramétrique} |
| 2992 |
|
| 2993 |
Pour représenter une courbe plane définie par deux fonctions décrivant |
| 2994 |
l'abscisse et l'ordonnée en fonction d'un paramètre, on utilisera la macro suivante: |
| 2995 |
\begin{colourband} |
| 2996 |
\macro|Courbe(«fct_abscisse»)(«fct_ordonnee»)(«ti»,«tf»,«n»)|\return{\typeMP{path}} |
| 2997 |
\begin{description} |
| 2998 |
\item[\meta{fct\_abscisse}:] est une macro \MP{} qui définit la fonction |
| 2999 |
mathématique d'une variable réelle décrivant l'évolution de l'abscisse des |
| 3000 |
points de la courbe que l'on souhaite représenter ; |
| 3001 |
\item[\meta{fct\_ordonnee}:] est une macro \MP{} qui définit la fonction |
| 3002 |
mathématique d'une variable réelle décrivant l'évolution de l'ordonnée des |
| 3003 |
points de la courbe que l'on souhaite représenter ; |
| 3004 |
\item[\meta{ti}:] est la valeur (\typeMP{numeric}) initiale de la variable à |
| 3005 |
partir de laquelle on souhaite construire la représentation de la fonction ; |
| 3006 |
\item[\meta{tf}:] est la valeur (\typeMP{numeric}) finale de la variable |
| 3007 |
jusqu'à laquelle on souhaite construire la représentation de la fonction ; |
| 3008 |
\item[\meta{n}:] est le nombre de pas (\typeMP{numeric}) utilisé pour la |
| 3009 |
discrétisation de la représentation. |
| 3010 |
\end{description} |
| 3011 |
\index{Courbe@\lstinline+Courbe+} |
| 3012 |
\end{colourband} |
| 3013 |
|
| 3014 |
\begin{ExempleMP} |
| 3015 |
input geom2d; |
| 3016 |
vardef f_a(expr t)= cos(t) enddef; |
| 3017 |
vardef f_o(expr t)= sin(2*t) enddef; |
| 3018 |
|
| 3019 |
beginfig(1); |
| 3020 |
RepereMinMax(-1.1,1.1,-1.1,1.1,2,2); |
| 3021 |
Axes; |
| 3022 |
Debut; |
| 3023 |
Graduations; |
| 3024 |
trace Courbe(f_a,f_o,-2Pi,2Pi,100); |
| 3025 |
Fin; |
| 3026 |
endfig; |
| 3027 |
\end{ExempleMP} |
| 3028 |
|
| 3029 |
Pour représenter une courbe plane définie par une fonction décrivant les |
| 3030 |
coordonées polaires en fonction d'un paramètre, on utilisera la macro suivante: |
| 3031 |
\begin{colourband} |
| 3032 |
\macro|CourbeEnPolaires(«fonction»)(«ti»,«tf»,«n»)|\return{\typeMP{path}} |
| 3033 |
\begin{description} |
| 3034 |
\item[\meta{fonction}:] est une macro \MP{} qui définit la fonction |
| 3035 |
mathématique d'une variable réelle décrivant l'évolution des coordonnées polaires des |
| 3036 |
points de la courbe que l'on souhaite représenter ; |
| 3037 |
\item[\meta{ti}:] est la valeur (\typeMP{numeric}) initiale de la variable à |
| 3038 |
partir de laquelle on souhaite construire la représentation de la fonction ; |
| 3039 |
\item[\meta{tf}:] est la valeur (\typeMP{numeric}) finale de la variable |
| 3040 |
jusqu'à laquelle on souhaite construire la représentation de la fonction ; |
| 3041 |
\item[\meta{n}:] est le nombre de pas (\typeMP{numeric}) utilisé pour la |
| 3042 |
discrétisation de la représentation. |
| 3043 |
\end{description} |
| 3044 |
\index{CourbeEnPolaires@\lstinline+CourbeEnPolaires+} |
| 3045 |
\end{colourband} |
| 3046 |
|
| 3047 |
\begin{ExempleMP} |
| 3048 |
input geom2d; |
| 3049 |
a := 2; |
| 3050 |
vardef cardioide(expr t)= a*(1+cos(t)) enddef; |
| 3051 |
beginfig(1); |
| 3052 |
RepereMinMax(-1.1,4.1,-2.8,2.8,1,1); |
| 3053 |
Axes; |
| 3054 |
Debut; |
| 3055 |
Graduations; |
| 3056 |
trace CourbeEnPolaires(cardioide,0,2Pi,100); |
| 3057 |
Fin; |
| 3058 |
endfig; |
| 3059 |
\end{ExempleMP} |
| 3060 |
|
| 3061 |
|
| 3062 |
\subsection{Champs de vecteurs} |
| 3063 |
|
| 3064 |
\mpgeomdd fournit des macros pour la représentation des champs de vecteurs. |
| 3065 |
|
| 3066 |
Tout d'abord, on peut tracer des champs de vecteurs associés à une équation |
| 3067 |
différentielle du premier ordre pour une fonction $y$ de la variable $x$: |
| 3068 |
\[y'=F(x,y).\] |
| 3069 |
La macro associée est la suivante: |
| 3070 |
\begin{colourband} |
| 3071 |
\macro|ChampVecteurs(«fonction»)(«x»,«y»,«px»,«py»,«dx»,«couleur»)|\return{\typeMP{path}} |
| 3072 |
\begin{description} |
| 3073 |
\item[\meta{fonction}:] est une macro \MP{} qui définit une fonction |
| 3074 |
mathématique de $\R^2$ dans $\R$ ; |
| 3075 |
\item[\meta{x}:] est une valeur (\typeMP{numeric}), en unité \variableGDD{gddU}, qui permet de décaler la |
| 3076 |
grille des vecteurs suivant la direction $x$, les points étant tous les |
| 3077 |
\meta{x}$+i$\meta{px} pour $i$ entier ; |
| 3078 |
\item[\meta{y}:] est une valeur (\typeMP{numeric}), en unité \variableGDD{gddU}, qui permet de décaler la |
| 3079 |
grille des vecteurs suivant la direction $y$, les points étant tous les |
| 3080 |
\meta{y}$+i$\meta{py} pour $i$ entier ; |
| 3081 |
\item[\meta{px}:] est la valeur (\typeMP{numeric}), en unité |
| 3082 |
\variableGDD{gddU}, du pas de la grille suivant l'axe $x$ pour |
| 3083 |
la représentation des vecteurs ; |
| 3084 |
\item[\meta{py}:] est la valeur (\typeMP{numeric}), en unité |
| 3085 |
\variableGDD{gddU}, du pas de la grille suivant l'axe $y$ pour |
| 3086 |
la représentation des vecteurs ; |
| 3087 |
\item[\meta{dx}:] est la norme (\typeMP{numeric}), en unité |
| 3088 |
\variableGDD{gddU}, des vecteurs du champ de vecteur ; |
| 3089 |
\item[\meta{couleur}:] est la couleur (\typeMP{color}) utilisée pour tracer |
| 3090 |
les vecteurs. |
| 3091 |
\end{description} |
| 3092 |
\index{ChampVecteurs@\lstinline+ChampVecteurs+} |
| 3093 |
\end{colourband} |
| 3094 |
|
| 3095 |
Comme cette macro utilise la macro \lstinline+drawarrow+ de \MP{}, il faudra |
| 3096 |
jouer avec le paramètre \lstinline+ahlength+ pour régler la taille du triangle |
| 3097 |
des flèches (voir~\cite{ctan-metapost}). |
| 3098 |
|
| 3099 |
\begin{ExempleMP} |
| 3100 |
input geom2d; |
| 3101 |
vardef F(expr x,y) = x - 2 * x * y enddef; |
| 3102 |
vardef f(expr x) = 1/2 + a * exp(- x*x) enddef; |
| 3103 |
beginfig(1); |
| 3104 |
RepereMinMax(-2.5,2.5,-2.8,2.8,1,1); |
| 3105 |
Axes; |
| 3106 |
Debut; |
| 3107 |
Graduations; |
| 3108 |
ahlength := 1; |
| 3109 |
ChampVecteurs(F,0,0,0.2,0.2,0.1,0.5white); |
| 3110 |
% Courbes intégrales |
| 3111 |
for n = 0 upto 16: |
| 3112 |
a := (n/2) - 4; |
| 3113 |
trace Representation(f,-2.5,2.5,50) |
| 3114 |
avecCrayon(1,(0.7,0.2,0.2)); |
| 3115 |
endfor |
| 3116 |
Fin; |
| 3117 |
endfig; |
| 3118 |
\end{ExempleMP} |
| 3119 |
|
| 3120 |
Sur le même modèle, on peut tracer des champs de vecteurs d'une fonction de |
| 3121 |
$\R^2$ dans $\R^2$. |
| 3122 |
La macro associée est la suivante: |
| 3123 |
\begin{colourband} |
| 3124 |
\macro|ChampVecteursDD(«fonction»)(«x»,«y»,«px»,«py»,«dx»,«couleur»)|\return{\typeMP{path}} |
| 3125 |
\begin{description} |
| 3126 |
\item[\meta{fonction}:] est une macro \MP{} qui définit une fonction |
| 3127 |
mathématique de $\R^2$ dans $\R^2$ (donc qui retourne une \typeMP{pair}) ; |
| 3128 |
\item[\meta{x}:] est une valeur (\typeMP{numeric}), en unité \variableGDD{gddU}, qui permet de décaler la |
| 3129 |
grille des vecteurs suivant la direction $x$, les points étant tous les |
| 3130 |
\meta{x}$+i$\meta{px} pour $i$ entier ; |
| 3131 |
\item[\meta{y}:] est une valeur (\typeMP{numeric}), en unité \variableGDD{gddU}, qui permet de décaler la |
| 3132 |
grille des vecteurs suivant la direction $y$, les points étant tous les |
| 3133 |
\meta{y}$+i$\meta{py} pour $i$ entier ; |
| 3134 |
\item[\meta{px}:] est la valeur (\typeMP{numeric}), en unité |
| 3135 |
\variableGDD{gddU}, du pas de la grille suivant l'axe $x$ pour |
| 3136 |
la représentation des vecteurs ; |
| 3137 |
\item[\meta{py}:] est la valeur (\typeMP{numeric}), en unité |
| 3138 |
\variableGDD{gddU}, du pas de la grille suivant l'axe $y$ pour |
| 3139 |
la représentation des vecteurs ; |
| 3140 |
\item[\meta{dx}:] est la norme (\typeMP{numeric}), en unité |
| 3141 |
\variableGDD{gddU}, des vecteurs du champ de vecteur ; |
| 3142 |
\item[\meta{couleur}:] est la couleur (\typeMP{color}) utilisée pour tracer |
| 3143 |
les vecteurs. |
| 3144 |
\end{description} |
| 3145 |
\index{ChampVecteursDD@\lstinline+ChampVecteursDD+} |
| 3146 |
\end{colourband} |
| 3147 |
|
| 3148 |
\begin{ExempleMP}[sidebyside=false] |
| 3149 |
input geom2d; |
| 3150 |
gddXlabel := "$\theta$"; |
| 3151 |
gddYlabel := "$\dot\theta$"; |
| 3152 |
numeric b,c; |
| 3153 |
b:=0.5; |
| 3154 |
c=1.0; |
| 3155 |
|
| 3156 |
vardef F(expr x,y) = (y,-b*y-c*sin(x)) enddef; |
| 3157 |
|
| 3158 |
beginfig(1); |
| 3159 |
Repere(10,6,2,4,2,2); |
| 3160 |
Axes; |
| 3161 |
Unites(1); |
| 3162 |
Debut; |
| 3163 |
Graduations; |
| 3164 |
trajectoire := CourbeDat("solution0",0); |
| 3165 |
ChampVecteursDD(F,0.5,0.5,0.2,0.2,0.15,0.5white); |
| 3166 |
trace trajectoire avecCrayon(1,(0.7,0.2,0.2)); |
| 3167 |
pointe Point(0,0) avecCrayon(1,(0.7,0.2,0.2)); |
| 3168 |
pointe Point(3.1415,0) avecCrayon(1,(0.7,0.2,0.2)); |
| 3169 |
Fin; |
| 3170 |
endfig; |
| 3171 |
\end{ExempleMP} |
| 3172 |
|
| 3173 |
|
| 3174 |
|
| 3175 |
|
| 3176 |
\section{Couleurs \texttt{svgnames}} |
| 3177 |
|
| 3178 |
\begin{mplibcode} |
| 3179 |
input exemples/svgnames/palette.mp |
| 3180 |
\end{mplibcode} |
| 3181 |
|
| 3182 |
|
| 3183 |
|
| 3184 |
\pagestyle{empty} |
| 3185 |
\begin{landscape} |
| 3186 |
\section{Galerie} |
| 3187 |
\subsection{Repère et tangentes extérieures} |
| 3188 |
\begin{minipage}{0.5\linewidth} |
| 3189 |
\begin{center} |
| 3190 |
\begin{mplibcode} |
| 3191 |
input exemples/cercles/cercles2.mp; |
| 3192 |
\end{mplibcode} |
| 3193 |
\end{center} |
| 3194 |
\end{minipage} |
| 3195 |
\begin{minipage}{0.5\linewidth} |
| 3196 |
\lstinputlisting[basicstyle=\ttfamily\small]{exemples/cercles/cercles2.mp} |
| 3197 |
\end{minipage} |
| 3198 |
\end{landscape} |
| 3199 |
|
| 3200 |
\begin{landscape} |
| 3201 |
\subsection{Vecteur dans un repère} |
| 3202 |
|
| 3203 |
\begin{multicols}{2} |
| 3204 |
\begin{center} |
| 3205 |
\begin{mplibcode} |
| 3206 |
input exemples/reperes/reperes2.mp; |
| 3207 |
\end{mplibcode} |
| 3208 |
\end{center} |
| 3209 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/reperes/reperes2.mp} |
| 3210 |
\end{multicols} |
| 3211 |
\end{landscape} |
| 3212 |
|
| 3213 |
\begin{landscape} |
| 3214 |
\subsection{Théorème de Pascal} |
| 3215 |
|
| 3216 |
\begin{multicols}{2} |
| 3217 |
\begin{center} |
| 3218 |
\begin{mplibcode} |
| 3219 |
input exemples/divers/pascalline.mp; |
| 3220 |
\end{mplibcode} |
| 3221 |
\end{center} |
| 3222 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/divers/pascalline.mp} |
| 3223 |
\end{multicols} |
| 3224 |
\end{landscape} |
| 3225 |
|
| 3226 |
\begin{landscape} |
| 3227 |
\subsection{Hyperbole} |
| 3228 |
|
| 3229 |
\begin{multicols}{2} |
| 3230 |
\begin{center} |
| 3231 |
\begin{mplibcode} |
| 3232 |
input exemples/coniques/hyper.mp; |
| 3233 |
\end{mplibcode} |
| 3234 |
\end{center} |
| 3235 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/coniques/hyper.mp} |
| 3236 |
\end{multicols} |
| 3237 |
\end{landscape} |
| 3238 |
|
| 3239 |
\begin{landscape} |
| 3240 |
\subsection{Astroïde comme enveloppe de droites} |
| 3241 |
|
| 3242 |
\begin{multicols}{2} |
| 3243 |
\begin{center} |
| 3244 |
\begin{mplibcode} |
| 3245 |
input exemples/courbes/cp01.mp; |
| 3246 |
\end{mplibcode} |
| 3247 |
\end{center} |
| 3248 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/courbes/cp01.mp} |
| 3249 |
\end{multicols} |
| 3250 |
\end{landscape} |
| 3251 |
|
| 3252 |
|
| 3253 |
\begin{landscape} |
| 3254 |
\subsection{Courbe de Lissajous} |
| 3255 |
|
| 3256 |
\begin{multicols}{2} |
| 3257 |
\begin{center} |
| 3258 |
\begin{mplibcode} |
| 3259 |
input exemples/courbes/cp02.mp; |
| 3260 |
\end{mplibcode} |
| 3261 |
\end{center} |
| 3262 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/courbes/cp02.mp} |
| 3263 |
\end{multicols} |
| 3264 |
\end{landscape} |
| 3265 |
|
| 3266 |
\begin{landscape} |
| 3267 |
\subsection{Étude de fonctions} |
| 3268 |
|
| 3269 |
\begin{multicols}{2} |
| 3270 |
\begin{center} |
| 3271 |
\begin{mplibcode} |
| 3272 |
input exemples/courbes/cp05.mp; |
| 3273 |
\end{mplibcode} |
| 3274 |
\end{center} |
| 3275 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/courbes/cp05.mp} |
| 3276 |
\end{multicols} |
| 3277 |
\end{landscape} |
| 3278 |
|
| 3279 |
\begin{landscape} |
| 3280 |
\subsection{Le bicorne} |
| 3281 |
|
| 3282 |
\begin{multicols}{2} |
| 3283 |
\begin{center} |
| 3284 |
\begin{mplibcode} |
| 3285 |
input exemples/courbes/cp08.mp; |
| 3286 |
\end{mplibcode} |
| 3287 |
\end{center} |
| 3288 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/courbes/cp08.mp} |
| 3289 |
\end{multicols} |
| 3290 |
\end{landscape} |
| 3291 |
|
| 3292 |
\begin{landscape} |
| 3293 |
\subsection{Une fonction et ses dérivées} |
| 3294 |
|
| 3295 |
\begin{multicols}{2} |
| 3296 |
\begin{center} |
| 3297 |
\begin{mplibcode} |
| 3298 |
input exemples/fonctions/fonction2.mp; |
| 3299 |
\end{mplibcode} |
| 3300 |
\end{center} |
| 3301 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/fonctions/fonction2.mp} |
| 3302 |
\end{multicols} |
| 3303 |
\end{landscape} |
| 3304 |
|
| 3305 |
\begin{landscape} |
| 3306 |
\subsection{Cardioïde} |
| 3307 |
|
| 3308 |
\begin{multicols}{2} |
| 3309 |
\begin{center} |
| 3310 |
\begin{mplibcode} |
| 3311 |
input exemples/polaires/pol02.mp; |
| 3312 |
\end{mplibcode} |
| 3313 |
\end{center} |
| 3314 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/polaires/pol02.mp} |
| 3315 |
\end{multicols} |
| 3316 |
\end{landscape} |
| 3317 |
|
| 3318 |
\begin{landscape} |
| 3319 |
\subsection{Axe de similitude} |
| 3320 |
\begin{center} |
| 3321 |
\begin{mplibcode} |
| 3322 |
input exemples/cercles/axessimilitude.mp; |
| 3323 |
\end{mplibcode} |
| 3324 |
\end{center} |
| 3325 |
\begin{multicols}{2} |
| 3326 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/cercles/axessimilitude.mp} |
| 3327 |
\end{multicols} |
| 3328 |
\end{landscape} |
| 3329 |
|
| 3330 |
|
| 3331 |
\begin{landscape} |
| 3332 |
\subsection{Tracé d'une cubique} |
| 3333 |
\begin{multicols}{2} |
| 3334 |
\begin{center} |
| 3335 |
\begin{mplibcode} |
| 3336 |
input exemples/cubiques/K001.mp; |
| 3337 |
\end{mplibcode} |
| 3338 |
\end{center} |
| 3339 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/cubiques/K001.mp} |
| 3340 |
\end{multicols} |
| 3341 |
\end{landscape} |
| 3342 |
|
| 3343 |
\begin{landscape} |
| 3344 |
\subsection{Apollonius} |
| 3345 |
|
| 3346 |
\begin{multicols}{2} |
| 3347 |
\begin{center} |
| 3348 |
\begin{mplibcode} |
| 3349 |
input exemples/triangles/apollonius.mp; |
| 3350 |
\end{mplibcode} |
| 3351 |
\end{center} |
| 3352 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/triangles/apollonius.mp} |
| 3353 |
\end{multicols} |
| 3354 |
\end{landscape} |
| 3355 |
|
| 3356 |
\begin{landscape} |
| 3357 |
\subsection{Épure d'ogive} |
| 3358 |
|
| 3359 |
\begin{multicols}{2} |
| 3360 |
\begin{center} |
| 3361 |
\begin{mplibcode} |
| 3362 |
input exemples/construction/ogiveentiers.mp; |
| 3363 |
\end{mplibcode} |
| 3364 |
\end{center} |
| 3365 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/construction/ogiveentiers.mp} |
| 3366 |
\end{multicols} |
| 3367 |
\end{landscape} |
| 3368 |
|
| 3369 |
\begin{landscape} |
| 3370 |
\subsection{Triangle orthique et problème de Fagnano} |
| 3371 |
|
| 3372 |
Figure 21 de~\cite{toeplitz}. |
| 3373 |
\begin{center} |
| 3374 |
\begin{mplibcode} |
| 3375 |
input exemples/triangles/pedale.mp; |
| 3376 |
\end{mplibcode} |
| 3377 |
\end{center} |
| 3378 |
\begin{multicols}{2} |
| 3379 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/triangles/pedale.mp} |
| 3380 |
\end{multicols} |
| 3381 |
\end{landscape} |
| 3382 |
\newpage |
| 3383 |
|
| 3384 |
\begin{landscape} |
| 3385 |
\subsection{Chaîne de Pappus} |
| 3386 |
|
| 3387 |
La chaîne de Pappus par inversion géométrique. |
| 3388 |
\begin{multicols}{2} |
| 3389 |
\begin{mplibcode} |
| 3390 |
input exemples/cercles/pappuschain.mp; |
| 3391 |
\end{mplibcode} |
| 3392 |
|
| 3393 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/cercles/pappuschain.mp} |
| 3394 |
\end{multicols} |
| 3395 |
\end{landscape} |
| 3396 |
\newpage |
| 3397 |
|
| 3398 |
\begin{landscape} |
| 3399 |
\subsection{L’arbre de Pythagore par similitude} |
| 3400 |
|
| 3401 |
La construction de l’arbre de Pythagore par similitude. Ce code est inspiré de |
| 3402 |
la construction proposée par MicMath sur sa chaîne Twitch. |
| 3403 |
\begin{multicols}{2} |
| 3404 |
\begin{mplibcode} |
| 3405 |
input exemples/transformations/arbrePythagore.mp; |
| 3406 |
\end{mplibcode} |
| 3407 |
|
| 3408 |
\lstinputlisting[basicstyle=\ttfamily\scriptsize]{exemples/transformations/arbrePythagore.mp} |
| 3409 |
\end{multicols} |
| 3410 |
\end{landscape} |
| 3411 |
|
| 3412 |
|
| 3413 |
\newpage |
| 3414 |
\section{Historique} |
| 3415 |
\begin{description} |
| 3416 |
\item[decembre 2025:] Ajout de la macro \lstinline+FinFenetre+, ajout des |
| 3417 |
macros de similitude à centre \lstinline+SimilitudeACentre+, ajout de |
| 3418 |
l’exemple \og{}Arbre de Pythagore\fg{}, correction de |
| 3419 |
bugs, et amélioration de la documentation. Utilisation de \lstinline+withtransparency+ |
| 3420 |
pour la commande \lstinline+colorieAvecTransparence+ quand \mpgeomdd est |
| 3421 |
utilisé avec \hologo{LuaTeX} et \package{luamplib}. Version 1.4. |
| 3422 |
\item[mai 2025:] Ajout de la macro \lstinline+pointes+ pour le pointage d’une |
| 3423 |
liste de points. Ajout des macros \lstinline+ParametrePointTaille+, |
| 3424 |
\lstinline+ParametrePointCouleur+, \lstinline+ParametrePointeType+ et |
| 3425 |
\lstinline+ParametreConiqueCoef+ pour modifier les valeurs des variables |
| 3426 |
globales. Ajout de la commande \lstinline|gddClip|. Traduction des macros, de |
| 3427 |
la documentation et des exemples en anglais. |
| 3428 |
\item[25 février 2025:] ajout de la macro \lstinline|PointIntersection|. Ajout |
| 3429 |
de la macro \lstinline+HyperboleF+. Quelques bugs, et amélioration de la |
| 3430 |
documentation. |
| 3431 |
\item[février 2025:] ajout de la macro \lstinline+hachure+ ainsi que la macro |
| 3432 |
\lstinline+SchemaHachure+. Correction d’un bug dans la macro |
| 3433 |
\lstinline+EllipseFD+. Version 1.2. |
| 3434 |
\item[décembre 2024:] ajout de la macro \lstinline+DroiteParallele+. |
| 3435 |
\item[novembre 2024:] ajout de la macro \lstinline+EllipseFD+ ainsi que le |
| 3436 |
stockage des directrices dans le type \typeGDD{ellipse}. Correction de la |
| 3437 |
commande \lstinline+gddLabel+. Ajout de l’exemple de la chaîne de Pappus. |
| 3438 |
\item[21 octobre 2024:] corrections de Quark67 (merci à lui) sur la |
| 3439 |
documentation et modifications suite à ses remarques. |
| 3440 |
\lstinline+DemieHyperbole+ devient |
| 3441 |
\lstinline+DemiHyperbole+ (sans compatibilité). Création de deux nouveaux |
| 3442 |
types |
| 3443 |
de pointage de \typeGDD{point} : croix et disque (voir commande \lstinline+pointe+). |
| 3444 |
\item[13 octobre 2024:] publication de la version 1.0 sur le CTAN. |
| 3445 |
\end{description} |
| 3446 |
|
| 3447 |
\printbibliography |
| 3448 |
\addcontentsline{toc}{section}{Références}%Including it as a chapter |
| 3449 |
\printindex |
| 3450 |
\addcontentsline{toc}{section}{Index}%Including it as a chapter |
| 3451 |
|
| 3452 |
|
| 3453 |
\end{document} |