[Challenge] De fin d'année

[VDH-Bruno]

Bonsoir,

Une récente discussion m'a inspiré une petite proposition de challenge qui doit pouvoir parler à tous le monde

https://cadxp.com/topic/54760-pb-de-trigo/?tab=comments#comment-312380

En général pour résoudre des problèmes de résolution dans un triangle, j'ai pour habitude de me servir des triangles semblables pour travailler sur un triangle dont l’hypoténuse (rayon du cercle unitaire) vaut 1, de façon à trouver la relation la plus simplifié à programmer pour résoudre le système. Pour mémoire dans cette configuration il suffit de connaitre une seule donné pour en déduire les autres.

Dans cet esprit je vous propose d'élaborer une fonction trigones qui peut prendre en arguments: l'angle / sinus / cosinus / sécante / cosécante / tangente / cotangente, j'ai volontairement limité les arguments on pourrait en ajouter.

(trigones  ang  sinus  cosinus  sécante cosécante  tangente cotangente)

Dans l'appel de la fonction, on ne renseignerait qu'un argument les autres valant nil, et la fonction retournerait tous les autres cotés, et ce quelque soit l'argument renseigné.

Ex: Appel de fonction en renseignant l'angle:

_$ (trigones (/ pi 4) nil nil nil nil nil nil)
(0.785398 0.707107 0.707107 1.41421 1.41421 1.0 1.0)

Ex: Appel de fonction en renseignant le sinus:

_$ (trigones nil 0.6 nil nil nil nil nil)
(0.643501 0.6 0.8 1.25 1.66667 0.75 1.33333)

Ex: Appel de fonction en renseignant la tangente:

_$ (trigones nil nil nil nil nil 2 nil)
(1.10715 0.894427 0.447214 2.23607 1.11803 2 0.5)

Une petite illustration pour ceux dont la résolution des trigones est un lointain souvenir, on se limite a résoudre le triangle de rayon 1 dans le premier quadrant du cercle c'est à dire avec un angle compris entre 0 et PI/2

Un petit prétexte pour réviser sa trigo en cette fin d'année, bon code à tous.

 

[(gile)]

Salut,

Je suis toujours ravi de pouvoir participer à un nouveau challenge.
J'ai bien une réponse, mais je vais attendre un peu que d'autres répondent.

[VDH-Bruno]

il y a 7 minutes, (gile) a dit :

Salut,

Je suis toujours ravi de pouvoir participer à un nouveau challenge.
J'ai bien une réponse, mais je vais attendre un peu que d'autres répondent.

Bonjour (gile)

Génial, même si j'en doutais pas, oui merci d'attendre un peu pour ne pas tuer le match.

Perso j'ai écrit la mienne en moins de 15mn (j'ai été au plus simple), et je pense que l'on doit avoir sensiblement la même, si tu es impatient, tu peux me la poster en MP je jetterai un œil ça m'occupera, j'ai exceptionnellement un peu de temps devant moi, je suis à l'isolement forcé depuis hier... donc un peu de temps pour lancer et tester un challenge.

Bruno

[VDH-Bruno]

il y a une heure, VDH-Bruno a dit :

Perso j'ai écrit la mienne en moins de 15mn (j'ai été au plus simple), et je pense que l'on doit avoir sensiblement la même,

Zut... Je viens d'en trouver une autre plus analytique, du coup la première que j'avais écrite perd un peu de son intérêt dans ce que je voulais démontrer, si j'avais un peu mieux réfléchie au sujet, j'aurais certainement modifier l'énoncé du challenge... Bon c'est le jeu on peut pas penser à tout😉 

[(gile)]

Petite précision doit-on considérer que l'angle est strictement compris entre 0 et PI/2 ?
Ou doit on aussi traiter les angles 0 et PI/2 (ainsi que les autres paramètres correspondant) ?

[VDH-Bruno]

il y a 9 minutes, (gile) a dit :

Petite précision doit-on considérer que l'angle est strictement compris entre 0 et PI/2 ?
Ou doit on aussi traiter les angles 0 et PI/2 (ainsi que les autres paramètres correspondant) ?

Tu as raison il y a une coquille dans mon illustration, c'est strictement compris entre 0 et PI/2, comme indiqué dans l'énoncé.

Effectivement il y avait ambiguïté la précision est nécessaire. 

[nazemrap]

Bonsoir,

Les réponses sont elles souhaitées uniquement en Lisp ?

[VDH-Bruno]

il y a 16 minutes, nazemrap a dit :

Bonsoir,

Les réponses sont elles souhaitées uniquement en Lisp ?

Bonsoir nazemrap,

En Lisp c'est mieux mais si tu souhaites en déposer une que tu ne peux pas retranscrire dans ce langage, personnellement je ne suis pas contre.

Par contre je ne pourrai pas te la tester ou te faire un éventuel retour dessus.

Après tout dépend du langage car je sais que certains font appel à des bibliothèques mathématiques spécialisées très bien fournies, dans ce cas il y a plus vraiment de challenge;)

Salutations

Bruno 

[nazemrap]

Je ne suis pas capable de retranscrire.

Comme je n'ai plus de contacts avec Autocad, je suis passé à SketchUp et donc à la programmation en Ruby.
Je ne sais pas si je suis dans les cordes, je posterai donc dans une autre rubrique.("programmer en s'amusant" ?)

En tout cas ces challenges sont super intéressants , Bravo !!
J'ai tout de même un résultat.

[(gile)]

Un exemple testable en F#.
 

[VDH-Bruno]

Bonjour,

@nazemrap oui c'est ça bien ça

@(gile) Quant j'ai vu que tu posais un exemple en F# je n'avais plus de doute sur le codage, voir le code n'a fait que confirmer ce que je savais déjà 😉

(Ps: (gile) Je ne pense pas qu'il y aura beaucoup de proposition en Lisp sinon des personnes ce seraient déjà manifesté, je pense que dans la matinée tu peux déposer ta version Lisp, si tu le souhaites) 

[(gile)]

F#, en plus d'être mieux équipé que AutoLISP en fonctions mathématiques, de gérer les notions d'infini (Infinity) et de valeurs non valides (comme un sinus supérieur à 1) avec NaN (Not a Number), fournit, avec les unions discriminées, un élégant moyen de spécifier le type de valeur passée en argument. Résultat, un code concis et robuste...

[VDH-Bruno]

Merci de la précision très intéressant, pour la version lisp je t’avouerai que je suis parti du principe que les valeurs saisies étant dans le premier quadrant du cercle, elle était forcément valide donc je n'ai pas prévu de gestion d'erreur... Le but "déguisé" était de montrer l’intérêt d'écrire une solution fonctionnelle en "chainant" les appels.

Après comme il y avait peu de candidat sur le challenge j'ai aussi écrit une version plus "classique", version qui prend plus de 15mn à écrire 😉

.

[VDH-Bruno]

Il y a 21 heures, VDH-Bruno a dit :

Zut... Je viens d'en trouver une autre plus analytique, du coup la première que j'avais écrite perd un peu de son intérêt dans ce que je voulais démontrer, si j'avais un peu mieux réfléchie au sujet, j'aurais certainement modifier l'énoncé du challenge... Bon c'est le jeu on peut pas penser à tout😉 

Bonjour,

Comme il n'y a pas foule en Lisp, j'ouvre le bal en proposant ma deuxième version qualifié de plus "analytique" (pas ma préféré), pour la version fonctionnelle je laisserai (gile) dégainer en premier.

Comme j'ai un peu de temps j'ai mis des commentaires dans le code (une fois n'est pas coutume), elle est basé sur les triangles semblable ce qui nous place dans une relation de Thalès, et comme les 3 triangles ont un coté commun il est très facile de définir un coefficient de proportionnalité pour chaque triangle, donc un peu de Pythagore pour trouver le premier triangle et le tour est joué.

La fonction principale (basé sur le principe de Thalès)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Trigones 2                                                        VDH-Bruno  ;;
;; ---------------------------------------------------------------------------- ;;
;; Algorithme: Les 3 triangles sont des triangles semblables.                   ;;
;;             (leurs côtés sont proportionnels, les angles sont égaux)         ;;
;;             résoudre un des triangles c'est résoudre les deux autres         ;;
;; ---------------------------------------------------------------------------- ;;
;; Description       | (Hypothénuse) |  (Adjacent)   |   (Opposé)   | (coef *)  ;;
;;       Triangle 1: |       1       |    cosinus    |     sinus    |   x1      ;;
;;       Triangle 2: |    cosécante  |   cotangente  |       1      |   x2      ;;
;;       Triangle 3: |     sécante   |       1       |    tangente  |   x3      ;;
;;                                                                              ;;

(defun trigones2
       (ang sinus cosinus sec csc tang cot / triangle x1 x2 x3)
  (cond	(ang ;_ si angle	 
	 (setq triangle	(triangleRec 1. (cos ang) nil) ;_ Triangle 1 (cos angle)
	       x1	1.
	       x2	(/ 1. (caddr triangle))
	       x3	(/ 1. (cadr triangle))
	 )
	)
	((or sinus cosinus) ;_ si sinus ou cosinus	 
	 (setq triangle	(triangleRec 1. cosinus sinus) ;_ Triangle 1 
	       x1	1.
	       x2	(/ 1. (caddr triangle))
	       x3	(/ 1. (cadr triangle))
	       ang	(atan (/ (caddr triangle) (cadr triangle)))
	 )
	)
	((or csc cot) ;_ si cotangente ou cosecante	 
	 (setq triangle	(triangleRec csc cot 1.) ;_ Triangle 2 
	       x1	(/ 1. (car triangle))
	       x2	1.
	       x3	(/ 1. (cadr triangle))
	       ang	(atan (/ (caddr triangle) (cadr triangle)))
	 )
	)
	((or sec tang)			; _si secante ou tangente	 
	 (setq triangle	(triangleRec sec 1. tang) ;_ Triangle 3
	       x1	(/ 1. (car triangle))
	       x2	(/ 1. (caddr triangle))
	       x3	1.
	       ang	(atan (/ (caddr triangle) (cadr triangle)))
	 )
	)
  )
  (list	ang				; angle
	(* x1 (caddr triangle))		; sinus
	(* x1 (cadr triangle))		; cosinus
	(* x3 (car triangle))		; secante
	(* x2 (car triangle))		; cosecante
	(* x3 (caddr triangle))		; tangente
	(* x2 (cadr triangle))		; cotangente
  )
)

 

Et la fonction auxiliaire utilisant Pythagore pour déterminer les 3 cotés d'un triangle rectangle en fonction des 2 autres (fonction issus de ma biblio perso)

;; TriangleRec                                                     VDH-Bruno
;; Retourne les 3 cotés d'un triangle rectangle en fonction des 2 autres
;; Exemple: (TriangleRec nil 3. 4.) -> (5.0 3.0 4.0)
;;          (TriangleRec 5. nil 4.) -> (5.0 3.0 4.0)
(defun triangleRec (hyp adj opp)
    (mapcar
    '(lambda (val fun)
       (if val
	 (eval (list 'defun fun () val))
	 fun
       )
     )
    (list hyp adj opp)
    (list (defun hyp () (sqrt (+ (expt (opp) 2.0) (expt (adj) 2.0))))
	  (defun adj () (sqrt (- (expt (hyp) 2.0) (expt (opp) 2.0))))
	  (defun opp () (sqrt (- (expt (hyp) 2.0) (expt (adj) 2.0))))
    )
  )
  (list (hyp) (adj) (opp))
)

 Bruno   

[(gile)]

Ma réponse en LISP pour un angle strictement compris entre 0 et PI/2 utilise la trigonométrie (plutôt que Thales/Pythagore).

(defun trigones (alpha sinus cosinus secante cosecante tangente cotangente / asin acos compute)

  (defun asin (x) (atan x (sqrt (- 1 (* x x)))))

  (defun acos (x) (atan (sqrt (- 1. (* x x))) x))

  (defun compute (a)
    (list a
	  (setq sinus (sin a))
	  (setq cosinus (cos a))
	  (setq secante (/ 1. cosinus))
	  (setq cosecante (/ 1. sinus))
	  (* sinus secante)
	  (* cosinus cosecante)
    )
  )

  (cond
    ((and alpha (< 0. alpha (/ pi 2.)))
     (compute alpha)
    )
    ((and sinus (< 0. sinus 1.))
     (compute (asin sinus))
    )
    ((and cosinus (< 0. cosinus 1.))
     (compute (acos cosinus))
    )
    ((and secante (< 1. secante))
     (compute (acos (/ 1. secante)))
    )
    ((and cosecante (< 1. cosecante))
     (compute (asin (/ 1. cosecante)))
    )
    ((and tangente (< 0. tangente))
     (compute (atan tangente))
    )
    ((and cotangente (< 0. cotangente))
     (compute (atan (/ 1. cotangente)))
    )
  )
)

 

[(gile)]

Une version qui prend aussi en compte les angles 0 et PI/2.
Pour exprimer une valeur infinie, on utilise celle renvoyée pour la tangente de PI/2.
Cette version traite chaque cas indépendamment  pour éviter de recalculer la valeur entrée.

(setq *infini* (/ 1. (cos (/ pi 2.))))

(defun trigones (alpha sinus cosinus secante cosecante tangente cotangente)
  (cond
    (alpha
     (cond
       ((= alpha 0.) (list alpha 0. 1. 1. *infini* 0. *infini*))
       ((= alpha (/ pi 2.)) (list alpha 1. 0. *infini* 1. *infini* 0.))
       ((< 0. alpha (/ pi 2.))
	(setq sinus	 (sin alpha)
	      cosinus	 (cos alpha)
	      secante	 (/ 1. cosinus)
	      cosecante	 (/ 1. sinus)
	      tangente	 (* sinus secante)
	      cotangente (* cosinus cosecante)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (sinus
     (cond
       ((= sinus 0.)
	(list 0. sinus 1. 1. *infini* 0. *infini*)
       )
       ((= sinus 1.)
	(list (/ pi 2.) sinus 0. *infini* 1. *infini* 0.)
       )
       ((< 0 sinus 1)
	(setq cosinus	 (sqrt (- 1. (* sinus sinus)))
	      secante	 (/ 1. cosinus)
	      cosecante	 (/ 1. sinus)
	      tangente	 (* sinus secante)
	      cotangente (* cosinus cosecante)
	      alpha	 (atan tangente)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (cosinus
     (cond
       ((= cosinus 0.)
	(list (/ pi 2.) 1. cosinus *infini* 1. *infini* 0.)
       )
       ((= cosinus 1.)
	(list 0. 0. cosinus 1. *infini* 0. *infini*)
       )
       ((< 0 cosinus 1)
	(setq sinus	 (sqrt (- 1. (* cosinus cosinus)))
	      secante	 (/ 1. cosinus)
	      cosecante	 (/ 1. sinus)
	      tangente	 (* sinus secante)
	      cotangente (* cosinus cosecante)
	      alpha	 (atan tangente)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (secante
     (cond
       ((<= 1. secante)
	(setq cosinus	 (/ 1. secante)
	      sinus	 (sqrt (- 1. (* cosinus cosinus)))
	      cosecante	 (/ 1. sinus)
	      tangente	 (* sinus secante)
	      cotangente (* cosinus cosecante)
	      alpha	 (atan tangente)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (cosecante
     (cond
       ((<= 1. cosecante)
	(setq sinus    (/ 1. cosecante)
	      cosinus  (sqrt (- 1. (* sinus sinus)))
	      secante  (/ 1. cosinus)
	      tangente (* sinus secante)
	      cotangente (* cosinus cosecante)
	      alpha    (atan tangente)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (tangente
     (cond
       ((= tangente 0.)
	(list 0. 0. 1. 1. *infini* tangente *infini*)
       )
       ((< 0. tangente)
	(setq alpha	 (atan tangente)
	      sinus	 (sin alpha)
	      cosinus	 (cos alpha)
	      secante	 (/ 1. cosinus)
	      cosecante	 (/ 1. sinus)
	      cotangente (* cosinus cosecante)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
    (cotangente
     (cond
       ((= 0. cotangente)
	(list (/ pi 2.) 1. 0. *infini* 1. *infini* 0.)
       )
       ((< 0. cotangente)
	(setq alpha	(atan (/ 1. cotangente))
	      sinus	(sin alpha)
	      cosinus	(cos alpha)
	      secante	(/ 1. cosinus)
	      cosecante	(/ 1. sinus)
	      tangente	(* sinus secante)
	)
	(list alpha sinus cosinus secante cosecante tangente cotangente)
       )
     )
    )
  )
)

 

[VDH-Bruno]

Jolie,

Pour ta version 1, j'ai une version équivalente sauf que je me suis limité pour le jeu de ne pas écrire de fonction auxiliaire et à ne me servir que des fonctions natives en Autolisp.

Pour ta version 2, je vais étudié cela plus dans le détail quant je serais en meilleur forme, notamment comment fonctionne la façon dont tu exprime l'infini dans ton code, je vais surement apprendre quelque chose. Pour ce qui est d'éviter de recalculer la valeur en entré je m'étais essayé par le passé à écrire une fonction de "mémoïsation" (pas sur que ce soit le bon terme) à titre expérimental, impossible de retrouver mes codes pour les adapter à ce challenge, de toute façon les opérations étant limité le coût aurait été supérieur au gain.

La version codé sur le principe de la fonction TriangleRec donné précédemment avec les fonctions mathématiques native fournie en AutoLisp (atan sin / sqrt expt + -), contrairement aux tiennes je n'ai pas bordé les saisies, j'ai été au plus simple, l'idée était de montrer le procédé...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Trigones 1                                                        VDH-Bruno  ;;
;; ---------------------------------------------------------------------------- ;;
;; Algorithme: Chaques fontions est définie en fonction d'une autre de façon    ;;
;;             qu'elles soient toutes chainées de façon à créer une dépendance  ;;
;;             circulaire, de fait si une valeur est insérer dans la boucle de  ;;
;;             dépendance toutes les fonctions sont alors définie et leurs      ;;
;;             valeurs respective retournées                                    ;;
;; ---------------------------------------------------------------------------- ;;
;; Description: -> "lire dépend de"                                             ;;
;; (tang) -> (sec) -> (cosinus) -> (cot) -> (csc) -> (sinus) -> (ang) -> (tang) ;;
;; ---------------------------------------------------------------------------- ;;
;; Liste des fonctions:                                                         ;;
;;    - Angle (ang)                                                             ;;
;;    - Sinus (sinus)                                                           ;;
;;    - Cosinus (cosinus)                                                       ;;
;;    - Sécante (sec)                                                           ;;
;;    - Cosécante (csc)                                                         ;;
;;    - Tangente (tang)                                                         ;;
;;    - Cotangente (cot)                                                        ;;

(defun trigones1 (ang sinus cosinus sec csc tang cot)
    (mapcar
    '(lambda (val fun)
       (if val
	 (eval (list 'defun fun () val))
	 fun
       )
     )
    (list ang sinus cosinus sec csc tang cot)
    (list (defun ang () (atan (tang)))
	  (defun sinus () (sin (ang)))
	  (defun cosinus () (/ (cot) (sqrt (1+ (expt (cot) 2.)))))
	  (defun sec () (/ 1. (cosinus)))
	  (defun csc () (/ 1. (sinus)))
	  (defun tang () (sqrt (1- (expt (sec) 2.))))
	  (defun cot () (sqrt (1- (expt (csc) 2.))))
    )
  )
  (list (ang) (sinus) (cosinus) (sec) (csc) (tang) (cot))
)

 

[VDH-Bruno]

Bravo!!! Après quelques testes et une analyse sommaire, je dois avouer que ta fonction compute (écrite efficacement) donne un avantage certain, rendant mon code plus "bruyant" en comparaison, je me dis que j'aurais pu insisté un peu plus sur l'optimisation. 

[(gile)]

Il y a 1 heure, VDH-Bruno a dit :

ta fonction compute (écrite efficacement) donne un avantage certain

C'est là qu'on aurait aimé avoir une fonction let:

(defun compute (a)
    (let
      '((sinus (sin a)) (cosinus (cos a)))
      '(let
	'((secante (/ 1. cosinus)) (cosecante (/ 1. sinus)))
	'(let
	  '((tangente (* sinus secante)) (cotangente (* cosinus cosecante)))
	  '(list a sinus cosinus secante cosecante tangente cotangente)
	 )
       )
    )
  )

 

[(gile)]

@nazemrap

Poste ton code Ruby, c'est toujours intéressant de voir les langues étrangères qu'on ne connait pas.

[nazemrap]

Bonjour,

Bon, j'ai enlevé les fioritures d'interface pour faire simple.

			#recupere les données
			angle = (angle.to_f).degrees
			sinus = sinus.to_f
			cosinus =cosinus.to_f
			secante =secante.to_f
			cosecante =cosecante.to_f
			tangente =tangente.to_f
			cotangente = cotangente.to_f	
			
			# calcul de l'angle selon la donnée d'origine
			if cosecante !=0
				sinus=1/cosecante
			end			
			
			if sinus !=0
				angle=Math.asin(sinus)
			end
			
			if secante !=0
				cosinus=1/secante
			end
			
			if cosinus !=0
				angle=Math.acos(cosinus)
			end	
			
			if cotangente !=0
				tangente=1/cotangente
			end				
			
			if tangente !=0
				angle=Math.atan(tangente)
			end	

			# 
			if angle!=0
			sinus=Math.sin(angle)
			cosinus=Math.cos(angle)
			secante=1/cosinus
			cosecante=1/sinus
			tangente=Math.tan(angle)
			cotangente=1/tangente
			end

 

[(gile)]

Il y a 2 heures, VDH-Bruno a dit :

comment fonctionne la façon dont tu exprime l'infini dans ton code

Ça exploite la minime imprécision dans la valeur de PI/2 (nombre à virgule flottante à double précision).
Théoriquement le cosinus de PI/2 est égal à 0 et la tangente de PI/2 est l'infini, mais avec la façon dont sont encodés les nombres réels le cosinus de PI/2 est approximé à 6.12323e-17 (0.0000000000000000612323) et la tangente de PI/2 (soit 1.0 / cos(PI/2)) à 1.63312e+16 (16331239353195370.0).
C'est cette valeur qu j'ai choisi pour exprimer l'infini.

Nota : cette imprécision n'est pas propre au LISP, on peut la voir en F# par exemple en évaluant : trigones Angle (pi / 2.) ou trigones Sinus 1. dans la fenêtre de Try F#.

[VDH-Bruno]

Le 22/12/2021 à 14:10, (gile) a dit :

Ça exploite la minime imprécision dans la valeur de PI/2 (nombre à virgule flottante à double précision).

Bonjour,

J'avoue ne pas mettre libéré suffisamment de temps entre les fêtes de fin d'années pour regarder plus dans le détail cette question, mais je le ferais et je te remercie de ta réponse. J'ai tout de même trouvé quelques minutes pour le jeu et l'occasion de revisiter joyeusement ma trigo, pour réécrire une version qui n'utilise pas de fonction auxiliaire, ce n'est ni plus ni moins qu'une réécriture de vos versions.

;; Trigones 3                                                        VDH-Bruno  ;;
;; ---------------------------------------------------------------------------- ;;
;; Algorithme: Version basé sur les relations trigonométriques                  ;;
;;             Les arguments sont exprimés en fontion de la tangeante pour le   ;;
;;             calcule de la valeur angulaire                                   ;;
;; ---------------------------------------------------------------------------- ;;

(defun trigones3 (a sinus cosinus secante cosecante tangente cotangente)
  (if
    (setq a
	   (cond ((< 0. a (/ pi 2.)) a)
		 ((< 0. sinus 1.) (atan sinus (sqrt (- 1. (* sinus sinus)))))
		 ((< 0. cosinus 1.) (atan (sqrt (- 1. (* cosinus cosinus))) cosinus))
		 ((< 1. secante) (atan (sqrt (1- (* secante secante)))))
		 ((< 1. cosecante) (atan (/ 1. (sqrt (1- (* cosecante cosecante))))))
		 ((< 0. tangente) (atan tangente))
		 ((< 0. cotangente) (atan (/ 1. cotangente)))
	   )
    )
     (list a
	   (setq sinus (sin a))
	   (setq cosinus (cos a))
	   (/ 1 cosinus)
	   (/ 1 sinus)
	   (/ sinus cosinus)
	   (/ cosinus sinus)
     )
  )
)

@(gile)  Pour le retour, les and précédant les < dans le cond me semble superflue dans ta première version....