{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE Strict #-}
{-# LANGUAGE TypeFamilies #-}

module Graphics.Color.Space.DIN99
  ( pattern DIN99,
    pattern ColorDIN99,
    DIN99,
    deltaE,
  )
where

import Data.List.NonEmpty
import Foreign.Storable
import GHC.Generics (Generic)
import Graphics.Color.Model.Internal
import Graphics.Color.Space.Internal
import Graphics.Color.Space.CIE1976.LAB

data DIN99 (i :: k)

-- | Color in DIN99 color space
newtype instance Color (DIN99 i) e = DIN99 (V3 e)

pattern ColorDIN99 :: e -> e -> e -> Color (DIN99 i) e
pattern $mColorDIN99 :: forall {r} {k} {e} {i :: k}.
Color (DIN99 i) e -> (e -> e -> e -> r) -> ((# #) -> r) -> r
$bColorDIN99 :: forall {k} e (i :: k). e -> e -> e -> Color (DIN99 i) e
ColorDIN99 l' a' b' = DIN99 (V3 l' a' b')

{-# COMPLETE ColorDIN99 #-}

-- | `DIN99` color space
deriving instance Eq e => Eq (Color (DIN99 i) e)

-- | `DIN99` color space
deriving instance Ord e => Ord (Color (DIN99 i) e)

-- | `DIN99` color space
deriving instance Functor (Color (DIN99 i))

-- | `DIN99` color space
deriving instance Applicative (Color (DIN99 i))

-- | `DIN99` color space
deriving instance Foldable (Color (DIN99 i))

-- | `DIN99` color space
deriving instance Traversable (Color (DIN99 i))

-- | `DIN99` color space
deriving instance Storable e => Storable (Color (DIN99 i) e)

-- | `DIN99` color space
instance (Illuminant i, Elevator e) => Show (Color (DIN99 i) e) where
  showsPrec :: Int -> Color (DIN99 i) e -> ShowS
showsPrec Int
_ = Color (DIN99 i) e -> ShowS
forall cs e. ColorModel cs e => Color cs e -> ShowS
showsColorModel

instance (Illuminant i, Elevator e) => ColorModel (DIN99 i) e where
  type Components (DIN99 i) e = (e, e, e)
  type ChannelCount (DIN99 i) = 3
  channelCount :: Proxy (Color (DIN99 i) e) -> Word8
channelCount Proxy (Color (DIN99 i) e)
_ = Word8
3
  {-# INLINE channelCount #-}
  channelNames :: Proxy (Color (DIN99 i) e) -> NonEmpty String
channelNames Proxy (Color (DIN99 i) e)
_ = String
"L*" String -> [String] -> NonEmpty String
forall a. a -> [a] -> NonEmpty a
:| [String
"a*", String
"b*"] -- DIN99 is base on Lab color space
  channelColors :: Proxy (Color (DIN99 i) e) -> NonEmpty (V3 Word8)
channelColors Proxy (Color (DIN99 i) e)
_ = Word8 -> Word8 -> Word8 -> V3 Word8
forall a. a -> a -> a -> V3 a
V3 Word8
0x80 Word8
0x80 Word8
0x80 V3 Word8 -> [V3 Word8] -> NonEmpty (V3 Word8)
forall a. a -> [a] -> NonEmpty a
:| -- gray
                  [ Word8 -> Word8 -> Word8 -> V3 Word8
forall a. a -> a -> a -> V3 a
V3 Word8
0x00 Word8
0x64 Word8
0x00    -- dark green
                  , Word8 -> Word8 -> Word8 -> V3 Word8
forall a. a -> a -> a -> V3 a
V3 Word8
0x00 Word8
0x00 Word8
0x8b    -- dark blue
                  ]
  toComponents :: Color (DIN99 i) e -> Components (DIN99 i) e
toComponents (ColorDIN99 e
l' e
a' e
b') = (e
l', e
a', e
b')
  {-# INLINE toComponents #-}
  fromComponents :: Components (DIN99 i) e -> Color (DIN99 i) e
fromComponents (e
l', e
a', e
b') = e -> e -> e -> Color (DIN99 i) e
forall {k} e (i :: k). e -> e -> e -> Color (DIN99 i) e
ColorDIN99 e
l' e
a' e
b'
  {-# INLINE fromComponents #-}

instance (Illuminant i, Elevator e, RealFloat e) => ColorSpace (DIN99 (i :: k)) i e where
  type BaseModel (DIN99 i) = DIN99 i
  type BaseSpace (DIN99 i) = DIN99 i
  toBaseSpace :: ColorSpace (BaseSpace (DIN99 i)) i e =>
Color (DIN99 i) e -> Color (BaseSpace (DIN99 i)) e
toBaseSpace = Color (DIN99 i) e -> Color (BaseSpace (DIN99 i)) e
Color (DIN99 i) e -> Color (DIN99 i) e
forall a. a -> a
id
  {-# INLINE toBaseSpace #-}
  fromBaseSpace :: ColorSpace (BaseSpace (DIN99 i)) i e =>
Color (BaseSpace (DIN99 i)) e -> Color (DIN99 i) e
fromBaseSpace = Color (BaseSpace (DIN99 i)) e -> Color (DIN99 i) e
Color (DIN99 i) e -> Color (DIN99 i) e
forall a. a -> a
id
  {-# INLINE fromBaseSpace #-}
  luminance :: forall a.
(Elevator a, RealFloat a) =>
Color (DIN99 i) e -> Color (Y i) a
luminance = Color (LAB i) e -> Color (Y i) a
forall a.
(Elevator a, RealFloat a) =>
Color (LAB i) e -> Color (Y i) a
forall k cs (i :: k) e a.
(ColorSpace cs i e, Elevator a, RealFloat a) =>
Color cs e -> Color (Y i) a
luminance (Color (LAB i) e -> Color (Y i) a)
-> (Color (DIN99 i) e -> Color (LAB i) e)
-> Color (DIN99 i) e
-> Color (Y i) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DINMethod -> Color (DIN99 i) e -> Color (LAB i) e
forall {k} e (i :: k).
RealFloat e =>
DINMethod -> Color (DIN99 i) e -> Color (LAB i) e
dinToLAB DINMethod
DIN99Method
  {-# INLINE luminance #-}
  grayscale :: Color (DIN99 i) e -> Color X e
grayscale (ColorDIN99 e
l' e
_ e
_) = e -> Color X e
forall e. e -> Color X e
X e
l'
  {-# INLINE grayscale #-}
  replaceGrayscale :: Color (DIN99 i) e -> Color X e -> Color (DIN99 i) e
replaceGrayscale (ColorDIN99 e
_ e
a' e
b') (X e
l') = e -> e -> e -> Color (DIN99 i) e
forall {k} e (i :: k). e -> e -> e -> Color (DIN99 i) e
ColorDIN99 e
l' e
a' e
b'
  {-# INLINE replaceGrayscale #-}
  toColorXYZ :: forall a.
(Elevator a, RealFloat a) =>
Color (DIN99 i) e -> Color (XYZ i) a
toColorXYZ = Color (LAB i) e -> Color (XYZ i) a
forall a.
(Elevator a, RealFloat a) =>
Color (LAB i) e -> Color (XYZ i) a
forall k cs (i :: k) e a.
(ColorSpace cs i e, Elevator a, RealFloat a) =>
Color cs e -> Color (XYZ i) a
toColorXYZ (Color (LAB i) e -> Color (XYZ i) a)
-> (Color (DIN99 i) e -> Color (LAB i) e)
-> Color (DIN99 i) e
-> Color (XYZ i) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DINMethod -> Color (DIN99 i) e -> Color (LAB i) e
forall {k} e (i :: k).
RealFloat e =>
DINMethod -> Color (DIN99 i) e -> Color (LAB i) e
dinToLAB DINMethod
DIN99Method
  {-# INLINE toColorXYZ #-}
  fromColorXYZ :: forall a.
(Elevator a, RealFloat a) =>
Color (XYZ i) a -> Color (DIN99 i) e
fromColorXYZ = DINMethod -> Color (LAB i) e -> Color (DIN99 i) e
forall {k} e (i :: k).
RealFloat e =>
DINMethod -> Color (LAB i) e -> Color (DIN99 i) e
labToDIN DINMethod
DIN99Method (Color (LAB i) e -> Color (DIN99 i) e)
-> (Color (XYZ i) a -> Color (LAB i) e)
-> Color (XYZ i) a
-> Color (DIN99 i) e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Color (XYZ i) a -> Color (LAB i) e
forall a.
(Elevator a, RealFloat a) =>
Color (XYZ i) a -> Color (LAB i) e
forall k cs (i :: k) e a.
(ColorSpace cs i e, Elevator a, RealFloat a) =>
Color (XYZ i) a -> Color cs e
fromColorXYZ
  {-# INLINE fromColorXYZ #-}

kE :: RealFloat a => a
kE :: forall a. RealFloat a => a
kE = a
1

kCH :: RealFloat a => a
kCH :: forall a. RealFloat a => a
kCH = a
1

data DINMethod
  = ASTMD2244_07Method
  | DIN99Method
  | DIN99bMethod
  | DIN99cMethod
  | DIN99dMethod
  deriving (DINMethod -> DINMethod -> Bool
(DINMethod -> DINMethod -> Bool)
-> (DINMethod -> DINMethod -> Bool) -> Eq DINMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DINMethod -> DINMethod -> Bool
== :: DINMethod -> DINMethod -> Bool
$c/= :: DINMethod -> DINMethod -> Bool
/= :: DINMethod -> DINMethod -> Bool
Eq, Int -> DINMethod -> ShowS
[DINMethod] -> ShowS
DINMethod -> String
(Int -> DINMethod -> ShowS)
-> (DINMethod -> String)
-> ([DINMethod] -> ShowS)
-> Show DINMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DINMethod -> ShowS
showsPrec :: Int -> DINMethod -> ShowS
$cshow :: DINMethod -> String
show :: DINMethod -> String
$cshowList :: [DINMethod] -> ShowS
showList :: [DINMethod] -> ShowS
Show, ReadPrec [DINMethod]
ReadPrec DINMethod
Int -> ReadS DINMethod
ReadS [DINMethod]
(Int -> ReadS DINMethod)
-> ReadS [DINMethod]
-> ReadPrec DINMethod
-> ReadPrec [DINMethod]
-> Read DINMethod
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DINMethod
readsPrec :: Int -> ReadS DINMethod
$creadList :: ReadS [DINMethod]
readList :: ReadS [DINMethod]
$creadPrec :: ReadPrec DINMethod
readPrec :: ReadPrec DINMethod
$creadListPrec :: ReadPrec [DINMethod]
readListPrec :: ReadPrec [DINMethod]
Read, Eq DINMethod
Eq DINMethod =>
(DINMethod -> DINMethod -> Ordering)
-> (DINMethod -> DINMethod -> Bool)
-> (DINMethod -> DINMethod -> Bool)
-> (DINMethod -> DINMethod -> Bool)
-> (DINMethod -> DINMethod -> Bool)
-> (DINMethod -> DINMethod -> DINMethod)
-> (DINMethod -> DINMethod -> DINMethod)
-> Ord DINMethod
DINMethod -> DINMethod -> Bool
DINMethod -> DINMethod -> Ordering
DINMethod -> DINMethod -> DINMethod
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DINMethod -> DINMethod -> Ordering
compare :: DINMethod -> DINMethod -> Ordering
$c< :: DINMethod -> DINMethod -> Bool
< :: DINMethod -> DINMethod -> Bool
$c<= :: DINMethod -> DINMethod -> Bool
<= :: DINMethod -> DINMethod -> Bool
$c> :: DINMethod -> DINMethod -> Bool
> :: DINMethod -> DINMethod -> Bool
$c>= :: DINMethod -> DINMethod -> Bool
>= :: DINMethod -> DINMethod -> Bool
$cmax :: DINMethod -> DINMethod -> DINMethod
max :: DINMethod -> DINMethod -> DINMethod
$cmin :: DINMethod -> DINMethod -> DINMethod
min :: DINMethod -> DINMethod -> DINMethod
Ord, DINMethod
DINMethod -> DINMethod -> Bounded DINMethod
forall a. a -> a -> Bounded a
$cminBound :: DINMethod
minBound :: DINMethod
$cmaxBound :: DINMethod
maxBound :: DINMethod
Bounded, Int -> DINMethod
DINMethod -> Int
DINMethod -> [DINMethod]
DINMethod -> DINMethod
DINMethod -> DINMethod -> [DINMethod]
DINMethod -> DINMethod -> DINMethod -> [DINMethod]
(DINMethod -> DINMethod)
-> (DINMethod -> DINMethod)
-> (Int -> DINMethod)
-> (DINMethod -> Int)
-> (DINMethod -> [DINMethod])
-> (DINMethod -> DINMethod -> [DINMethod])
-> (DINMethod -> DINMethod -> [DINMethod])
-> (DINMethod -> DINMethod -> DINMethod -> [DINMethod])
-> Enum DINMethod
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DINMethod -> DINMethod
succ :: DINMethod -> DINMethod
$cpred :: DINMethod -> DINMethod
pred :: DINMethod -> DINMethod
$ctoEnum :: Int -> DINMethod
toEnum :: Int -> DINMethod
$cfromEnum :: DINMethod -> Int
fromEnum :: DINMethod -> Int
$cenumFrom :: DINMethod -> [DINMethod]
enumFrom :: DINMethod -> [DINMethod]
$cenumFromThen :: DINMethod -> DINMethod -> [DINMethod]
enumFromThen :: DINMethod -> DINMethod -> [DINMethod]
$cenumFromTo :: DINMethod -> DINMethod -> [DINMethod]
enumFromTo :: DINMethod -> DINMethod -> [DINMethod]
$cenumFromThenTo :: DINMethod -> DINMethod -> DINMethod -> [DINMethod]
enumFromThenTo :: DINMethod -> DINMethod -> DINMethod -> [DINMethod]
Enum, (forall x. DINMethod -> Rep DINMethod x)
-> (forall x. Rep DINMethod x -> DINMethod) -> Generic DINMethod
forall x. Rep DINMethod x -> DINMethod
forall x. DINMethod -> Rep DINMethod x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DINMethod -> Rep DINMethod x
from :: forall x. DINMethod -> Rep DINMethod x
$cto :: forall x. Rep DINMethod x -> DINMethod
to :: forall x. Rep DINMethod x -> DINMethod
Generic)

fromDINMethod ::
  ( Fractional a,
    Fractional b,
    Fractional c,
    Fractional d,
    Fractional f,
    Fractional g,
    Fractional h,
    Fractional e
  ) =>
  DINMethod ->
  (a, b, c, d, e, f, g, h)
fromDINMethod :: forall a b c d f g h e.
(Fractional a, Fractional b, Fractional c, Fractional d,
 Fractional f, Fractional g, Fractional h, Fractional e) =>
DINMethod -> (a, b, c, d, e, f, g, h)
fromDINMethod DINMethod
ASTMD2244_07Method =
  (a
105.509, b
0.0158, c
16.0, d
0.7, e
1, f
9 f -> f -> f
forall a. Fractional a => a -> a -> a
/ f
200, g
0.0, h
9 h -> h -> h
forall a. Fractional a => a -> a -> a
/ h
200)
fromDINMethod DINMethod
DIN99Method = (a
105.509, b
0.0158, c
16.0, d
0.7, e
1, f
9 f -> f -> f
forall a. Fractional a => a -> a -> a
/ f
200, g
0.0, h
9 h -> h -> h
forall a. Fractional a => a -> a -> a
/ h
200)
fromDINMethod DINMethod
DIN99bMethod = (a
303.67, b
0.0039, c
26.0, d
0.83, e
23.0, f
0.075, g
26.0, h
1)
fromDINMethod DINMethod
DIN99cMethod = (a
317.65, b
0.0037, c
0.0, d
0.94, e
23.0, f
0.066, g
0.0, h
1)
fromDINMethod DINMethod
DIN99dMethod = (a
325.22, b
0.0036, c
50.0, d
1.14, e
22.5, f
0.06, g
50.0, h
1)

radians :: Floating a => a -> a
radians :: forall a. Floating a => a -> a
radians a
x = a
forall a. Floating a => a
pi a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
180 a -> a -> a
forall a. Num a => a -> a -> a
* a
x

-- | deltaE distance in DIN99 is the perceptually-uniform distance between
-- two points in the space. Otherwise known as euclidean distance.
deltaE ::
  (Floating e, Illuminant i, Elevator e) =>
  Color (LAB i) e ->
  Color (LAB i) e ->
  e
deltaE :: forall {k} e (i :: k).
(Floating e, Illuminant i, Elevator e) =>
Color (LAB i) e -> Color (LAB i) e -> e
deltaE Color (LAB i) e
a Color (LAB i) e
b = e -> e
forall a. Floating a => a -> a
sqrt (e -> e) -> e -> e
forall a b. (a -> b) -> a -> b
$ Color (LAB i) e -> e
forall a. Num a => Color (LAB i) a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ((Color (LAB i) e
a Color (LAB i) e -> Color (LAB i) e -> Color (LAB i) e
forall a. Num a => a -> a -> a
- Color (LAB i) e
b) Color (LAB i) e -> Color (LAB i) e -> Color (LAB i) e
forall a. Floating a => a -> a -> a
** Color (LAB i) e
2)

-- | Bidirectional @DIN99@ @DIN99@ conversion as implemented in Python
-- [colour](https://github.com/colour-science/colour/blob/c3735e5d0ad67443022ece0b42b575e040eb61d1/colour/models/din99.py#L79) package.
--
-- >>> import Graphics.Color.Illuminant.Wikipedia as W
-- >>> labToDIN DIN99Method (ColorLAB 41.527874 52.638584 26.92318 :: Color (LAB 'W.D65) Float)
-- <DIN99 Degree2 'D65:(53.22821400,28.41634600, 3.89839500)>
-- >>> dinToLAB DIN99Method (ColorDIN99 53.228218 28.416348 3.8983955 :: Color (DIN99 'W.D65) Float)
-- <LAB Degree2 'D65:(41.52787800,52.63859000,26.92318300)>
labToDIN ::
  (RealFloat e) =>
  DINMethod ->
  Color (LAB i) e ->
  Color (DIN99 i) e
labToDIN :: forall {k} e (i :: k).
RealFloat e =>
DINMethod -> Color (LAB i) e -> Color (DIN99 i) e
labToDIN DINMethod
m (ColorLAB e
l e
a e
b) = e -> e -> e -> Color (DIN99 i) e
forall {k} e (i :: k). e -> e -> e -> Color (DIN99 i) e
ColorDIN99 e
l_99 e
a_99 e
b_99
  where
    cos_c :: e
cos_c = e -> e
forall a. Floating a => a -> a
cos (e -> e) -> e -> e
forall a b. (a -> b) -> a -> b
$ e -> e
forall a. Floating a => a -> a
radians e
c_3
    sin_c :: e
sin_c = e -> e
forall a. Floating a => a -> a
sin (e -> e) -> e -> e
forall a b. (a -> b) -> a -> b
$ e -> e
forall a. Floating a => a -> a
radians e
c_3
    e :: e
e = e
cos_c e -> e -> e
forall a. Num a => a -> a -> a
* e
a e -> e -> e
forall a. Num a => a -> a -> a
+ e
sin_c e -> e -> e
forall a. Num a => a -> a -> a
* e
b
    f :: e
f = e
c_4 e -> e -> e
forall a. Num a => a -> a -> a
* (- e
sin_c e -> e -> e
forall a. Num a => a -> a -> a
* e
a e -> e -> e
forall a. Num a => a -> a -> a
+ e
cos_c e -> e -> e
forall a. Num a => a -> a -> a
* e
b)
    g' :: e
g' = e -> e
forall a. Floating a => a -> a
sqrt (e
e e -> e -> e
forall a. Floating a => a -> a -> a
** e
2 e -> e -> e
forall a. Num a => a -> a -> a
+ e
f e -> e -> e
forall a. Floating a => a -> a -> a
** e
2)
    h_ef :: e
h_ef = e -> e -> e
forall a. RealFloat a => a -> a -> a
atan2 e
f e
e e -> e -> e
forall a. Num a => a -> a -> a
+ e -> e
forall a. Floating a => a -> a
radians e
c_7
    c_99 :: e
c_99 = e
c_5 e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
log (e
1 e -> e -> e
forall a. Num a => a -> a -> a
+ e
c_6 e -> e -> e
forall a. Num a => a -> a -> a
* e
g') e -> e -> e
forall a. Fractional a => a -> a -> a
/ (e
c_8 e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kCH e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kE)
    a_99 :: e
a_99 = e
c_99 e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
cos e
h_ef
    b_99 :: e
b_99 = e
c_99 e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
sin e
h_ef
    l_99 :: e
l_99 = e
c_1 e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
log (e
1 e -> e -> e
forall a. Num a => a -> a -> a
+ e
c_2 e -> e -> e
forall a. Num a => a -> a -> a
* e
l) e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kE
    (e
c_1, e
c_2, e
c_3, e
c_4, e
c_5, e
c_6, e
c_7, e
c_8) = DINMethod -> (e, e, e, e, e, e, e, e)
forall a b c d f g h e.
(Fractional a, Fractional b, Fractional c, Fractional d,
 Fractional f, Fractional g, Fractional h, Fractional e) =>
DINMethod -> (a, b, c, d, e, f, g, h)
fromDINMethod DINMethod
m

dinToLAB ::
  RealFloat e =>
  DINMethod ->
  Color (DIN99 i) e ->
  Color (LAB i) e
dinToLAB :: forall {k} e (i :: k).
RealFloat e =>
DINMethod -> Color (DIN99 i) e -> Color (LAB i) e
dinToLAB DINMethod
m (ColorDIN99 e
l_99 e
a_99 e
b_99) = e -> e -> e -> Color (LAB i) e
forall {k} e (i :: k). e -> e -> e -> Color (LAB i) e
ColorLAB e
l e
a e
b
  where
    expm1 :: a -> a
expm1 a
x = a -> a
forall a. Floating a => a -> a
exp a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
1
    cos' :: e
cos' = e -> e
forall a. Floating a => a -> a
cos (e -> e
forall a. Floating a => a -> a
radians e
c_3)
    sin' :: e
sin' = e -> e
forall a. Floating a => a -> a
sin (e -> e
forall a. Floating a => a -> a
radians e
c_3)

    h_99 :: e
h_99 = e -> e -> e
forall a. RealFloat a => a -> a -> a
atan2 e
b_99 e
a_99 e -> e -> e
forall a. Num a => a -> a -> a
- e -> e
forall a. Floating a => a -> a
radians e
c_7

    c_99 :: e
c_99 = e -> e
forall a. Floating a => a -> a
sqrt (e
a_99 e -> e -> e
forall a. Floating a => a -> a -> a
** e
2 e -> e -> e
forall a. Num a => a -> a -> a
+ e
b_99 e -> e -> e
forall a. Floating a => a -> a -> a
** e
2)
    g' :: e
g' = e -> e
forall a. Floating a => a -> a
expm1 (e
c_8 e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_5 e -> e -> e
forall a. Num a => a -> a -> a
* e
c_99 e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kCH e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kE) e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_6

    e :: e
e = e
g' e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
cos e
h_99
    f :: e
f = e
g' e -> e -> e
forall a. Num a => a -> a -> a
* e -> e
forall a. Floating a => a -> a
sin e
h_99

    a :: e
a = e
e e -> e -> e
forall a. Num a => a -> a -> a
* e
cos' e -> e -> e
forall a. Num a => a -> a -> a
- e
f e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_4 e -> e -> e
forall a. Num a => a -> a -> a
* e
sin'
    b :: e
b = e
e e -> e -> e
forall a. Num a => a -> a -> a
* e
sin' e -> e -> e
forall a. Num a => a -> a -> a
+ e
f e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_4 e -> e -> e
forall a. Num a => a -> a -> a
* e
cos'
    l :: e
l = e -> e
forall a. Floating a => a -> a
expm1 (e
l_99 e -> e -> e
forall a. Num a => a -> a -> a
* e
forall a. RealFloat a => a
kE e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_1) e -> e -> e
forall a. Fractional a => a -> a -> a
/ e
c_2
    (e
c_1, e
c_2, e
c_3, e
c_4, e
c_5, e
c_6, e
c_7, e
c_8) = DINMethod -> (e, e, e, e, e, e, e, e)
forall a b c d f g h e.
(Fractional a, Fractional b, Fractional c, Fractional d,
 Fractional f, Fractional g, Fractional h, Fractional e) =>
DINMethod -> (a, b, c, d, e, f, g, h)
fromDINMethod DINMethod
m