segment .data
segment .text
  global __maths_abs
  global __maths_mod
  
  global __maths_sin
  global __maths_cos
  global __maths_tan
  
  ; p-e faux a la fin pour les fx trig hyperboliques
  global __maths_sinh  ; sh(x) = (exp(x) - exp(-x)) / 2
  global __maths_cosh  ; ch(x) = (exp(x) + exp(-x)) / 2
  global __maths_tanh  ; th(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))

  ; asin et acos a verifier 
  global __maths_asin
  global __maths_acos
  global __maths_atan
  global __maths_atan2

  ; devrais être OK pour les log
  global __maths_ln
  global __maths_log
  
  global __maths_sqrt

; double _maths_abs(double x)
__maths_abs:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ;
  fld     qword [ebp+8]     ; Stack : x
  fabs                      ; Stack : -x
  pop     ebp				; 
ret 0

; double _maths_mod(double x, double y)
__maths_mod:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ;
  fld     qword [ebp+16]    ; x
  fld     qword [ebp+8]     ; y
L00:
  fprem                     ; Reste de la division (partiel)
  fstsw   ax                ; Etat de la FPU
  test    ax, 0400h         ; mod fini?
jnz     L00
  fstp    st1

  pop     ebp				; 
ret 0

__maths_sin:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ; 
  sub     esp, 8            ; Alloue un double (le x en argument)
  fld     qword [ebp+8]     ; Stack : x
  fsin                      ; Stack : sin(x)
  mov     esp, ebp		    ; Désalloue le double
  pop     ebp				; 
ret 0

; double _maths_cos( double x)
__maths_cos:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ; 
  sub     esp, 8            ; Alloue un double (le x en argument)
  fld     qword [ebp+8]     ; Stack : x
  fcos                      ; Stack : cos(x)
  mov     esp, ebp		    ; Désalloue le double
  pop     ebp				; 
ret 0

; double _maths_tan( double x)
__maths_tan:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp 
  sub     esp, 8            ; Alloue un double (le x en argument)
  fld     qword [ebp+8]     ; Stack : x
  fptan                     ; Stack : tan(x)
  mov     esp, ebp		    ; Désalloue le double
  pop     ebp 
ret 0

; double _maths_sinh( double x) // Rem : ln2(x) : Logarithme base 2 de x 
__maths_sinh:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp 
  sub     esp, 8            ; Alloc x
  
  fld     qword [ebp+8]     ; Stack : x
  fchs                      ; Stack : -x
  
  fldl2e                    ; ln2(e) / -x
  fmulp   st1, st0          ; x*ln2(e)
  fst     st1               ; copie dans st1
  frndint                   ; arrondi st0
  fsub    st1, st0          ; st1 = st1 - st0 
  fxch                      ; st0 = st1 et st1 = st0
  f2xm1 
  fld1 
  fadd    st0 
  fscale                    ; pow2
  fstp    st1               ; push st1
  
  fstp    qword [ebp-8]     ; Sauvegarde exp(-x)
  fld     qword [ebp+8]     ; Recharge x
  
  fldl2e                    ; Même chose qu'avant mais avec x
  fmulp   st1, st0          ; au lieu de -x
  fst     st1 
  frndint 
  fsub    st1, st0 
  fxch 
  f2xm1 
  fld1 
  fadd    st0 
  fscale 
  fstp    st1               ; exp(-x) => st1
  
  fld     qword [ebp-8]     ; exp(x)  => st0
  fsub    st1               ; exp(x) - exp(-x) => st0
  fld1                      ; 1 => st0 / st1
  fld1                      ; 1 => st0 / st1 / st2
  faddp   st1               ; 1 + 1 => 2       st0 / st1
  fdivp   st1               ; sinh = [exp(x) - exp(-x)] / 2
  
  mov     esp, ebp          ; fini!! (ouf :p)
  pop     ebp
ret

; double _maths_cosh( double x) 
__maths_cosh:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ; 
  sub     esp, 8            ; Alloc x

  fld     qword [ebp+8]     ; Stack : x
  fchs                      ; Stack : -x
  
  fldl2e                    ; ln2(e) / -x
  fmulp   st1, st0          ; x*ln2(e)
  fst     st1               ; copie dans st1
  frndint                   ; arrondi st0
  fsub    st1, st0          ; st1 = st1 - st0 
  fxch                      ; st0 = st1 et st1 = st0
  f2xm1 
  fld1 
  fadd    st0 
  fscale                    ; pow2
  fstp    st1               ; push st1
  
  fstp    qword [ebp-8]     ; Sauvegarde exp(-x)
  fld     qword [ebp+8]     ; Recharge x
  
  fldl2e                    ; Même chose qu'avant mais avec x
  fmulp   st1, st0          ; au lieu de -x
  fst     st1
  frndint 
  fsub    st1, st0 
  fxch
  f2xm1
  fld1
  fadd    st0
  fscale
  fstp    st1               ; exp(-x) => st1
  
  fld     qword [ebp-8]     ; exp(x)  => st0
  fadd    st1               ; exp(x) + exp(-x) => st0
  fld1                      ; 1 => st0 / st1
  fld1                      ; 1 => st0 / st1 / st2
  faddp   st1               ; 1 + 1 => 2       st0 / st1
  fdivp   st1               ; cosh = [exp(x) + exp(-x)] : 2
  
  mov     esp, ebp 
  pop     ebp
ret

; double _maths_tanh( double x) 
__maths_tanh:
  push    ebp               ; Sauvegarde ebp
  mov     ebp, esp          ; 
  
  fld     qword [ebp+8]     ; x
  fld     st0               ; x / x
  fadd    st1               ; 2x / x
  fldl2e                    ; ln2(e) / 2x / x 
  fmulp   st1, st0          ; x * ln2(e) / x
  fst     st1               ; x * ln2(e) / x * ln2(e) 
  frndint                   ; (int)x * ln2(e) / x * ln2(e)
  fsub    st1, st0          ; x * ln2(e) - (int)x * ln2(e) / x * ln2(e)
  fxch                      ; x * ln2(e) / x * ln2(e) - (int)x * ln2(e)
  f2xm1                     ; 2^(x-1)
  fld1
  fadd    st1               ; 2 ^ x
  fscale                    ; ^ 2 
  fstp    st1
  fld1
  fadd    st1               ; exp(2*x)+1
  fld1
  fld1
  faddp   st1               ; 1 + 1 => 2
  fdivr   st1               ; 2/(exp(2*x)+1)
  fld1
  fsubr   st1               ; tanh
  
  pop     ebp
ret

; double _maths_asin(double x)
__maths_asin:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]     ; x
  fld     st0               ; x / x
  fld     st0               ; x / x / x
  fmul    st0               ; x² / x / x
  fld1                      ; 1 / x² / x / x
  fsubr   st1               ; 1 - x² / x / x
  fsqrt                     ; sqrt(1 - x²) / x / x
  fpatan                    ; asin
  
  pop     ebp
ret

; double _maths_acos(double x)
__maths_acos:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]     ; x
  fld     st0               ; x / x
  fld     st0               ; x / x / x
  fmul    st1               ; x² / x / x
  fld1                      ; 1 / x² / x / x
  fsubr   st1               ; 1 - x² / x / x
  fsqrt                     ; sqrt(1 - x²) / x / x
  fxch                      ; swap(st0, st1)
  fpatan                    ; acos
  
  pop     ebp
ret

; double _maths_atan(double x)
__maths_atan:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]     ; x
  fld1                      ; 1
  fpatan                    ; atan
  
  pop     ebp
ret

; double _maths_atan(double x, double y)
__maths_atan2:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]     ; a1
  fld     qword [ebp+16]    ; a2
  fpatan                    ; atan
  
  mov     esp,ebp
  pop     ebp
ret

; double _maths_exp(double x)
__maths_exp:
  push    ebp
  mov     ebp,esp
  sub     esp,8
  
  fld     qword [ebp+8]
  fldl2e  
  fmulp   st1, st0
  fst     st1
  frndint 
  fsub    st1, st0
  fxch    
  f2xm1   
  fld1    
  fadd    st1
  fscale
  fstp    st1
  fst     qword [ebp-8]
  
  mov     esp,ebp
  pop     ebp
ret

; double _maths_ln(double x)
__maths_ln:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]
  fldln2             
  fxch    st1
  fyl2x   

  pop     ebp
ret

; double _maths_log(double x)
__maths_log:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]
  fldlg2  
  fxch    st0
  fyl2x

  pop     ebp
ret

; double _maths_sqrt(double x)  -- Square root
__maths_sqrt:
  push    ebp
  mov     ebp,esp
  
  fld     qword [ebp+8]
  fsqrt

  pop     ebp
ret

; @EOF