Bonjour ,

si on sait ce qu'est la mesure principale d'un angle orienté , il n'y a rien de compliqué à comprendre .
Le mieux serait que tu dises ce que tu ne comprends pas

Cordialement

C'est la seule mesure de alpha dans [-Pi ; Pi ] mais alors que sont les 3 cas, les trois cas particulier ?  angle nul, angle plat et angle droit ?

Pour l'algorithme, je ne sais pas comment faire, par où commencer, que mettre dans les trous

Pour le 3), je ne sais spas faire un algorithme, comment ça fonctionne..

Les 3 cas sont   x=0 , x>0  et  x<0

Pour compléter l'algorithme , il suffit de savoir comment tu ferais pour ramener un angle à sa valeur principale .

Pour l'algorithme on obtient donc ceci ?

Si x > 0
     |            Alors Tant que x > Pi
     |                   |          x prend la valeur x-2 Pi
     |                 Fin tant que
     |                 Afficher x
     |             Sinon si x inférieur ou égal à -Pi
     |                    |       Alors tant que x inférieur ou égal à -Pi
     |                    |               |            x prend la valeur x+2 Pi
     |                    |             Fin tant que
     |                    |             Afficher x
     |                    |       Sinon afficher x
     |                    Fin si
Fin si

Et pour le 3 ? je ne sais pas comment faire...

Tu vois que ce ne n'était pas très compliqué .
Pour le 3 , comment ferais-tu s'il fallait trouver la mesure principale de  29 /3  par exemple

D'après ce que j'ai compris, on peut faire 29 - 2*3 ? jusqu'à que  a<b ?

Là , tu es sur la bonne voie .

Donc si a/b > 0 on fait a-2b jusqu'à ce que a<b mais pour a/b <0 ?

si  a/b est négatif , il faut déterminer si c'est a qui est négatif ou si c'est b .
dans ce dernier cas , on se ramène à  a négatif  (en inversant les signes de a et de b) et on ajoute  2 b   jusqu'à   a<-b

On peut aussi faire une valeur absolue ?
Si a/b supérieur ou égal à 0
Tant que |a/b|>0
Alors a prend a+2b
Ou si a/b inférieur ou égal à 0
TAnt que |a/b|>0
Alors a prend a-2b ?

C'est peut-être possible . Tu peux (tu devrais) vérifier cela avec  prolab  par exemple ou ta calculatrice éventuellement ou pourquoi pas python .

Je ne vois pas comment faire le programme j'ai essayé mais aucun résultat...

Montre ce que tu as essayé .

"A="?->A
"B="?->B
If A/B>=0
Then
While Abs (A/B)>0
Do
A-2*B->C
WhileEnd
Afficher C
Afficher B
Else
While Abs (A/B)>0
Do
A+2*B->D
WhileEnd
IfEnd
Afficher D
Afficher B

tes boucles  While Abs (A/B)>0  sont des boucles sans fin puisque A et B ne changent pas de valeur dans la boucle . Donc la condition est toujours vraie

Donc comment la faire changer de valeur ? JE ne suis pas sûr d'avoir très bien compris.

tu peux faire  C = A   et  D = B    et   While Abs (C/D)>0

Mais il faut de j'obtienne une fraction avec c et d ?
Excuse moi, mais je ne comprends rien à ce que je dois mettre ou enlever...

Ce que tu as commencé à faire allait dans le bon sens . Il faut travailler (test et modifications)  sur C et D qu'on affichera à la fin .

Il faut donc que je modifie les boucles While ?

"A="?->A
"B="?->B
A=C
B=D
If A/B>=0
Then
While Abs (A/B)>0
Do
A-2*B->E
WhileEnd
Afficher E
Afficher B
Else
While Abs (C/D)>0
Do
A+2*D->F
WhileEnd
IfEnd
Afficher F
Afficher C

C'est ça ?

Pourquoi introduire d'autres variable (E)  
Ensuite tu affiches  C  sans lui avoir donné aucune valeur .

Pour les deux formules :
A-2*B->A
et
C+2*D->C ?

A la fin je fais afficher C et D du coup ?

Oui le résultat doit être dans C et D

J'ai recopié le programme comme ceci :

"A="?->A
"B="?->B
A=C
B=D
If A/B>=0
Then
While Abs (A/B)>0
Do
A-2*B->A
WhileEnd
Afficher A
Afficher B
Else
While Abs (C/D)>0
Do
C+2*D->C
WhileEnd
IfEnd
Afficher C
Afficher D

MAlheureusement j'ai un problème de syntaxe ici

Pour la syntaxe , je ne peux pas t'aider car je ne connais pas ce langage très peu lisible (pas d'indentation)

Voila une version prolab (algobox) perfectible

VARIABLES
A EST_DU_TYPE NOMBRE
B EST_DU_TYPE NOMBRE
C EST_DU_TYPE NOMBRE
D EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE A
LIRE B

SI ((A*B>0)) ALORS   // meme signe
DEBUT_SI
    C PREND_LA_VALEUR abs(A)
    D PREND_LA_VALEUR abs(B)
TANT_QUE (C>D) FAIRE
DEBUT_TANT_QUE
C PREND_LA_VALEUR C-2*D
FIN_TANT_QUE
FIN_SI

SI ((A<0) ET (B>0)) ALORS
DEBUT_SI
    C PREND_LA_VALEUR A
    D PREND_LA_VALEUR B
TANT_QUE (abs(C)>D) FAIRE
DEBUT_TANT_QUE
C PREND_LA_VALEUR C+2*D
FIN_TANT_QUE
FIN_SI

SI ((A>0) ET (B<0)) ALORS
DEBUT_SI
    C PREND_LA_VALEUR -A
    D PREND_LA_VALEUR -B
TANT_QUE (abs(C)>D) FAIRE
DEBUT_TANT_QUE
C PREND_LA_VALEUR C+2*D
FIN_TANT_QUE
FIN_SI


SI (C==D) ALORS
DEBUT_SI
AFFICHER A
        AFFICHER " pi / "
        AFFICHER B
        AFFICHER " = "
        AFFICHER " pi / "

FIN_SI
SINON
DEBUT_SINON
                AFFICHER A
            AFFICHER " pi / "
            AFFICHER B
            AFFICHER " = "
            AFFICHER C
            AFFICHER " pi / "
            AFFICHER D
FIN_SINON
FIN_ALGORITHME

Tout ceci devient de plus en plus compliqué...Je me pers.
Ton logiciel peut-il convertir ceci en langage casio ? Cela faciliterait la compréhension...

La conversion dans le sens algobox casio ne demande que de connaitre le langage casio (ce qui n'est pas mon cas , je n'ai même pas de calculatrice)
On distingue 3 cas suivant les signes de A et B . Commence par coder le premier cas (mêmes signes)
voici en plus lisible  la partie hors affichages qui ne sont pas super en algobox

Pourquoi demande-t-on les valeurs C et D ? Je souhaite juste demander les deux nombres A et B et afficher la mesure principale sous la forme C/D Pi

De plus, cet algorithme me semble très compliqué pour mon niveau.
Ne penses-tu pas que l'on puisse faire quelque chose de beaucoup plus court ?

Je ne demande que A et B  (LIRE A  et  LIRE B)
Ce qui précède n'est que la déclaration des variables que le programme utilise . Il semble que en casio  , ces déclarations ne soient pas nécessaires .

le programme parait long mais les 3 blocs sont très semblables . Une fois le premier bloc  (A et B de même signe) testé , un simple copie/collé me donne les 2 autres blocs dans lesquels je modifie peu de choses . Tu peux simplifier l'affichage final en n'affichant que C et D .

Tu n'aurais pas une façon plus rapide de trouver ce résultat ? Je suis totalement perdu là..

Chacun des 3 trois blocs fait 4 lignes . Je ne vois pas comment on pourrait faire plus simple .

Comment traduire  ((A<0) ET (B>0)) ?
Il n'y a pas de commande And

tu peux faire 2 si
si A<0
   si B>0
      ...

Mais je suis surpris qu'il n'y ait pas  ET  et  OU  en casio
Voir

JE viens de trouver, malheureusement j'ai toujours un problème au niveau du WhileEnd mais je ne sais pas comment le résoudre..

Voila ce que j'ai trouvé sur internet .
Voie ces quelques lignes car il se peut que l'erreur signalée sur WhileEnd  vienne d'ailleurs entre While et WhileEnd  . Par exemple le Do que tu as mis juste après While .

Il semblerait que ton programme fonctionne, il fait exactement ce que je veux.
DE plus, dans la question 1, les trois cas sont donc x>0, x=0 et x<0, quel est le plus simple à gérer ?  x=0 ?

Il se pourrait que les 3 cas soient    

-pi < x <= pi     cas le plus simple car il n'y a rien à faire
x > pi
x <= -pi

D'accord, j'ai compris !
JE te remercie pour ton aide et j'espère ne pas t'avoir trop embêté.
Sur ce je te souhaite une bonne soirée !

Merci et bonne continuation .