Data/Floating/Types/CMath.hs

   1 {-
   2  - Copyright (C) 2010 Nick Bowler.
   3  -
   4  - License BSD2:  2-clause BSD license.  See LICENSE for full terms.
   5  - This is free software: you are free to change and redistribute it.
   6  - There is NO WARRANTY, to the extent permitted by law.
   7  -}
   8
   9 -- | Class instances for 'CFloat' and 'CDouble'.  As it is elsewhere in the
  10 -- library, it is assumed that 'CFloat' is identical to 'Float' and 'CDouble'
  11 -- is identical to 'Double'.
  12 module Data.Floating.Types.CMath where
  13
  14 import Prelude (($), (.), const, undefined)
  15 import Data.Floating.Types.Double
  16 import Data.Floating.Types.Float
  17 import Data.Floating.Types.Core
  18 import Foreign.C
  19
  20 import Data.Poset
  21
  22 doubleLibm :: (Double -> Double) -> CDouble -> CDouble
  23 doubleLibm f a = toFloating $ f (toFloating a)
  24
  25 floatLibm :: (Float -> Float) -> CFloat -> CFloat
  26 floatLibm f a = toFloating $ f (toFloating a)
  27
  28 doubleLibm2 :: (Double -> Double -> Double) -> CDouble -> CDouble -> CDouble
  29 doubleLibm2 f a b = toFloating $ f (toFloating a) (toFloating b)
  30
  31 floatLibm2 :: (Float -> Float -> Float) -> CFloat -> CFloat -> CFloat
  32 floatLibm2 f a b = toFloating $ f (toFloating a) (toFloating b)
  33
  34 doubleLibm3 :: (Double -> Double -> Double -> Double)
  35     -> CDouble -> CDouble -> CDouble -> CDouble
  36 doubleLibm3 f a b c = toFloating
  37     $ f (toFloating a) (toFloating b) (toFloating c)
  38
  39 floatLibm3 :: (Float -> Float -> Float -> Float)
  40     -> CFloat -> CFloat -> CFloat -> CFloat
  41 floatLibm3 f a b c = toFloating
  42     $ f (toFloating a) (toFloating b) (toFloating c)
  43
  44 instance Floating CDouble where
  45     (**)  = doubleLibm2 (**)
  46     sqrt  = doubleLibm sqrt
  47     acos  = doubleLibm acos
  48     asin  = doubleLibm asin
  49     atan  = doubleLibm atan
  50     cos   = doubleLibm cos
  51     sin   = doubleLibm sin
  52     tan   = doubleLibm tan
  53     acosh = doubleLibm acosh
  54     asinh = doubleLibm asinh
  55     atanh = doubleLibm atanh
  56     cosh  = doubleLibm cosh
  57     sinh  = doubleLibm sinh
  58     tanh  = doubleLibm tanh
  59     exp   = doubleLibm exp
  60     log   = doubleLibm log
  61
  62 instance Floating CFloat where
  63     (**)  = floatLibm2 (**)
  64     sqrt  = floatLibm sqrt
  65     acos  = floatLibm acos
  66     asin  = floatLibm asin
  67     atan  = floatLibm atan
  68     cos   = floatLibm cos
  69     sin   = floatLibm sin
  70     tan   = floatLibm tan
  71     acosh = floatLibm acosh
  72     asinh = floatLibm asinh
  73     atanh = floatLibm atanh
  74     cosh  = floatLibm cosh
  75     sinh  = floatLibm sinh
  76     tanh  = floatLibm tanh
  77     exp   = floatLibm exp
  78     log   = floatLibm log
  79
  80 instance RealFloat CDouble where
  81     fma       = doubleLibm3 fma
  82     copysign  = doubleLibm2 copysign
  83     nextafter = doubleLibm2 nextafter
  84     atan2     = doubleLibm2 atan2
  85     fmod      = doubleLibm2 fmod
  86     frem      = doubleLibm2 frem
  87     hypot     = doubleLibm2 hypot
  88     cbrt      = doubleLibm cbrt
  89     exp2      = doubleLibm exp2
  90     expm1     = doubleLibm expm1
  91     log10     = doubleLibm log10
  92     log1p     = doubleLibm log1p
  93     log2      = doubleLibm log2
  94     erf       = doubleLibm erf
  95     erfc      = doubleLibm erfc
  96     gamma     = doubleLibm gamma
  97     lgamma    = doubleLibm lgamma
  98     rint      = doubleLibm rint
  99     nearbyint = doubleLibm nearbyint
 100
 101 instance RealFloat CFloat where
 102     fma       = floatLibm3 fma
 103     copysign  = floatLibm2 copysign
 104     nextafter = floatLibm2 nextafter
 105     atan2     = floatLibm2 atan2
 106     fmod      = floatLibm2 fmod
 107     frem      = floatLibm2 frem
 108     hypot     = floatLibm2 hypot
 109     cbrt      = floatLibm cbrt
 110     exp2      = floatLibm exp2
 111     expm1     = floatLibm expm1
 112     log10     = floatLibm log10
 113     log1p     = floatLibm log1p
 114     log2      = floatLibm log2
 115     erf       = floatLibm erf
 116     erfc      = floatLibm erfc
 117     gamma     = floatLibm gamma
 118     lgamma    = floatLibm lgamma
 119     rint      = floatLibm rint
 120     nearbyint = floatLibm nearbyint
 121
 122 instance Poset CDouble where
 123     compare x y = compare (toFloating x :: Double) (toFloating y :: Double)
 124     x <==> y    = (toFloating x :: Double) <==> (toFloating y :: Double)
 125     x </=> y    = (toFloating x :: Double) </=> (toFloating y :: Double)
 126     x  <   y    = (toFloating x :: Double)  <   (toFloating y :: Double)
 127     x  <=  y    = (toFloating x :: Double)  <=  (toFloating y :: Double)
 128     x  >=  y    = (toFloating x :: Double)  >=  (toFloating y :: Double)
 129     x  >   y    = (toFloating x :: Double)  >   (toFloating y :: Double)
 130
 131 instance Poset CFloat where
 132     compare x y = compare (toFloating x :: Float) (toFloating y :: Float)
 133     x <==> y    = (toFloating x :: Float) <==> (toFloating y :: Float)
 134     x </=> y    = (toFloating x :: Float) </=> (toFloating y :: Float)
 135     x  <   y    = (toFloating x :: Float)  <   (toFloating y :: Float)
 136     x  <=  y    = (toFloating x :: Float)  <=  (toFloating y :: Float)
 137     x  >=  y    = (toFloating x :: Float)  >=  (toFloating y :: Float)
 138     x  >   y    = (toFloating x :: Float)  >   (toFloating y :: Float)
 139
 140 instance Sortable CDouble where
 141     isOrdered x = isOrdered (toFloating x :: Double)
 142     max = doubleLibm2 max
 143     min = doubleLibm2 min
 144
 145 instance Sortable CFloat where
 146     isOrdered x = isOrdered (toFloating x :: Float)
 147     max = floatLibm2 max
 148     min = floatLibm2 min
 149
 150 instance Roundable CDouble where
 151     toIntegral x = toIntegral (toFloating x :: Double)
 152     ceiling      = doubleLibm ceiling
 153     floor        = doubleLibm floor
 154     truncate     = doubleLibm truncate
 155     round        = doubleLibm round
 156
 157 instance Roundable CFloat where
 158     toIntegral x = toIntegral (toFloating x :: Float)
 159     ceiling      = floatLibm ceiling
 160     floor        = floatLibm floor
 161     truncate     = floatLibm truncate
 162     round        = floatLibm round
 163
 164 instance PrimFloat CDouble where
 165     floatRadix     = const $ floatRadix (undefined :: Double)
 166     floatPrecision = const $ floatPrecision (undefined :: Double)
 167     floatRange     = const $ floatRange (undefined :: Double)
 168     classify t     = classify (toFloating t :: Double)
 169     logb           = doubleLibm logb
 170     scalb x        = toFloating . scalb (toFloating x :: Double)
 171
 172 instance PrimFloat CFloat where
 173     floatRadix     = const $ floatRadix (undefined :: Float)
 174     floatPrecision = const $ floatPrecision (undefined :: Float)
 175     floatRange     = const $ floatRange (undefined :: Float)
 176     classify t     = classify (toFloating t :: Float)
 177     logb           = floatLibm logb
 178     scalb x        = toFloating . scalb (toFloating x :: Float)