ASY-Forum

unitsize(.8cm);
import geometry;
 
defaultpen(fontsize(8pt)); // Stylo par défaut
 
real r=5; // rayon du demi-cercle intérieur : r
real l=2.5; // largeur du rapporteur : l
real p=l/10; // largeur des petites graduations
real g=2p; // largeur des grandes graduations
 
point pO=(0,0), pA=(r,0);
line droiteregle=line(0,-l);
circle cercleint=circle(pO,r),
       cercleext=circle(pO,r+l);
point[] R=intersectionpoints(droiteregle,cercleext);
 
for(int a=0; a<=6; ++a) draw(pO--r*dir(a*30),gray);
path chint=arc(cercleint,pA,-pA)--cycle,
	 chext=arc(cercleext,R[1],R[0])--cycle;
filldraw(chint^^chext,paleblue+white+evenodd,1bp+black);
draw((r+l)*dir(45)--pO--(r+l)*dir(135),red);
 
for(int k=0; k<180; ++k)
	draw(r*dir(k)--(r+p)*dir(k)^^(r+l-p)*dir(k)--(r+l)*dir(k),.4bp+gray);
 
for(int k=0; k<=18; ++k) {
	draw(r*dir(10k)--(r+g)*dir(10k)^^(r+l-g)*dir(10k)--(r+l)*dir(10k),.6bp+blue);
	label(rotate(10k-90)*format("%i",10*k),(r+g)*dir(10k),dir(10k));
	label(rotate(90-10k)*format("%i",10*k),(r+l-g)*dir(180-10k),dir(-10k));
}
int xmax=floor(R[1].x);
for(int x=0; x<10*xmax; ++x)
	draw((-x/10,-l)--(-x/10,p-l)^^(x/10,-l)--(x/10,p-l),.4bp+gray);
for(int x=0; x<=xmax; ++x) {
	draw((-x,-l)--(-x,g-l)^^(x,-l)--(x,g-l),.6bp+blue);
	label(format("%i",x),(x,g-l),N);
	label(format("%i",-x),(-x,g-l),N);
}

import graph;
import math;
usepackage("amsmath");
size(15cm,15cm,Aspect);
 
pair O=(0,0), A, B, C, D;
real R[], u = 1cm;
path cercle[];
int n= 100;
 
R[1] = 13u;
R[2] = R[1]/2;
 
// Définition et tracé du cadre
A = shift(R[1],0)*O;
B = shift(0,R[1])*O;
 
void test(real theta)
{
    real angle = radians(theta);
    pair P =R[1]*(cos(angle),sin(angle));
    // write(P);
    dot("P",P,red);
    draw(O--P,red);
    //
    pair Q = (0,ypart(P));
    draw(P--Q,red);
    dot("Q",Q,red);
}
path cadre(pair point, real R)
{
    return arc(point,R,0,90)--point--shift(R,0)*point;
}
 
draw(cadre(O,R[1]),linewidth(0.5bp));
 
path trait1,trait2,trait3;
 
real longueur = 1u;
real longueur1 = 0.05*u;
real longueur2 = 0.10*u;
real longueur3 = 0.20*u;
real longueur4 = 0.25*u;
real longueur5 = 0.35*u;
real longueur6 = 0.5*u;
 
// Tracé des graduations du cadre
for (int i=0; i <=n; ++i)
{
    if (i%5 != 0){
        longueur = longueur2;
    }else{
        longueur = longueur3;
        label(format("% 0.2f ",i/n), shift(-longueur,(i/n)*R[1])*O,+0.2W); //,+0.2W
        label(format("% 0.2f ",i/n), shift((i/n)*R[1],-longueur)*O,+0.4S);//,+0.4S
    }
    trait1 = O--shift(0,-longueur)*O;
 
    // Graducations sur l'axe horizontal
    draw(shift((i/n)*R[1],0)*trait1,linewidth(0.5bp));
    // Graducations sur l'axe vertical
    draw(shift(0,(i/n)*R[1])*rotate(-90)*trait1,linewidth(0.5bp));
}
 
// Tracé des degrés sur la cercle
real i= 0;
while (i <= 90)
{
    if (2*i % 2 == 0){
        longueur = longueur2;}
        if (i % 5 == 0){
            if (i % 10 == 0){
                longueur = longueur4;
            }else{
                longueur = longueur3;
            }
        Label toto= format("%1f ",i);
        label(rotate(-90+i)*toto,rotate(i)*shift(R[1]+longueur5,0)*O, black);
    }
    if (2*i % 2 == 1){
        longueur = longueur1;
    }
    trait1 = shift(R[1],0)*(O--shift(longueur,0)*O);
    draw(rotate(i,O)*trait1);
    i = i + .5;
}
draw(arc(O,R[1]+longueur2,0,90),linewidth(0.5bp));
draw(arc(O,R[1]+longueur6,0,90),linewidth(0.5bp));
 
// tracé des cercles de Cosinus et Sinus
C = (R[1]/2,0);
real epaisseur = 1*longueur/3;
 
// Cercle des Cosinus
cercle[1] = arc(O,R[1]/2,0,180);
cercle[2] = arc(O,R[1]/2-epaisseur,0,180);
draw(shift(C)*cercle[1],linewidth(0.5bp));
draw(shift(C)*cercle[2],linewidth(0.5bp));
 
// Cercle des Sinus
D = rotate(90)*C;
cercle[3] = shift(D)*rotate(-90)*cercle[1];
cercle[4] = shift(D)*rotate(-90)*cercle[2];
draw(cercle[3],linewidth(0.5bp));
draw(cercle[4],linewidth(0.5bp));
 
// Graduation des arcs de Cosinus
trait1 = shift(0,R[1]/2-epaisseur)*(C--shift(0,epaisseur)*C);
trait2 = shift(0,R[1]/2-epaisseur/2)*(C--shift(0,epaisseur/2)*C);
 
Label toto;
 
void pointC(int i)
{
    real abs = i/1000*R[1];
    real x = abs^2/R[1];
    real y = sqrt(R[2]^2-(x-xpart(C))^2);
    toto = format("%.2f",abs/R[1]);
    pair T = (x,y);
    if (i % 10 ==0){
        real delta;
        if (i <= 100){
            delta = 1-0.75*epaisseur/100;
        }else{
            delta = 1.0075;
        }
        draw(rotate(2*degrees(angle(T))-90)*scale(0.35)*toto,shift((T-C)*delta)*C);
    }
    path trait;
    trait1 = C--shift(0,-epaisseur)*C;
    trait2 = C--shift(0,-epaisseur/2)*C;
    if (i % 5 ==0){
        trait = trait1;
    }else{
        trait = trait2;
    }
    draw(rotate(2*degrees(angle(T))-90,T)*shift(T-C)*trait);
}
 
void pointS(int i)
{
    real abs = i/1000*R[1];
    real y = abs^2/R[1];
    real x = sqrt(R[2]^2-(y-ypart(D))^2);
    toto = format("%.2f",abs/R[1]);
 
    pair T = (x,y);
    if (i % 10 ==0){
        real delta;
        if (i <= 100 ){
            delta = 1-0.75*epaisseur/100;
        }else{
            delta = 1.01;
        }
        if (i != 710){
            draw(rotate(2*degrees(angle(T))-90)*scale(0.35)*toto,shift((T-D)*delta)*D);
        }
    }
 
    path trait;
    trait1 = D--shift(-epaisseur,0)*D;
    trait2 = D--shift(-epaisseur/2,0)*D;
    if (i % 5 ==0){
        trait = trait1;
    }else{
        trait = trait2;
    }
    draw(rotate(2*degrees(angle(T))-90,T)*shift(T-D)*trait);
}
 
for (int i = 2; i <= 1000; i = i +2){
    pointC(i);
    pointS(i);
}
 
// Schéma de principe
pair M = R[1]*.76*(1,1);
real r= 3.5u;
dot("M",M,SW);
 
draw(cadre(M, r));
real theta = 35;
real angle = radians(theta);
pair P =M + r*(cos(angle),sin(angle));
 
dot("$P$",P);
draw(M--P);
pair Q1 = (xpart(M),ypart(P));
pair Q2 = (xpart(P),ypart(M));
draw(Q1--P--Q2,dashed);
dot("$\sin \alpha$",Q1,W);
dot("$\cos \alpha$",Q2,S);
draw(arc(shift(r/2,0)*M,r/2,0,180));
draw(arc(shift(0,r/2)*M,r/2,-90,90));
draw(arc(M,xpart(Q2)-xpart(M),0,theta));
draw(arc(M,r/5,0,theta));
label("$\alpha$", rotate(theta/2,M)*shift(r/5,0)*M,W);
dot("$\cos \alpha$", rotate(theta,M)*Q2,N);
draw(rotate(theta,M)*Q2--shift(r,0)*M);
 
dot("$\sin \alpha$", rotate(theta-90,M)*Q1,SE);
draw(shift(0,r)*M--rotate(theta-90,M)*Q1);
draw(arc(M,ypart(Q1)-ypart(M),theta,90));
 
draw(arc(M,xpart(Q2)-xpart(M),0,theta));
 
draw(arc(shift(0,r)*M,r/5,-90,-90+theta));
label("$\alpha$", rotate(theta/2,shift(0,r)*M)*shift(0,4r/5)*M,N);