Retour

Source de manuel_geoplan.tex

Fichier TeX
\documentclass[a4paper,10pt]{article}

% Use this form to include eps (latex) or pdf (pdflatex) files:
\usepackage{asymptote}
\usepackage[utf8]{inputenc}
\usepackage[francais]{babel}
\usepackage[T1]{fontenc}
\usepackage{eurosym}
\usepackage{pstricks}
\usepackage{graphicx}
\usepackage{multicol}
\usepackage{frcursive}
\usepackage{lmodern} 
\usepackage[margin=2.5cm]{geometry}
% \usepackage{fichexo} %package personnel
\usepackage{amsfonts,amssymb,amsmath,amsthm}
\usepackage{mathrsfs}
\usepackage{fancyhdr}
\usepackage{lastpage}
\usepackage{calc}
\usepackage{stmaryrd}
\usepackage{picins}

\newcommand{\asym}{ \texttt{Asymptote} }
\newcommand{\com}{$\blacktriangleright$}
\newcommand{\comm}[1]{$\blacktriangleright$ \texttt{#1} }
% Use this form with latex or pdflatex to include inline LaTeX code:
%\usepackage[inline]{asymptote}

% Enable this line to produce pdf hyperlinks with latex:
%\usepackage[hypertex]{hyperref}

% Enable this line to produce pdf hyperlinks with pdflatex:
%\usepackage[pdftex]{hyperref}
\title{Macros de géométrie  plane avec \asym}
\author{D. Comin}
\let\ang\widehat
\begin{document}
\maketitle

\tableofcontents
\newpage
\begin{asydef}
// Global Asymptote définitions can be put here.
usepackage("bm");
usepackage("eurosym");
usepackage("stmaryrd");
usepackage("babel","french");
usepackage("mathrsfs");
defaultpen(fontsize(10));
\end{asydef}

\def\A{A}
\def\B{\bm{B}}
\section{Les constantes.}
\subsection{Les dimensions.}
Par défaut, l'unité est le cm, ce qui est cohérent pour faire de la géométrie plane. L'usage de la commande \verb+size+ perturbe les unités et la figure tracée n'est plus en vraie grandeur ...

 La figure est plus ou moins contenue dans un chemin fermé appelé \verb+cadre+ dont les coordonnées des sommets sont récupérables par les quatre <<pairs>> suivants :  \verb+hautgauche, hautdroit, basgauche, basdroit+. 

La commande \comm{figure(pair basgauche,pair hautdroit)} permet de fixer le cadre. Il n'est, par défaut, pas tracé.

\noindent\begin{minipage}{8cm}
\begin{verbatim}
import geoplane;
 figure((0,0),(5,3),black+dashed);
\\voir plus bas pour la macro nomme
nomme("hautgauche",hautgauche,nord);
nomme("hautdroit",hautdroit,nord);
nomme("basdroit",basdroit,sud);
nomme("basgauche",basgauche,sud);
\end{verbatim} 
\end{minipage}
\begin{minipage}{6cm}
 \begin{asy}
import geoplane;
figure((0,0),(5,3),black+dashed);
nomme("hautgauche",hautgauche,nord);
nomme("hautdroit",hautdroit,nord);
nomme("basdroit",basdroit,sud);
nomme("basgauche",basgauche,sud);
\end{asy}
\end{minipage}

La constante \verb|croix| définit la taille des points tracés à l'écran, les dimensions de la croix en fait.

\subsection{Les directions}
\asym connaît les huit principaux points cardinaux comme variables de type <<pair>>: N pour le nord, S pour le sud,etc. Ces directions sont pratiques pour nommés les points mais interdisent d'utiliser certaines lettres : N,S,W,E...Ces directions sont renommées comme suit.

\noindent\begin{minipage}{8cm}
 \begin{verbatim}
 import geoplane;
figure((-2,-2),(2,2));
draw((0,0)--nord,Arrow);
label("nord",nord,nord);
draw((0,0)--sud,Arrow);
label("sud",sud,sud);
draw((0,0)--est,Arrow);
label("est",est,est);
draw((0,0)--ouest,Arrow);
label("ouest",ouest,ouest);
draw((0,0)--nest,Arrow);
label("nest",nest,nest);
draw((0,0)--sest,Arrow);
label("sest",sest,sest);
draw((0,0)--nouest,Arrow);
label("nouest",nouest,nouest);
draw((0,0)--souest,Arrow);
label("souest",souest,souest);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-2,-2),(2,2));
draw((0,0)--nord,Arrow);
label("nord",nord,nord);
draw((0,0)--sud,Arrow);
label("sud",sud,sud);
draw((0,0)--est,Arrow);
label("est",est,est);
draw((0,0)--ouest,Arrow);
label("ouest",ouest,ouest);
draw((0,0)--nest,Arrow);
label("nest",nest,nest);
draw((0,0)--sest,Arrow);
label("sest",sest,sest);
draw((0,0)--nouest,Arrow);
label("nouest",nouest,nouest);
draw((0,0)--souest,Arrow);
label("souest",souest,souest);
\end{asy}
\end{minipage}

\subsection{Le tracé à <<main levée>>}

Il  suffit de mettre la constante \texttt{mainlevee} de type \texttt{bool} à la valeur \texttt{true} pour avoir un dessin qui ressemble à un croquis à main levée.

\begin{verbatim}
import geoplane;
//dessin à main levée
mainlevee=true;
pair A=(0,0);
path tt=rectangle(A,7,5,angle=-15);
draw(tt);
nomme("$A$",sommet(tt,0),sud);
nomme("$B$",sommet(tt,1),sud);
nomme("$C$",sommet(tt,2),nord);
nomme("$D$",sommet(tt,3),nord);
draw(segment(sommet(tt,0),sommet(tt,2)));
etiquette(sommet(tt,0),sommet(tt,2),"8,6 cm");
etiquette(sommet(tt,0),sommet(tt,3),"5 cm");
etiquette(sommet(tt,0),sommet(tt,1),"7 cm",dessus=false);
angledroit(sommet(tt,0),sommet(tt,1),sommet(tt,2));
\end{verbatim}


\begin{asy}
import geoplane;
//dessin à main levée
mainlevee=true;
pair A=(0,0);
path tt=rectangle(A,7,5,angle=-15);
draw(tt);
nomme("$A$",sommet(tt,0),sud);
nomme("$B$",sommet(tt,1),sud);
nomme("$C$",sommet(tt,2),nord);
nomme("$D$",sommet(tt,3),nord);
draw(segment(sommet(tt,0),sommet(tt,2)));
etiquette(sommet(tt,0),sommet(tt,2),"8,6 cm");
etiquette(sommet(tt,0),sommet(tt,3),"5 cm");
etiquette(sommet(tt,0),sommet(tt,1),"7 cm",dessus=false);
angledroit(sommet(tt,0),sommet(tt,1),sommet(tt,2));
\end{asy}



\section{Les points}
\subsection{Tracé}

\comm{pointe(pair A,pen p=currentpen)} trace une croix en A sans nommer le point.

\comm{nomme(Label L, pair position,pen p=currentpen)} trace le point sur le pair <<position>> et place le texte contenu dans le <<label>> L.

\noindent\begin{minipage}{8cm}
 \begin{verbatim}
import geoplane;
figure((-2,-2),(2,2));
pair A,B,C;
A=(-1.5,1.5);
B=(-1,0);
C=(1,1.5);
pointe(A);
nomme("et hop",B,est,blue);
nomme("$C$",C,sud);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-2,-2),(2,2));
pair A,B,C;
A=(-1.5,1.5);
B=(-1,0);
C=(1,1.5);
pointe(A);
nomme("et hop",B,est,blue);
nomme("$C$",C,sud);
\end{asy}
\end{minipage}

On notera la présence des directions est,sud,... qui permettent de placer l'étiquette de texte: "et hop" est à l'est de la position B. 
\subsection{Construction}

\comm{pointdistant(pair A,real distance, real angle)} crée un <<pair>> situé à une certaine distance de A, (AB) faisant un angle donné avec l'horizontale. 

\comm{point\_angle\_dist(pair A, pair B, real angle, real distance)} renvoie M un point à \textit{distance} de A et tel que $\ang{MAB}=angle \degres$

\noindent\begin{minipage}{8cm}
 \begin{verbatim}
import geoplane;
figure((-1,-1),(5,5));
pair A,B;
A=(0,0);
B=pointdistant(A,5,30);
nomme("$A$",A,sud);
nomme("$B$ est \`a 5 cm de $A$",B,nord);
draw(A--B);
\end{verbatim}
\end{minipage}
\begin{minipage}{6cm}
\begin{asy}
import geoplane;
figure((-1,-1),(5,5));
pair A,B;
A=(0,0);
B=pointdistant(A,5,30);
nomme("$A$",A,sud);
nomme("$B$ est \`a 5 cm de $A$",B,nord);
draw(A--B);
\end{asy}
\end{minipage}

\comm{compas(pair A,pair B, real a, real b)} crée un <<pair>> situé à distances données de A et B.

\noindent\begin{minipage}{9cm}
 \begin{verbatim}
import geoplane;
figure((-1,-1),(5,5));
pair A,B,C;
A=(0,0);
B=pointdistant(A,5,10);
C=compas(A,B,3,5);
nomme("$A$",A,sud);
nomme("$B$",B,est);
nomme("$C$",C,nord);
draw(A--B--C--cycle);
label("un joli triangle isoc\`ele",(A+B+C)/3,sud);
 \end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-1,-1),(5,5));
pair A,B,C;
A=(0,0);
B=pointdistant(A,5,10);
C=compas(A,B,3,5);
nomme("$A$",A,sud);
nomme("$B$",B,est);
nomme("$C$",C,nord);
draw(A--B--C--cycle);
label("un joli triangle isoc\`ele",(A+B+C)/3,sud);
\end{asy}
\end{minipage}

\comm{milieu(pair A, pair B)},bon là, ça va aller.

\comm{pointsur(path chemin, real r)} renvoie un <<pair>> situé sur la chemin en fonction de $r\in[0..1]$: 0 correspond à l'origine et 1 à l'extrémité. 

\noindent\begin{minipage}{9cm}
 \begin{verbatim}
import geoplane;
figure((-0.5,-0.5),(4,5));
path c=(0,0)..(2,3)..(3,1)..(4,2);
draw(c,blue+dashed);
pointe(pointsur(c,0));
pointe(pointsur(c,0.2));
pointe(pointsur(c,0.7));
pointe(pointsur(c,0),1);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-0.5,-0.5),(4,5));
path c=(0,0)..(2,3)..(3,1)..(4,2);
draw(c,blue+dashed);
pointe(pointsur(c,0));
pointe(pointsur(c,0.2));
pointe(pointsur(c,0.7));
pointe(pointsur(c,1));
\end{asy}
\end{minipage}

\subsection{Points particuliers}
\comm{orthocentre(pair C, pair A, pair B)} renvoie l'orthocentre du triangle ABC.

\comm{circonscrit(pair C, pair A, pair B)} renvoie le centre du cercle circonscrit à ABC.

\comm{projortho(pair M, pair A,pair B)} renvoie le projeté orthogonal de M sur (AB).

\comm{inscrit{pair A, pair B, pair C}} renvoie le centre du cercle inscrit dans ABC.

\noindent\begin{minipage}{9cm}
\begin{verbatim}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C,O,H,Ha;
A=(0,0);
B=(4,1);
C=(1,3);
draw(A--B--C--cycle);
nomme("$A$",A,sud);
nomme("$B$",B,sud);
nomme("$C$",C,nord);
H=orthocentre(A,B,C);
nomme("$H$",H,sud);
O=circonscrit(A,B,C);
nomme("$O$",O,sud);
Ha=projortho(A,B,C);
draw(Ha--A,dashed);
nomme("$H_A$",Ha,nest);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C,O,H,Ha;
A=(0,0);
B=(4,1);
C=(1,3);
draw(A--B--C--cycle);
nomme("$A$",A,sud);
nomme("$B$",B,sud);
nomme("$C$",C,nord);
H=orthocentre(A,B,C);
nomme("$H$",H,sud);
O=circonscrit(A,B,C);
nomme("$O$",O,sud);
Ha=projortho(A,B,C);
draw(Ha--A,dashed);
nomme("$H_A$",Ha,nest);
\end{asy}
\end{minipage}

\section{Mesure et codage}
\subsection{Cotation}
\comm{cotemilieu(pair A,pair B, string texte, real d,bool trait=false,pen sty=black)} trace une flèche de A à B à d mm au dessus de (AB), le texte est au milieu.

\comm{cote(pair A,pair B, string texte, real d,bool trait=false,pen sty=black)} trace une flèche de A à B à d mm au dessus de (AB), le texte est au dessus.

\comm{etiquette(pair A, pair B, string txt,bool dessus=true,pen sty=currentpen)} place le texte txt le long de [AB].

\comm{hachurage(path p,real  espace, real angle, pen pen=currentpen)} remplit avec des hachures espacées de "espace" mm, avec un angle de "angle" \degre le chemin fermé p.

\noindent\begin{minipage}{9cm}
\begin{verbatim}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C;
A=(0,0);
B=(0,4);
C=(3,4);
draw(A--B--C--cycle);
cote(A,B,"4 cm",4,trait=true);
cotemilieu(A,C,"5 cm",-2,trait=true);
hachurage(A--B--C--cycle,2mm,20);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C;
A=(0,0);
B=(0,4);
C=(3,4);
draw(A--B--C--cycle);
cote(A,B,"4 cm",4,trait=true);
cotemilieu(A,C,"5 cm",-4,trait=true);
hachurage(A--B--C--cycle,2mm,20);
\end{asy}
\end{minipage}

\subsection{Codage des longeurs et des angles}
\comm{code(pen sty=invisible,int trait ...pair[] K)} code une série de segments dont les extrémités sont contenues dans une matrice de type <<pair[]>> mais il suffit d'ecrire \texttt{code(2,A,B,B,C,D,E)} pour coder les segments $[AB]$, $[BC]$ et $[DE]$ de deux traits. Le paramètre "trait" précise le codage :
\begin{description}
 \item[Si "trait" vaut 1, 2 ou 3] le segment est codé par des traits ...
\item[Si "trait" vaut 4] le segment est codé par un tilde.
\item[Si "trait" vaut 5] le segment est codé par un cercle.
 \end{description}

\comm{codemilieu(pair A, pair B, int trait)} est similaire à
\verb+code+ mais plus simple syntaxiquement. 

\comm{codeangle(pair A,pair B, pair C, int trait,int nbarc=1)} marque
l'angle $\ang{ABC}$ par des traits et un ou plusieurs arcs de cercle. 

\comm{angledroit(pair A,pair B,pair C,real taille=3mm, pen
p=black)}\begin{small}\begin{footnotesize}                                                                                
\end{footnotesize}                                                                   
\end{small} code l'angle $\ang{ABC}$, supposé droit.

\noindent\begin{minipage}{9cm}
\begin{verbatim}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C,D,I;
A=(0,0);
B=pointdistant(A,4,10);
C=pointdistant(A,4,80);
D=compas(C,B,3,3);
I=extension(C,B,A,D);
draw(A--B--D--C--cycle);
nomme("$A$",A,souest);
nomme("$B$",B,souest);
nomme("$C$",C,souest);
nomme("$D$",D,nest);
nomme("$I$",I,nord);
code(2,C,A,A,B);
codemilieu(C,B,3);
draw(A--D,red);
draw(B--C,red);
codeangle(B,C,D,2);
codeangle(C,D,I,0,2);
angledroit(A,I,B,blue);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((-0.5,-0.5),(4,5));
pair A,B,C,D,I;
A=(0,0);
B=pointdistant(A,4,10);
C=pointdistant(A,4,80);
D=compas(C,B,3,3);
I=extension(C,B,A,D);
draw(A--B--D--C--cycle);
nomme("$A$",A,souest);
nomme("$B$",B,souest);
nomme("$C$",C,souest);
nomme("$D$",D,nest);
nomme("$I$",I,nord);
code(2,C,A,A,B);
codemilieu(C,B,3);
draw(A--D,red);
draw(B--C,red);
codeangle(B,C,D,2);
codeangle(C,D,I,0,2);
angledroit(A,I,B,blue);
\end{asy}
\end{minipage}

\section{Quadrillages}
\subsection{les papiers}
\comm{millimetre(pen sty=orange)} trace du papier millimétré dans les limites du \texttt{cadre}. La couleur par defaut est "orange".

\comm{carreau(real cote=0.5, pen sty=orange)} trace un quadrillage \mbox{5 mm $\times$ 5mm} par défaut.

\comm{seyes()} trace un morceau de cahier d'écolier.

\noindent\begin{minipage}{9cm}
\begin{verbatim}
import geoplane;
figure((0,0),(6,6));
seyes();
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((0,0),(6,6));
seyes();
\end{asy}
\end{minipage}

\subsection{les fractions}

Les commandes suivantes tracent des fractions à partir d'un quadrillage en coloriant un nombre $n$ de parts.

\comm{void fractionRect(int l,int h, int n=0, pen remplissage=grey, pen trait=currentpen)} trace un quadrillage rectangulaire. $l$ désigne la largeur et $h$ la hateur du quadrillage.

\comm{void fractionCercle(int l,int n=0, pen remplissage=grey, pen trait=currentpen)} trace des parts de camembert \footnote{ou tout autre fromage circulaire}. $l$ désigne le nombre total de parts. 

\comm{void fractionPoly(int l,int n=0, pen remplissage=grey, pen trait=currentpen)} trace un polygone régulier à $l$ côtés séparé en $l$ parts.

\noindent\begin{minipage}{6cm}
\begin{verbatim}
import geoplane;
figure((0,0),(3,3));
fractionPoly(3,1);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
figure((0,0),(3,3));
fractionPoly(3,1);
\end{asy}
\end{minipage}
\section{les objets de type \texttt{path}}
\subsection{triangle et quadrilatères}

Pour les triangles, la longueur $a$ est située en face du point $A$, $b$ et $c$ sont placés ensuite dans le sens trigonométrique.
L'angle $\ang{alpha}$ est l'angle en $A$, $\ang{beta}$ en $B$.

\comm{triangle3c(pair A, real a, real b, real c, bool dessus=true,real angle=0)} renvoie un path, le triangle dont les côtés sont a b et c en cm. 

\comm{triangle1c(pair A, real c, real alpha, real beta,bool dessus=true,real angle=0)} renvoie un path, le triangle de côté c en cm.et d'angles adjacents alpha et beta  

\comm{triangle2c(pair A, real c, real b, real alpha, bool dessus=true,real angle=0)} renvoie un path, le triangle de côtés adjacents c et b en cm.et formant un angle alpha.

\comm{rectangle(pair A, real a, real b,bool diagonale=false,real angle=0)} renvoie un path, le rectangle de côtés adjacents a et b en cm. Si diagonale=true, b est la diagonale.

\comm{parallelogramme(pair A, real a, real b, real alpha, bool diagonale=false,\\real angle=0)} renvoie un path, le parallelogramme de côtés adjacents a et b en cm formant un angle alpha. 

Si diagonale vaut true, alpha est la diagonale en cm.

\comm{pair sommet(path c,int n)} renvoie le sommet n du triangle ou quadrilatère. La numérotation commence à 0. 

\comm{path polygone(...pair[] K)} renvoie un polygone, utile pour tracer des triangles ou quadrilatères définis par des sommets dans le style <<à main levee>>. Il suffit pour cela de donner les sommets ; \texttt{path poly=polygone(A,B,C,D,E)}.

\vspace{5mm}

\noindent\begin{minipage}{8cm}
\begin{verbatim}
import geoplane;
pair A=(0,0);
path t=triangle1c(A,6,74,24);
draw(t);
pair B=sommet(t,1);
pair C=sommet(t,2);
label("$A$",A,sud);
label("$B$",B,sud);
label("$C$",C,nord);
codeangle(C,A,B,"$74 \degres$",0,sty=red);
codeangle(C,B,A,"$24 \degres$",trait=0,2,green);	
\end{verbatim}
\end{minipage}
\begin{minipage}{6.5cm}
\begin{asy}
import geoplane;
pair A=(0,0);
path t=triangle1c(A,6,74,24);
draw(t);
pair B=sommet(t,1);
pair C=sommet(t,2);
label("$A$",A,sud);
label("$B$",B,sud);
label("$C$",C,nord);
codeangle(C,A,B,"$74 \degres$",0,sty=red);
codeangle(C,B,A,"$24 \degres$",trait=0,2,green);
\end{asy}
\end{minipage}

\subsection{Droites et segments}

$\blacktriangleright$ La commande \verb+segment(pair A, pair B,real a=0)+ renvoie le chemin [AB] et permet de faire dépasser le trait de $a$ cm de part et d'autre des extrémités.

\comm{droite(pair A, pair B)} définit un <<path>> passant par A et B mais contenu dans le \verb+cadre+, le résultat est plus élégant -- à mon sens -- que \verb+drawline+.

\comm{demidroite(pair A, pair B)} renvoie, elle, la demi-droite $[AB)$

$\blacktriangleright$ La fonction \verb+perpendiculaire(pair A, pair B, pair M)+ 
(\emph{resp.} \verb+parallele+) retourne la droite perpendicualire (\emph{resp.} parallèle) à (AB) et passant par M.

On dispose aussi des fonctions suivantes qui renvoient toutes des droites :

\comm{hauteur(pair C, pair A, pair B)}: la hauteur issue de C de ABC.

\comm{mediatrice(pair A, pair B)}: la médiatrice de [AB]

\comm{bissectrice(pair A, pair B, pair C)}:la bissectrice de l'angle ABC.

\noindent\begin{minipage}{8cm}
\begin{verbatim}
import geoplane;
usepackage("mathrsfs");
figure((-1,-1),(6,5));
pair A,B,C,M,H;
A=(1,1);
B=(4,0);
C=(2,3);
draw(A--B--C--cycle);
nomme("$A$",A,ouest);
nomme("$B$",B,est);
nomme("$C$",C,nord);
path d=parallele(A,B,C);
draw(d,dashed);
M=pointsur(d,0.3);
nomme("$M$",M,nest);
path dd=perpendiculaire(C,M,M);
draw(dd,dashed+red);
label("$(\mathscr{D})$",1.7*(M-C)+C,nord);
draw(hauteur(A,C,B),blue);
draw(bissectrice(A,C,B),green);
H=projortho(A,C,B);
nomme("$H$",H,nord);
angledroit(A,H,B,blue);
\end{verbatim}
\end{minipage}
\begin{minipage}{6cm}
\begin{asy}
import geoplane;
usepackage("mathrsfs");
figure((-1,-1),(6,5));
pair A,B,C,M,H;
A=(1,1);
B=(4,0);
C=(2,3);
draw(A--B--C--cycle);
nomme("$A$",A,ouest);
nomme("$B$",B,est);
nomme("$C$",C,nord);
path d=parallele(A,B,C);
draw(d,dashed);
M=pointsur(d,0.3);
nomme("$M$",M,nest);
path dd=perpendiculaire(C,M,M);
draw(dd,dashed+red);
label("$(\mathscr{D})$",1.7*(M-C)+C,nord);
draw(hauteur(A,C,B),blue);
draw(bissectrice(A,C,B),green);
H=projortho(A,C,B);
nomme("$H$",H,nord);
angledroit(A,H,B,blue);
\end{asy}
\end{minipage}

\subsection{Les cercles}
Les cercles ne sont pas contenus dans le \verb+cadre+ (le moyen n'a pas été encore trouvé ...), ils peuvent en déborder.
La commande suivante permet de ne tracer qu'une partie de crecle.

\comm{arc(pair B, pair A, real s, real t)} renvoie un chemin qui est l'arc de centre B, passant par A et avec un angle autour de A, le 0 étant sur A.

\comm{cercle(pair O, pair A)} renvoie le cercle de centre O et de rayon A.

\comm{cercleR(pair O, real R)} définit le cercle de centre O et de rayon R.

\comm{cercleD(pair A, pair B)} donne le cercle de diamètre [AB].

\noindent\begin{minipage}{6cm}
\begin{verbatim}
import geoplane;
pair A,B,C;
figure((-1,-1),(5,5));
A=(3,0);
B=(4,1);
C=(2,4);
nomme("$A$",A,sest);
nomme("$B$",B,nest);
nomme("$C$",C,nouest);
pointe(circonscrit(A,B,C));
draw(cercle(circonscrit(A,B,C),A));
draw(A--B--C--cycle);
draw(cercleD(A,B),dashed+0.6*red);
draw(arc(C,B,-20,45),green*0.6+dashed);
\end{verbatim}
\end{minipage}
\begin{minipage}{5cm}
\begin{asy}
import geoplane;
pair A,B,C;
figure((-1,-1),(5,5));
A=(3,0);
B=(4,1);
C=(2,4);
nomme("$A$",A,sest);
nomme("$B$",B,nest);
nomme("$C$",C,nouest);
pointe(circonscrit(A,B,C));
draw(cercle(circonscrit(A,B,C),A));
draw(A--B--C--cycle);
draw(cercleD(A,B),dashed+0.6*red);
draw(arc(C,B,-20,35),green*0.6+dashed);
\end{asy}
\end{minipage}

\subsection{Nommer les \texttt{path}s}

La commande

\comm{nomchemin(string txt,path chemin, real pos=0.9, pair direction, pen p=currentpen)}\\
place à proximité d'un objet \texttt{path} son nom . Le texte est placé par défaut à le position 0,9 du chemin, au sens de la fonction \texttt{pointsur}.

\section{Repérage}

\subsection{Axes gradués}

\comm{void inequation(string txt="", real valeur, real crochet, real zone,\\pen pen=currentpen)} permet de tracer l'axe gradué, hachuré à partir de \texttt{valeur} dans la direction définie par \texttt{zone}:
\begin{description}
	\item[si \texttt{zone} = $-1$]; la partie vers les abscisses négatifs est hachurée.
	\item[si \texttt{zone} = $1$]; la partie vers les abscisses positifs est hachurée.
 \end{description}

\texttt{crochet} fonctionne de la même façon.

\begin{verbatim}
import geoplane;
figure((-5,-1),(5,1));
inequation("$\frac{2}{3}$",2/3,-1,1);
\end{verbatim}

\begin{asy}
import geoplane;
figure((-5,-1),(5,1));
inequation("$\frac{2}{3}$",2/3,-1,1);
\end{asy}

De maninière similaire au type \texttt{repere} (\ref{rep}), on définit le type \texttt{axe} \emph{ie} un point, un vecteur directeur de l'axe et les informations comme le nom de l'origine, etc.

\begin{verbatim}
struct axe {
pair origine ;
pair abscisse;
string originetxt="$O$" ;
string abscissetxt="1";
}
\end{verbatim}

L'axe par défaut est appelé \texttt{canonique} :
\begin{verbatim}
axe canonique;
canonique.origine=(0,0);
canonique.abscisse=(1,0);
canonique.originetxt="$O$";
canonique.abscissetxt="1";
\end{verbatim}

Par commodité, l'axe courant est contenu dans \texttt{axecourant}.

\comm{void graduation(axe grad=axecourant, real debut, real fin, real intermediaire=0,\\pen sty=currentpen)} trace un axe gradué, les valeurs \texttt{début} et \texttt{fin} sont exprimées en fonction du vecteur unité, \texttt{intermediaire} est une fraction du vecteur unité.

\comm{void abscisse(axe grad=axecourant, string txtdessous, string txtdessus="", real x, bool croix=true, pen sty=currentpen)} trace un point qui correspond à une abscisse particulière sur un axe

\begin{verbatim}
import geoplane;
figure((-5,-1),(5,1));
axe axe;
axe.origine=(0,0);
axe.abscisse=(0.8,0);
axecourant=axe;
graduation(-3.5,4.8,1/3);
abscisse("$-\frac{2}{3}$",-2/3,red*0.6);
\end{verbatim}

\begin{asy}
import geoplane;
figure((-5,-1),(5,1));
axe axe;
axe.origine=(0,0);
axe.abscisse=(0.8,0);
axecourant=axe;
graduation(-3.5,4.8,1/3);
abscisse("$-\frac{2}{3}$",-2/3,red*0.6);
\end{asy}

\subsection{Repères}

Le type \texttt{repere} \label{rep} contient les informations nécéssaires à un repère du plan :
\begin{verbatim}
struct repere {
pair origine ;
pair abscisse;
pair ordonnee;
string originetxt ;
string abscissetxt;
string ordonneetxt;
}	
\end{verbatim}

\begin{description}
	\item[\texttt{origine}] contient les coordonnées de l'origine.
	\item[\texttt{abscisse}] contient les coordonnées du vecteur de l'axe des abscisses.
	\item[\texttt{ordonnee}] contient les coordonnées du vecteur de l'axe des ordonnées.
	\item[\texttt{originetxt }] contient le nom de l'origine.
	\item[\texttt{abscissetxt}] contient le nom de du vecteur de l'axe des abscisses.
	\item[\texttt{ordonneetxt}] contient le nom de du vecteur de l'axe des ordonnées.
 \end{description}

Le repère par défaut est définit par \verb+reperecourant+, une constante de type \texttt{repere}. C'est, sauf définition de l'utilisateur, le repère << canonique >> de \mbox{\asym.}

\begin{verbatim}
repere canonique;
canonique.origine=(0,0);
canonique.abscisse=(1,0);
canonique.ordonnee=(0,1);
canonique.originetxt="$O$";
canonique.abscissetxt="$\vec{i}$";
canonique.ordonneetxt="$\vec{j}$";
\end{verbatim}

Une fois le repere définit, il reste à tracer les axes et eventuellement la base :

\comm{axes(repere rep,int graduation=1,pen sty=currentpen)} trace les axes si graduation=1, gradué toutes les unités, 2 toutes les demi-unités, 3 tous les dixièmes.

\comm{base(repere rep,bool vecteur=true,pen sty=currentpen)} trace une base avec les vecteurs. Si \texttt{vecteur} est \texttt{true}, le nom des vecteurs apparaissent.


\subsection{Les points}

\comm{pair place(string nom,real x, real y,pair direction, repere rep=reperecourant, bool trait=false, pen sty=currentpen)} renvoie et place un pair avec les coordonnées (x;y) dans le repère rep mais dont les coordonnées pour \asym peuvent être différentes.

\comm{pair position(real x, real y,repere rep=reperecourant)} renvoie un pair avec les coordonnées (x;y) dans le repère rep mais dont les coordonnées pour \asym peuvent être différentes.

\section{Les courbes et fonctions}

\subsection{Courbes}


\comm{tracepara (real f(real),real g(real),real a, real b, repere rep=reperecourant, int precision=500, pen sty=currentpen+linewidth(0.5)) } trace des courbes paramètrées.

\comm{tracepolaire (real r(real), real a, real b, repere rep=reperecourant,\\int precision=500, pen sty=currentpen+linewidth(0.5))} trace des courbes polaires.

\subsection{Fonctions}

\comm{tracefonction (real f(real), real a, real b, repere rep=reperecourant,\\int precision=500, pen sty=currentpen+linewidth(0.5))} trace des fonctions.

\comm{path tangente(real a, real f(real), real h=0.01, repere rep=reperecourant)} trace la tangente en a à f.

\comm{path morceau (real f(real), real a, real b, repere rep=reperecourant,\\int precision=500)} renvoie un morceau de courbe si tout le tracé est contenu dans le cadre. Cette fonction est pratique pour hachurer des zones ou calculer des intersections de courbes.

\comm{nomfonction(string txt, real f(real), real abscisse, repere oij=reperecourant,\\pair diri, pen p=currentpen)} place le nom du graphe de la fonction $f$.

Exemple de tracé de fonctions :

\noindent\begin{verbatim}
import geoplane;
figure((-6,-4),(6,4));
pair A;
repere oij;
oij.origine=(0,0);
oij.abscisse=(1,0);
oij.ordonnee=(0,1);
oij.originetxt="$O$";
oij.abscissetxt="$\vec{\imath}$";
oij.ordonneetxt="$\vec{\jmath}$";
reperecourant=oij;
real f2(real x){return sin(x);}

axes(oij,1);

A=place("$A$",pi/4,f2(pi/4),nord,oij,trait=true);
hachurage(morceau(f2,0,pi/4,200)--position(pi/4,0)--oij.origine--cycle,2,45,grey);
draw(tangente(pi/4,f2),blue+dashed);
tracefonction(f2,-1.99,2,oij,red); 
//commencer le trace à -1,99 permet d'éviter une division par zéro

nomfonction("$\mathscr{C}_g$",f2,-1,sud,red);
base(oij);
\end{verbatim}

\begin{flushleft}
\begin{asy}
import geoplane;
figure((-6,-4),(6,4));
pair A;
repere oij;
oij.origine=(0,0);
oij.abscisse=(1.5,0);
oij.ordonnee=(0,1.5);
oij.originetxt="$O$";
oij.abscissetxt="$\vec{\imath}$";
oij.ordonneetxt="$\vec{\jmath}$";
reperecourant=oij;
real f2(real x){return sin(x);}
real f1(real x){return 1/x;}
axes(oij,1);

A=place("$A$",pi/4,f2(pi/4),nord,oij,trait=true);

hachurage(morceau(f2,0,pi,200)--position(pi,0)--oij.origine--cycle,2,45,lightred);
draw(tangente(pi/4,f2),blue+dashed);
tracefonction(f2,-4,4,oij,red);
tracefonction(f1,-3.99,4,green*0.6);
nomfonction("$\mathscr{C}_g$",f2,-1,sud,red);
base(oij);
\end{asy}        
\end{flushleft}

Exemple de tracé de courbes paramétrées :

\noindent\begin{verbatim}
import geoplane;
figure((-6,-6),(6,6));

repere oij;
oij.origine=(0,0);
oij.abscisse=(1.2,0);
oij.ordonnee=(0,1.2);
oij.originetxt="$O$";
oij.abscissetxt="$\vec{\imath}$";
oij.ordonneetxt="$\vec{\jmath}$";
reperecourant=oij;

real x1(real t){return 4*(cos(t)^3);}
real y1(real t){return 4*(sin(t)^3);}
real r(real t){return 1+3*cos(t);}

axes(oij,1);

tracepara(x1,y1,-3.14,3.14,oij,0.5*green);
tracepolaire(r,0,10*pi,lightblue);

base(oij);
\end{verbatim}

\begin{flushleft}
\begin{asy}
import geoplane;
figure((-6,-6),(6,6));

repere oij;
oij.origine=(0,0);
oij.abscisse=(1.2,0);
oij.ordonnee=(0,1.2);
oij.originetxt="$O$";
oij.abscissetxt="$\vec{\imath}$";
oij.ordonneetxt="$\vec{\jmath}$";
reperecourant=oij;

real x1(real t){return 4*(cos(t)^3);}
real y1(real t){return 4*(sin(t)^3);}
real r(real t){return 1+3*cos(t);}

axes(oij,1);

tracepara(x1,y1,-3.14,3.14,oij,0.5*green);
tracepolaire(r,0,10*pi,lightblue);

base(oij);
\end{asy}        
\end{flushleft}



\newpage

\begin{Large}Et un dernier exemple plus complet ...\end{Large}

\begin{verbatim}
import geoplane;
import math;
import markers;
import geometry;
import patterns;

pair A,B,C,D,I,L,J;

figure((-0.5,-0.5),(6.5,6.5));
A=(0,0);
B=(0,6);
C=(6,6);
D=C-B+A;
I=milieu(A,D);
L=A+4/6*(B-A);
draw(A--B--C--D--cycle);
draw(L--I);
draw(L--D);
angledroit(L,A,I,red);
cotemilieu(A,L,"4 cm",2mm);
cote(B,C,"6 cm",2mm,0.5*green);
hachurage(I--L--D--cycle,2mm,45,blue);
filldraw(L--D--C--B--cycle,0.8*white);
nomme("$A$",A,p=blue,sud);
nomme("$B$",B,nord);
nomme("$C$",C,nord);
nomme("$D$",D,sud);
nomme("$I$",I,sud);
nomme("$L$",L,ouest);
pointe(milieu(L,I));
codemilieu(L,I,5);
draw(droite(A,milieu(L,I)),dashed);
J=intersectionpoint(droite(A,milieu(L,I)),B--C);
nomme("$J$",J,nord);
codemilieu(A,D,2);
path d;
d=perpendiculaire(A,D,J);
draw(d,0.6*red+dashed);
draw(arc(A,L,2,-92),orange);
codeangle(I,A,J,0,2,green*0.5+1.5bp);
\end{verbatim}

\begin{center}
\begin{asy}
import geoplane;
import math;
import markers;
import geometry;
import patterns;

pair A,B,C,D,I,L,J;

figure((-0.5,-0.5),(6.5,6.5));
A=(0,0);
B=(0,6);
C=(6,6);
D=C-B+A;
I=milieu(A,D);
L=A+4/6*(B-A);
draw(A--B--C--D--cycle);
draw(L--I);
draw(L--D);
angledroit(L,A,I,red);
cotemilieu(A,L,"4 cm",2mm);
cote(B,C,"6 cm",2mm,0.5*green);
hachurage(I--L--D--cycle,2mm,45,blue);
filldraw(L--D--C--B--cycle,0.8*white);
nomme("$A$",A,p=blue,sud);
nomme("$B$",B,nord);
nomme("$C$",C,nord);
nomme("$D$",D,sud);
nomme("$I$",I,sud);
nomme("$L$",L,ouest);
pointe(milieu(L,I));
codemilieu(L,I,5);
draw(droite(A,milieu(L,I)),dashed);
J=intersectionpoint(droite(A,milieu(L,I)),B--C);
nomme("$J$",J,nord);
codemilieu(A,D,2);
path d;
d=perpendiculaire(A,D,J);
draw(d,0.6*red+dashed);
draw(arc(A,L,2,-92),orange);
codeangle(I,A,J,0,2,green*0.5+1.5bp);
\end{asy}
%\caption{Venn diagram}\label{venn}
\end{center}


\end{document}