bonjour,


regarde ce topic Algorithme calculant la mesure principale d'un angle orienté

Merci pour votre redirection, mais je ne crois pas avoir tout compris

Nottament la commande : "TANT_QUE (abs(MP)>1) FAIRE" Et pour faire "SI (MP<-1) ALORS"... "SI (MP>1) ALORS" ... alors que dans mon énoncé, la seule chose qui est précisé c'est "sachant qu'il faut a/b<1"

VARIABLES
N EST_DU_TYPE NOMBRE  N pour numerateur (c'est le a)
D EST_DU_TYPE NOMBRE  D pour dénominateur (c'est le b)
MP EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE N
LIRE D
MP PREND_LA_VALEUR N/D  ==> MP prend la valeur a/b
TANT_QUE (abs(MP)>1) FAIRE  ==> tant que |a/b|>1 on s'arretera quand a/b <1 avec a/b>0 ou
                                                                        quand a/b> -1 avec a/b<0
DEBUT_TANT_QUE
SI (MP<-1) ALORS  ==> on est dans le cas ou a/b < 0
DEBUT_SI
N PREND_LA_VALEUR N+2*D   ==> il faut ajouter 2pi à l'angle
FIN_SI
SI (MP>1) ALORS  ==> on est dans le cas ou a/b > 0
DEBUT_SI
N PREND_LA_VALEUR N-2*D   ==> il faut retrancher 2pi
FIN_SI
MP PREND_LA_VALEUR N/D
FIN_TANT_QUE
AFFICHER N
AFFICHER "/"
AFFICHER D
FIN_ALGORITHME



OK ?

Juste une remarque sur l'algo de Leile :

Il faut ramener l'angle dans ]-Pi ; Pi]

Soit, dans l'algo, N/D dans ]-1 ; 1]

Il y a un "raté" qui amène -1 (qui est hors domaine) au lieu de 1.
Par exemple en entrant N = -18 et D = 6 ...
L'algo donne au final -6/6 ... au lieu de + 1

Il reste à corriger cette imperfection (ce qui est facile à faire)

Une alternative (qu'on peut simplifier) :

VARIABLES
a EST_DU_TYPE NOMBRE
b EST_DU_TYPE NOMBRE
k EST_DU_TYPE NOMBRE
n EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE a
AFFICHER "Entrez une valeur de b non nulle"
LIRE b
SI (a/b > 0) ALORS
DEBUT_SI
k PREND_LA_VALEUR floor(a/b/2)
SI (a/b/2 - k >= 0.5) ALORS
DEBUT_SI
      k PREND_LA_VALEUR k+1
FIN_SI
n PREND_LA_VALEUR (a/b) - 2*k
FIN_SI
SINON
DEBUT_SINON
k PREND_LA_VALEUR floor(-a/b/2)
SI (-a/b/2 - k >= 0.5) ALORS
DEBUT_SI
k PREND_LA_VALEUR k+1
FIN_SI
  n PREND_LA_VALEUR (a/b) + 2*k
FIN_SINON
SI (n == -1) ALORS
   DEBUT_SI
   n PREND_LA_VALEUR 1
   FIN_SI
AFFICHER "mesure principale = "
AFFICHER n
AFFICHER " Pi radian"
FIN_ALGORITHME

Je comprend pas tout,
Je suis allé voir mon professeur ce midi, il m'a donné pour consigne (aide) d'utiliser un Tant que. Il a précisé de faire determiné si a/b est positif ou négatif ce que semble avoir fais Leile.
Cependant, je comprend pas "SI (MP<-1) ALORS  ==> on est dans le cas ou a/b < 0 " ; "SI (MP>1) ALORS  ==> on est dans le cas ou a/b > 0 "

Du coup, quand je programme cet algorithme sur calcu il me sort pas réellement ce qui est demandé :/  

on veut faire différemment selon que a/b est negatif ou positif

on pourrait écrire "SI (a/b <0) alors... "
on a MP = a/b  et comme on est à l'intérieur du tant que
on a forcément MP > 1 ou MP < -1
le test MP < -1  est equivalent à a/b <0

on pourrait écrire
SI (MP < 0) ALORS  au lieu de SI(MP < -1) ALORS
et
SI (MP > 0) ALORS au lieu de SI (MP > 1) ALORS

d'accord ?

Je crois comprendre, j'essaierai ça. Donc, dans l'algorithme, on peut écrire directement "Si MP<0 alors ..." et si "MP>0 alors..." ?

oui, c'est ce que j'ai écrit à 13:35

SI (MP < 0) ALORS  au lieu de SI(MP < -1) ALORS
et
SI (MP > 0) ALORS au lieu de SI (MP > 1) ALORS

à toi de tester l'algo

C'était pour être sur, j'essaye ça en rentrant, merci beaucoup

J'ai testé,

Alors pour quelques valeurs positifs, tout est niquel
Pour a/b < 0 il me donne les valeurs que j'entre au départ donc il ne donne pas la valeur principale de celle-ci.

Ainsi, comment faire pour avoir la valeur principale lorsque a/b, soit MP<0

Merci

J'ai également testé l'alternative de J-P, et il veux pas executé, il me met toujours "0"

Remarque en passant,

Avec l'algo proposé par Leile, cela peut "coincer" à cause du nombre max de boucles permis par Algobox.

Par exemple, en entrant N = 12345678 et D = 3
...
On recoit le message :
***Algorithme interrompu ligne 20 : dépassement de la capacité autorisée pour les boucles***

Dans cet algo, (même si on reste à un nombre de boucles permis), la durée d'exécution s'allonge avec la valeur du rapport N/D. Cette "caractéristique" n'existe pas avec l'algo du message du  17-04-15 à 12:40.
Mais ce n'est probablement pas ce qui est attendu par le prof qui suggère le résoudre l'exo par boucles successives (comme dans l'algo de Leile) malgré ses limitations et inconvénients (nombre max de boucles permis et temps de traitement qui s'allonge avec le rapport N/D)

bonjour,

Pas de raison (autre que celle que j'ai mentionnée sur le nombre max de boucles) que l'algo de Leile ne fonctionne pas avec MP < 0.

Mais évidemment, il ressortira les valeurs entrées au départ ... si ces valeurs correspondent à la valeur principale.

Tu ferais mieux de préciser les valeurs que tu entres et celles qui ressortent que tu juges fausses.

Leile, je ne comprend pas le traitement "Abs(MP)" pourquoi abs ?

J-P, j'ai re-vérifié plusieurs fois, et j'ai tout copié correctement..

De plus, sur le screenshot on vois que le résultat est "-0.52..." pi radian, or il me le faut sous forme de fraction

Merci pour vos propositions et vos corrections, mais après plus de de 7h de travail sur ce même exercice, et des 10aines de, voir une ceintaine de combinaisons différentes essayer, je n'arrive à rien qui répondent à toutes les demandes de la consigne..

Je pense m'arrêter là, tanpis...

pourquoi "abs" ?

tu dois opérer la boucle TANT QUE  MP > 1 si MP est positif
ou bien TANT QUE  MP < -1 si MP est négatif

pour que le test du TANT QUE soit plus simple à écrire, je t'ai proposé de tester la valeur absolue de MP

ainsi "MP > 1 si MP>0  ou  MP<-1 si MP <0"  se résume à "valeur absolue de MP >1", que j'ai écrit (abs(MP)>1)

sur ta calculatrice, as tu bien précisé que tu testais la boucle TANT QUE selon la valeur absolue de MP ?
si non, ça ne marchera pas pour les valeurs négatives..

tu es tout proche, dommage d'abandonner maintenant..

J'ai une solution, regroupant tout ce que vous m'avez dis mais qui n'est pas exactement la même que les votres.

Je ne l'ai que sous forme de programme casio 35+
Soit,

"Numérateur ="?→A
"Entrer B différent de 0"
"Dénominateur ="?→B
If A/B<0
Then While Abs(A/B)>1
A+2B→A
WhileEnd
Else While Abs(A/B)>1
A-2B→A
WhileEnd
IfEnd
"A/B=:A/B◄

Je ne sais pas si ce programme traduit exactement vos algos proposés mais en tout cas, il a l'air de fonctionner pour les valeurs pos et nég.

Est-il bon?

Remarque déjà faite :

Si par exemple, tu entres A = -3 et B = 1
... la sortie de ton algo donnera -1/1. Mais la bonne réponse devrait être 1/1

La mesure principale est dans ]-Pi ; Pi] et pas dans [-Pi ; Pi]

Il manque donc une ligne pour corriger cette anomalie.