Trigo et degrés

Dr. Dri · Message par **Dr. Dri** » lun. 06/févr./2006 17:39

Guimauve a écrit :Moi ça m'énerve de savoir que je calculs des angles en radians, je fais une conversion en degré, passe l'information au moteur 3D, qui lui refait la conversion en radian et finalement fait les calculs qu'on lui demande.

Je me tue à dire depuis le début qu'avec un tel système si on est en radian la conversion n'a pas lieu, pas de perte de précision, à la rigueur une petite opération supplémentaire (carrément négligeable)

Dri -_-²

Guimauve · Message par **Guimauve** » mar. 07/févr./2006 0:14

Message supprimé

Dr. Dri · Message par **Dr. Dri** » mar. 07/févr./2006 9:56

Guimauve a écrit :Est-ce que tu as déja entendu parler des cosinus directeurs et la manière des calculer ? À mon avis non.

Pour faire court -> oui

Guimauve a écrit :Est-ce que tu sais comment sont calculer les transformations 3D ? À mon avis ça non plus.

Je m'abstiendrai de répondre

Guimauve a écrit :Ma question est : Comment va-t'on faire pour dire aux fonction Sin() et Cos() que leurs input est en degré et que leurs output doivent être en radian ?

Là je vais répondre. Ou plutôt je vais essayer de te réexpliquer le fonctionnement. Parce que tout ce que je vois, c'est que t'a l'air de t'en foutre royalement. T'as l'air buté et bloqué sur ton "JE VEUX PAS DE DEGRES ALORS QUE JE SUIS TRES BIEN AVEC MES RADIANS"

Premièrement si t'avais lu ce que je suggères, tu saurais que ce n'est pas un passage aux degrés mais des conversions automatiques. Certes je demande les degrés par défaut, et c'est pas parce que mon niveau en maths n'est pas suffisament élevé pour comprendre l'intérêt des radians mais pour aller dans la logique de simplicité du PureBasic.

Deuxièmement, pour avoir en input et en output l'unité de son choix, bah y'a rien de plus facile... Suffit de choisir avec SetMathAngles()

Troisièmement, je vais coder un exemple de conversion automatiques (le système auquel je pense) et poster ca dans la foulée.

Dri

Dr. Dri · Message par **Dr. Dri** » mar. 07/févr./2006 10:00

Voila un code que tu devrais lire attentivement... A défaut de lire le reste du topic <_<

Code : Tout sélectionner

;constantes plubliques, celles qu'on utilise pour changer les angles
Enumeration
  #PB_Math_Rad
  #PB_Math_Deg
  #PB_Math_Grd
EndEnumeration

;faut considérer que ce sont des constantes (privées)
;j'avais envie d'avoir une précision au moins .f
;donc pour l'exemple je déclare en global
Global Pi.f, _PB_Coeff_Rad.f, _PB_Coeff_Deg.f, _PB_Coeff_Grd.f

Pi = ATan(1) * 4

_PB_Coeff_Rad = 1.0
_PB_Coeff_Deg = Pi / 180
_PB_Coeff_Grd = Pi / 200

;variables privées de la lib
;(récupérables via l'asm en ligne ?)
Global _PB_Math_Angles.l, _PB_Math_Coeff.f
_PB_Math_Angles = #PB_Math_Deg
_PB_Math_Coeff  = _PB_Coeff_Deg

;procédures de gestion des angles
Procedure.l SetMathAngles(Type.l)
  Protected Error.l
  
  Select Type
    Case #PB_Math_Rad
      _PB_Math_Coeff = _PB_Coeff_Rad
    Case #PB_Math_Deg
      _PB_Math_Coeff = _PB_Coeff_Deg
    Case #PB_Math_Grd
      _PB_Math_Coeff = _PB_Coeff_Grd
    Default
      Error = #True
  EndSelect
  
  If Error = #False
    _PB_Math_Angles = Type
  EndIf
  
  ProcedureReturn Error ! #True ;retourne 'Not Error'
EndProcedure

Procedure.l GetMathAngles()
  ProcedureReturn _PB_Math_Angles
EndProcedure

;procédures de conversion
Procedure.f Rad(Angle.f)
  If _PB_Math_Angles <> #PB_Math_Rad
    Angle * (_PB_Math_Coeff / _PB_Coeff_Rad) ;la division peut facilement être zappée
  EndIf
  
  ProcedureReturn Angle
EndProcedure

Procedure.f Deg(Angle.f)
  If _PB_Math_Angles <> #PB_Math_Deg
    Angle * (_PB_Math_Coeff / _PB_Coeff_Deg)
  EndIf
  
  ProcedureReturn Angle
EndProcedure

Procedure.f Grd(Angle.f)
  If _PB_Math_Angles <> #PB_Math_Grd
    Angle * (_PB_Math_Coeff / _PB_Coeff_Grd)
  EndIf
  
  ProcedureReturn Angle
EndProcedure

;procédures de trigo
Procedure.f Cos_(Angle.f)
  If _PB_Math_Angles <> #PB_Math_Rad ;si les angles sont en radians, ca ajoute juste un test
    Angle * (_PB_Math_Coeff / _PB_Coeff_Rad) ;la division peut facilement être zappée
  EndIf
  
  ProcedureReturn Cos(Angle)
EndProcedure

Procedure.f ACos_(Cos.f)
  Protected Angle.f
  
  Angle = ACos(Cos)
  
  If _PB_Math_Angles <> #PB_Math_Rad
    Angle / (_PB_Math_Coeff / _PB_Coeff_Rad)
  EndIf
  
  ProcedureReturn Angle
EndProcedure

;test spécial Guimauve, le but est de retomber sur le cosinus de départ
cosinus.f = 3/5 ; -1 <= cosinus <= 1

Debug "cosinus pour le test"
Debug cosinus

Debug "en radians (angle puis cosinus)"
SetMathAngles(#PB_Math_Rad)
Debug ACos_(cosinus)
Debug Cos_( ACos_(cosinus) )

Debug "en degrés (angle puis cosinus)"
SetMathAngles(#PB_Math_Deg)
Debug ACos_(cosinus)
Debug Cos_( ACos_(cosinus) )

Debug "en grades (angle puis cosinus)"
SetMathAngles(#PB_Math_Grd)
Debug ACos_(cosinus)
Debug Cos_( ACos_(cosinus) )

Dri -_-

Guimauve · Message par **Guimauve** » mar. 07/févr./2006 18:49

Message supprimé

Heis Spiter · Message par **Heis Spiter** » mar. 07/févr./2006 19:49

Faut être honnête Guimauve, t'es un peu coincé quand même. On te fais des concessions, et tu restes bloqué sur ta position

....

Dr. Dri · Message par **Dr. Dri** » mar. 07/févr./2006 20:10

Ce ne sont même pas des concessions, depuis le début mon idée est de ne surtout pas diminuer la précision ou vitesse des fonctions de trigo. Après je sais que je m'expime mal, j'ai l'habitude d'être compris de travers et de devoir me justifier (à force je me justifie pour tout et n'importe quoi

)

Après s'il n'est pas satisfait une fois qu'il a toutes les informations en sa possession, c'est autre chose... L'idée de la lib a déjà été proposée. La version 4 n'étant même pas sortie (on a juste une bêta) on ne sait pas encore comment faire des subsystems. Quand aux bons en maths qui font les frais des moins bons, bah je (re)dirais que les degrés par défaut n'ont rien d'indispensable étant donné que la conversion est le principal sujet.

Dri

Flype · Message par **Flype** » mar. 07/févr./2006 22:41

Une autre solution pourrait etre un fichier include 'degre.pb' dans lequel il y aurait une grosse macro bien construite.
Et là aucun ralentissement ou autre querelle en tout genre.

Bon sinon je voudrais pas m'en prendre plein la tronche comme Dr Dri

, mais il faut quand reconnaitre un truc, en france en tout cas (ailleurs je sais pas) :
demandez à votre femme, votre petite soeur, ou votre pote jardinier s'il sait calculer en radian. Il va vous dire : En quoooiiii ? Par contre vous lui demander après quel angle çà fait 90°. Là il saura répondre.

Bref, le radian c'est super, pour les pros, les matheux et pour les programmeurs, et à ce titre personne içi ne dit le contraire.
Mais pour ceux qui ont envie de programmer un truc pèpère sans se prendre la tête, le degré reste dans ma tête à moi (et ma chérie aussi alors hein) le plus naturel.

Ce n'est qu'une opinion, vous pouvez même détruire ce message après.
ah non çà ya que moi qui peut le faire

Guimauve · Message par **Guimauve** » mar. 07/févr./2006 23:07

Message supprimé

Backup · Message par **Backup** » mar. 07/févr./2006 23:47

les matheux on surement besoin du radian

pas les programeurs de jeux ou d'utilitaires (sauf exeption)
dans les jeux 2D,3D , les softs de 3D (Maya,3dsmax,Neon,LightWaves,ect ..tous ce qui concerne les reperes dans l'espace 3D)
on parle en Degres pas en Radian, meme si ça t'emmerde , c'est ainsi !

Frenchy Pilou · Message par **Frenchy Pilou** » mer. 08/févr./2006 0:23

Et le grade, il se sent orphelin, le petit dernier

Guimauve · Message par **Guimauve** » mer. 08/févr./2006 4:15

Message supprimé

cederavic · Message par **cederavic** » mer. 08/févr./2006 8:25

Je suis un peut de l'avi de Guimauve, le system du SetMathAngles reste à evité car ça ajoute des condition même si on veut rester au radians. Vous me direz un IF c'est rien, mais prenon un moteur 3D temp reel, ça va faire autant de IF que de vertices rien que pour la projection, alors si en plus de ça on ajoute les rotation etc... et pir encor un moteur physic, ça va en faire un paquet (des milliers par boucles) de IF juste pour un SetMathAngle

Parcontre ce qu'il pourait etre interressant c'est que toute les commandes soient en radians et qu'il y ai un parametre optionnel comme #PB_Math_Degre et #PB_Math_Grade qui serait simplement des facteur rad -> deg et rad -> grade. Comme ça plus de IF et la commade Cos ressemblerais a ça :

Code : Tout sélectionner

Procedure.f Cos(Angle.f[, Mode.f])
  ProcedureReturn RealCos(Angle * Mode)
EndProcedure

PS : meme si je ne suis pas d'accord avec le fait de mettre tout en degre, je cherche quand meme une solution pour ceux qui veulent avoir les degré, alors tapez pas sur la tete svp

Backup · Message par **Backup** » mer. 08/févr./2006 10:45

Tu me dis que les calculs doivent obligatoirement être en degré pour que ça marche ?

je vois la que tu n'as pas compris ma demande

je vais etre clair sur ce que je demande

on ne touche pas au RADIANTs (j'ai jamais voulu les virers !!

)

on ajoute un system qui permet d'avoir les resultats en degres !

le system proposé par Cederavic , m'irai bien,
juste la possibilité d'avoir une fonction ou un parametre qui permette
d'avoir les resultats en Grad, Degres, ou Radian
(que les fonction marche en Radiant a la base , je m'en fout

)

pour faire un paralelle , tu peut actuellement avoir les resultat de tes calcul en binaire (octal ?) , et hexadecimal, ou decimal

je demande la meme chose pour les calcul d'angle ...

c'est pourtant pas compliquer a comprendre !

d'ailleur ce peut etre des fonctions suplementaire

genre :

x=degres(y) , considerant que y est TOUJOUR en radian par defaut .....
dans ce cas x aura la convertion en degres de y qui est en radian

on pourrai donc avoir

x=Grad(y) ; transforme y(radian) en x(grad)

tt=Radian(x) ; transforme x(grad) en tt(radian)

ect ....

je vois pas en quoi ça va te gener ça ?

ou bien la methode a Cederavic

Dr. Dri · Message par **Dr. Dri** » mer. 08/févr./2006 12:59

Bon pour une énième fois, t'es encore à côté du sujet. Quand tu dis que "si les fonctions trigonométriques sont en mode degré, le résultat va ètre erroné" t'as encore tout faux. Le test d'au dessus ne t'as pas suffit ?

Aussi quand tu es "outré de ce qui se passe en arrière plan" t'as encore tout faux. Ce n'est absolument pas ce qui se passe. Changer les angles a chaque fois est la simple preuve que t'as rien compris à la proposition. SetMathAngles est prévu pour changer les angles une seule fois voir plusieurs selon utilisation.

Actuellement les fonctions d'ogre et le RotateSprite3D sont en degrés, chose qui me dérange un peu. Parce que c'est en contradiction avec les fonctions de trigo. J'aimerais aussi que ce genre de fonctions utilise les angles selon le mode en cours. Ca rendrait tout homogène et tout paramétrable, et ca n'est pas faisable avec une lib...

Pour la proposition de cederavic, je ne suis pas du tout d'accord, ca revient à l'utilisation que Guimauve pense de mon système, à savoir changer le mode à chaque fois. Encore une fois le système que je propose ne fait le gros du travail que dans SetMathAngles et prend ainsi un minimum de resources et un amximum de précision dans les fonctions de trigo! En radians ca n'ajoute qu'un test, qui ne prend pas plus de temps que le passage sur la pile de l'angle par exemple.

Maintenant si tu refuses une proposition parce que une de tes astuces n'a pas a eu de succès, j'ai besoin de connaître le rapport... Réglement de compte ? A court d'arguments ? (qui de toute facon sont toujours à côté du sujet)

Dri -_-