{-# LANGUAGE CPP #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

-- |
-- Module    :  Numeric.InfBackprop.Instances.NumHask
-- Copyright   :  (C) 2025 Alexey Tochin
-- License     :  BSD3 (see the file LICENSE)
-- Maintainer  :  Alexey Tochin <Alexey.Tochin@gmail.com>
--
-- Orphane instances for
-- [numhask](https://hackage.haskell.org/package/numhask)
-- typeclasses.
module Numeric.InfBackprop.Instances.NumHask () where

{- HLINT ignore "Use fewer imports" -}

import Control.Applicative (liftA2)
import Data.Bifunctor (bimap)
import qualified Data.Stream as DS
import qualified Data.Vector.Generic as DVG
import qualified Data.Vector.Generic.Sized as DVGS
import GHC.Base (Functor (fmap), Maybe (Just))
import GHC.TypeNats (KnownNat)
import NumHask
  ( Additive,
    Divisive,
    ExpField,
    Multiplicative,
    Subtractive,
    TrigField,
    acos,
    acosh,
    asin,
    asinh,
    atan,
    atan2,
    atanh,
    cos,
    cosh,
    exp,
    log,
    logBase,
    negate,
    one,
    pi,
    recip,
    sin,
    sinh,
    sqrt,
    tan,
    tanh,
    zero,
    (*),
    (**),
    (+),
    (-),
    (/),
  )
import Numeric.InfBackprop.Utils.Tuple (biCross, biCross3, cross, cross3)

-- | Instances for NumHask classes for common data types.
-- These instances follow the standard lifting of operations to container types.
--
-- Note: These are orphan instances. Consider proposing them upstream to numhask.

-- | Tuple instance of `Additive` typecalss.
instance
  (Additive a0, Additive a1) =>
  Additive (a0, a1)
  where
  zero :: (a0, a1)
zero = (a0
forall a. Additive a => a
zero, a1
forall a. Additive a => a
zero)
  + :: (a0, a1) -> (a0, a1) -> (a0, a1)
(+) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1) -> (a0, a1) -> (a0, a1) -> (a0, a1)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a0 -> a0 -> a0
forall a. Additive a => a -> a -> a
(+) a1 -> a1 -> a1
forall a. Additive a => a -> a -> a
(+)

-- | Tuple instance of `Subtractive` typeclass.
instance
  (Subtractive a0, Subtractive a1) =>
  Subtractive (a0, a1)
  where
  negate :: (a0, a1) -> (a0, a1)
negate (a0
x0, a1
x1) = (a0 -> a0
forall a. Subtractive a => a -> a
negate a0
x0, a1 -> a1
forall a. Subtractive a => a -> a
negate a1
x1)
  (-) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1) -> (a0, a1) -> (a0, a1) -> (a0, a1)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross (-) (-)

-- | Tuple instance of `Multiplicative` typeclass.
instance
  (Multiplicative a0, Multiplicative a1) =>
  Multiplicative (a0, a1)
  where
  one :: (a0, a1)
one = (a0
forall a. Multiplicative a => a
one, a1
forall a. Multiplicative a => a
one)
  * :: (a0, a1) -> (a0, a1) -> (a0, a1)
(*) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1) -> (a0, a1) -> (a0, a1) -> (a0, a1)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a0 -> a0 -> a0
forall a. Multiplicative a => a -> a -> a
(*) a1 -> a1 -> a1
forall a. Multiplicative a => a -> a -> a
(*)

-- | Tuple instance of `Divisive` typeclass.
instance
  (Divisive a0, Divisive a1) =>
  Divisive (a0, a1)
  where
  recip :: (a0, a1) -> (a0, a1)
recip = (a0 -> a0) -> (a1 -> a1) -> (a0, a1) -> (a0, a1)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
cross a0 -> a0
forall a. Divisive a => a -> a
recip a1 -> a1
forall a. Divisive a => a -> a
recip
  / :: (a0, a1) -> (a0, a1) -> (a0, a1)
(/) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1) -> (a0, a1) -> (a0, a1) -> (a0, a1)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a0 -> a0 -> a0
forall a. Divisive a => a -> a -> a
(/) a1 -> a1 -> a1
forall a. Divisive a => a -> a -> a
(/)

-- | Tuple instance of `ExpField` typeclass.
instance
  (ExpField a, ExpField b) =>
  ExpField (a, b)
  where
  exp :: (a, b) -> (a, b)
exp = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. ExpField a => a -> a
exp b -> b
forall a. ExpField a => a -> a
exp
  log :: (a, b) -> (a, b)
log = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. ExpField a => a -> a
log b -> b
forall a. ExpField a => a -> a
log
  ** :: (a, b) -> (a, b) -> (a, b)
(**) = (a -> a -> a) -> (b -> b -> b) -> (a, b) -> (a, b) -> (a, b)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a -> a -> a
forall a. ExpField a => a -> a -> a
(**) b -> b -> b
forall a. ExpField a => a -> a -> a
(**)
  logBase :: (a, b) -> (a, b) -> (a, b)
logBase = (a -> a -> a) -> (b -> b -> b) -> (a, b) -> (a, b) -> (a, b)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a -> a -> a
forall a. ExpField a => a -> a -> a
logBase b -> b -> b
forall a. ExpField a => a -> a -> a
logBase
  sqrt :: (a, b) -> (a, b)
sqrt = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. ExpField a => a -> a
sqrt b -> b
forall a. ExpField a => a -> a
sqrt

-- | Tuple instance of `TrigField` typeclass.
instance
  (TrigField a, TrigField b) =>
  TrigField (a, b)
  where
  -- Constants
  pi :: (a, b)
pi = (a
forall a. TrigField a => a
pi, b
forall a. TrigField a => a
pi)

  -- Basic trig functions
  sin :: (a, b) -> (a, b)
sin = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
sin b -> b
forall a. TrigField a => a -> a
sin
  cos :: (a, b) -> (a, b)
cos = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
cos b -> b
forall a. TrigField a => a -> a
cos
  tan :: (a, b) -> (a, b)
tan = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
tan b -> b
forall a. TrigField a => a -> a
tan

  -- Inverse trig functions
  asin :: (a, b) -> (a, b)
asin = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
asin b -> b
forall a. TrigField a => a -> a
asin
  acos :: (a, b) -> (a, b)
acos = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
acos b -> b
forall a. TrigField a => a -> a
acos
  atan :: (a, b) -> (a, b)
atan = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
atan b -> b
forall a. TrigField a => a -> a
atan
  atan2 :: (a, b) -> (a, b) -> (a, b)
atan2 = (a -> a -> a) -> (b -> b -> b) -> (a, b) -> (a, b) -> (a, b)
forall a b c d e f.
(a -> b -> c) -> (d -> e -> f) -> (a, d) -> (b, e) -> (c, f)
biCross a -> a -> a
forall a. TrigField a => a -> a -> a
atan2 b -> b -> b
forall a. TrigField a => a -> a -> a
atan2

  -- Hyperbolic functions
  sinh :: (a, b) -> (a, b)
sinh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
sinh b -> b
forall a. TrigField a => a -> a
sinh
  cosh :: (a, b) -> (a, b)
cosh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
cosh b -> b
forall a. TrigField a => a -> a
cosh
  tanh :: (a, b) -> (a, b)
tanh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
tanh b -> b
forall a. TrigField a => a -> a
tanh

  -- Inverse hyperbolic functions
  asinh :: (a, b) -> (a, b)
asinh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
asinh b -> b
forall a. TrigField a => a -> a
asinh
  acosh :: (a, b) -> (a, b)
acosh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
acosh b -> b
forall a. TrigField a => a -> a
acosh
  atanh :: (a, b) -> (a, b)
atanh = (a -> a) -> (b -> b) -> (a, b) -> (a, b)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap a -> a
forall a. TrigField a => a -> a
atanh b -> b
forall a. TrigField a => a -> a
atanh

-- | Triple instance of `Additive`.
instance
  (Additive a0, Additive a1, Additive a2) =>
  Additive (a0, a1, a2)
  where
  zero :: (a0, a1, a2)
zero = (a0
forall a. Additive a => a
zero, a1
forall a. Additive a => a
zero, a2
forall a. Additive a => a
zero)
  + :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)
(+) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a0 -> a0 -> a0
forall a. Additive a => a -> a -> a
(+) a1 -> a1 -> a1
forall a. Additive a => a -> a -> a
(+) a2 -> a2 -> a2
forall a. Additive a => a -> a -> a
(+)

-- | Triple instance of `Subtractive`.
instance
  (Subtractive a0, Subtractive a1, Subtractive a2) =>
  Subtractive (a0, a1, a2)
  where
  negate :: (a0, a1, a2) -> (a0, a1, a2)
negate (a0
x0, a1
x1, a2
x2) = (a0 -> a0
forall a. Subtractive a => a -> a
negate a0
x0, a1 -> a1
forall a. Subtractive a => a -> a
negate a1
x1, a2 -> a2
forall a. Subtractive a => a -> a
negate a2
x2)
  (-) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 (-) (-) (-)

-- | Triple instance of `Multiplicative` typeclass.
instance
  (Multiplicative a0, Multiplicative a1, Multiplicative a2) =>
  Multiplicative (a0, a1, a2)
  where
  one :: (a0, a1, a2)
one = (a0
forall a. Multiplicative a => a
one, a1
forall a. Multiplicative a => a
one, a2
forall a. Multiplicative a => a
one)
  * :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)
(*) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a0 -> a0 -> a0
forall a. Multiplicative a => a -> a -> a
(*) a1 -> a1 -> a1
forall a. Multiplicative a => a -> a -> a
(*) a2 -> a2 -> a2
forall a. Multiplicative a => a -> a -> a
(*)

-- | Triple instance of `Divisive` typeclass.
instance
  (Divisive a0, Divisive a1, Divisive a2) =>
  Divisive (a0, a1, a2)
  where
  recip :: (a0, a1, a2) -> (a0, a1, a2)
recip = (a0 -> a0)
-> (a1 -> a1) -> (a2 -> a2) -> (a0, a1, a2) -> (a0, a1, a2)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a0 -> a0
forall a. Divisive a => a -> a
recip a1 -> a1
forall a. Divisive a => a -> a
recip a2 -> a2
forall a. Divisive a => a -> a
recip
  / :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)
(/) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a0 -> a0 -> a0
forall a. Divisive a => a -> a -> a
(/) a1 -> a1 -> a1
forall a. Divisive a => a -> a -> a
(/) a2 -> a2 -> a2
forall a. Divisive a => a -> a -> a
(/)

-- | Triple instance of `ExpField`.
instance
  (ExpField a0, ExpField a1, ExpField a2) =>
  ExpField (a0, a1, a2)
  where
  exp :: (a0, a1, a2) -> (a0, a1, a2)
exp = (a0 -> a0)
-> (a1 -> a1) -> (a2 -> a2) -> (a0, a1, a2) -> (a0, a1, a2)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a0 -> a0
forall a. ExpField a => a -> a
exp a1 -> a1
forall a. ExpField a => a -> a
exp a2 -> a2
forall a. ExpField a => a -> a
exp
  log :: (a0, a1, a2) -> (a0, a1, a2)
log = (a0 -> a0)
-> (a1 -> a1) -> (a2 -> a2) -> (a0, a1, a2) -> (a0, a1, a2)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a0 -> a0
forall a. ExpField a => a -> a
log a1 -> a1
forall a. ExpField a => a -> a
log a2 -> a2
forall a. ExpField a => a -> a
log
  ** :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)
(**) = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a0 -> a0 -> a0
forall a. ExpField a => a -> a -> a
(**) a1 -> a1 -> a1
forall a. ExpField a => a -> a -> a
(**) a2 -> a2 -> a2
forall a. ExpField a => a -> a -> a
(**)
  logBase :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)
logBase = (a0 -> a0 -> a0)
-> (a1 -> a1 -> a1)
-> (a2 -> a2 -> a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
-> (a0, a1, a2)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a0 -> a0 -> a0
forall a. ExpField a => a -> a -> a
logBase a1 -> a1 -> a1
forall a. ExpField a => a -> a -> a
logBase a2 -> a2 -> a2
forall a. ExpField a => a -> a -> a
logBase
  sqrt :: (a0, a1, a2) -> (a0, a1, a2)
sqrt = (a0 -> a0)
-> (a1 -> a1) -> (a2 -> a2) -> (a0, a1, a2) -> (a0, a1, a2)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a0 -> a0
forall a. ExpField a => a -> a
sqrt a1 -> a1
forall a. ExpField a => a -> a
sqrt a2 -> a2
forall a. ExpField a => a -> a
sqrt

-- | Triple instance of `TrigField`.
instance
  (TrigField a, TrigField b, TrigField c) =>
  TrigField (a, b, c)
  where
  -- Constants
  pi :: (a, b, c)
pi = (a
forall a. TrigField a => a
pi, b
forall a. TrigField a => a
pi, c
forall a. TrigField a => a
pi)

  -- Basic trig functions
  sin :: (a, b, c) -> (a, b, c)
sin = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
sin b -> b
forall a. TrigField a => a -> a
sin c -> c
forall a. TrigField a => a -> a
sin
  cos :: (a, b, c) -> (a, b, c)
cos = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
cos b -> b
forall a. TrigField a => a -> a
cos c -> c
forall a. TrigField a => a -> a
cos
  tan :: (a, b, c) -> (a, b, c)
tan = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
tan b -> b
forall a. TrigField a => a -> a
tan c -> c
forall a. TrigField a => a -> a
tan

  -- Inverse trig functions
  asin :: (a, b, c) -> (a, b, c)
asin = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
asin b -> b
forall a. TrigField a => a -> a
asin c -> c
forall a. TrigField a => a -> a
asin
  acos :: (a, b, c) -> (a, b, c)
acos = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
acos b -> b
forall a. TrigField a => a -> a
acos c -> c
forall a. TrigField a => a -> a
acos
  atan :: (a, b, c) -> (a, b, c)
atan = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
atan b -> b
forall a. TrigField a => a -> a
atan c -> c
forall a. TrigField a => a -> a
atan
  atan2 :: (a, b, c) -> (a, b, c) -> (a, b, c)
atan2 = (a -> a -> a)
-> (b -> b -> b)
-> (c -> c -> c)
-> (a, b, c)
-> (a, b, c)
-> (a, b, c)
forall a b c d e f g h l.
(a -> b -> c)
-> (d -> e -> f)
-> (g -> h -> l)
-> (a, d, g)
-> (b, e, h)
-> (c, f, l)
biCross3 a -> a -> a
forall a. TrigField a => a -> a -> a
atan2 b -> b -> b
forall a. TrigField a => a -> a -> a
atan2 c -> c -> c
forall a. TrigField a => a -> a -> a
atan2

  -- Hyperbolic functions
  sinh :: (a, b, c) -> (a, b, c)
sinh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
sinh b -> b
forall a. TrigField a => a -> a
sinh c -> c
forall a. TrigField a => a -> a
sinh
  cosh :: (a, b, c) -> (a, b, c)
cosh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
cosh b -> b
forall a. TrigField a => a -> a
cosh c -> c
forall a. TrigField a => a -> a
cosh
  tanh :: (a, b, c) -> (a, b, c)
tanh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
tanh b -> b
forall a. TrigField a => a -> a
tanh c -> c
forall a. TrigField a => a -> a
tanh

  -- Inverse hyperbolic functions
  asinh :: (a, b, c) -> (a, b, c)
asinh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
asinh b -> b
forall a. TrigField a => a -> a
asinh c -> c
forall a. TrigField a => a -> a
asinh
  acosh :: (a, b, c) -> (a, b, c)
acosh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
acosh b -> b
forall a. TrigField a => a -> a
acosh c -> c
forall a. TrigField a => a -> a
acosh
  atanh :: (a, b, c) -> (a, b, c)
atanh = (a -> a) -> (b -> b) -> (c -> c) -> (a, b, c) -> (a, b, c)
forall a0 b0 a1 b1 a2 b2.
(a0 -> b0)
-> (a1 -> b1) -> (a2 -> b2) -> (a0, a1, a2) -> (b0, b1, b2)
cross3 a -> a
forall a. TrigField a => a -> a
atanh b -> b
forall a. TrigField a => a -> a
atanh c -> c
forall a. TrigField a => a -> a
atanh

-- | Sized Vector instance of `Additive` typeclass.
instance
  (KnownNat n, Additive a, DVG.Vector v a) =>
  Additive (DVGS.Vector v n a)
  where
  zero :: Vector v n a
zero = a -> Vector v n a
forall (v :: * -> *) (n :: Nat) a.
(KnownNat n, Vector v a) =>
a -> Vector v n a
DVGS.replicate a
forall a. Additive a => a
zero
  + :: Vector v n a -> Vector v n a -> Vector v n a
(+) = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. Additive a => a -> a -> a
(+)

-- | Sized Vector instance of `Subtractive` typeclass.
instance
  (KnownNat n, Subtractive a, DVG.Vector v a) =>
  Subtractive (DVGS.Vector v n a)
  where
  negate :: Vector v n a -> Vector v n a
negate = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. Additive a => a
zero
  (-) = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith (-)

-- | Sized Vector instance of `Multiplicative` typeclass.
instance
  (KnownNat n, Multiplicative a, DVG.Vector v a) =>
  Multiplicative (DVGS.Vector v n a)
  where
  one :: Vector v n a
one = a -> Vector v n a
forall (v :: * -> *) (n :: Nat) a.
(KnownNat n, Vector v a) =>
a -> Vector v n a
DVGS.replicate a
forall a. Multiplicative a => a
one
  * :: Vector v n a -> Vector v n a -> Vector v n a
(*) = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. Multiplicative a => a -> a -> a
(*)

-- | Sized Vector instance of `Divisive` typeclass.
instance
  (KnownNat n, Divisive a, DVG.Vector v a) =>
  Divisive (DVGS.Vector v n a)
  where
  / :: Vector v n a -> Vector v n a -> Vector v n a
(/) = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. Divisive a => a -> a -> a
(/)

-- | Sized Vector instance of `ExpField` typeclass.
instance
  (KnownNat n, ExpField a, DVG.Vector v a) =>
  ExpField (DVGS.Vector v n a)
  where
  exp :: Vector v n a -> Vector v n a
exp = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. ExpField a => a -> a
exp
  log :: Vector v n a -> Vector v n a
log = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. ExpField a => a -> a
log
  ** :: Vector v n a -> Vector v n a -> Vector v n a
(**) = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. ExpField a => a -> a -> a
(**)
  logBase :: Vector v n a -> Vector v n a -> Vector v n a
logBase = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. ExpField a => a -> a -> a
logBase
  sqrt :: Vector v n a -> Vector v n a
sqrt = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. ExpField a => a -> a
sqrt

-- | Sized Vector instance of `TrigField` typeclass.
instance
  (KnownNat n, TrigField a, DVG.Vector v a) =>
  TrigField (DVGS.Vector v n a)
  where
  -- Constants
  pi :: Vector v n a
pi = a -> Vector v n a
forall (v :: * -> *) (n :: Nat) a.
(KnownNat n, Vector v a) =>
a -> Vector v n a
DVGS.replicate a
forall a. TrigField a => a
pi

  -- Basic trig functions
  sin :: Vector v n a -> Vector v n a
sin = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
sin
  cos :: Vector v n a -> Vector v n a
cos = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
cos
  tan :: Vector v n a -> Vector v n a
tan = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
tan

  -- Inverse trig functions
  asin :: Vector v n a -> Vector v n a
asin = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
asin
  acos :: Vector v n a -> Vector v n a
acos = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
acos
  atan :: Vector v n a -> Vector v n a
atan = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
atan
  atan2 :: Vector v n a -> Vector v n a -> Vector v n a
atan2 = (a -> a -> a) -> Vector v n a -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
DVGS.zipWith a -> a -> a
forall a. TrigField a => a -> a -> a
atan2

  -- Hyperbolic functions
  sinh :: Vector v n a -> Vector v n a
sinh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
sinh
  cosh :: Vector v n a -> Vector v n a
cosh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
cosh
  tanh :: Vector v n a -> Vector v n a
tanh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
tanh

  -- Inverse hyperbolic functions
  asinh :: Vector v n a -> Vector v n a
asinh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
asinh
  acosh :: Vector v n a -> Vector v n a
acosh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
acosh
  atanh :: Vector v n a -> Vector v n a
atanh = (a -> a) -> Vector v n a -> Vector v n a
forall (v :: * -> *) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
DVGS.map a -> a
forall a. TrigField a => a -> a
atanh

-- | `Data.Stream.Stream` instances  of `Additive` typeclass.
instance
  (Additive a) =>
  Additive (DS.Stream a)
  where
  zero :: Stream a
zero = a -> Stream a
forall a. a -> Stream a
DS.repeat a
forall a. Additive a => a
zero
  + :: Stream a -> Stream a -> Stream a
(+) = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
DS.zipWith a -> a -> a
forall a. Additive a => a -> a -> a
(+)

-- | `Data.Stream.Stream` instances  of `Subtractive` typeclass.
instance
  (Subtractive a) =>
  Subtractive (DS.Stream a)
  where
  negate :: Stream a -> Stream a
negate = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Subtractive a => a -> a
negate
  (-) = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
DS.zipWith (-)

-- | `Data.Stream.Stream` instances  of `Multiplicative` typeclass.
instance
  (Multiplicative a) =>
  Multiplicative (DS.Stream a)
  where
  one :: Stream a
one = a -> Stream a
forall a. a -> Stream a
DS.repeat a
forall a. Multiplicative a => a
one
  * :: Stream a -> Stream a -> Stream a
(*) = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Multiplicative a => a -> a -> a
(*)

-- | `Data.Stream.Stream` instances  of `Divisive` typeclass.
instance
  (Divisive a) =>
  Divisive (DS.Stream a)
  where
  recip :: Stream a -> Stream a
recip = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Divisive a => a -> a
recip
  / :: Stream a -> Stream a -> Stream a
(/) = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Divisive a => a -> a -> a
(/)

-- | `Data.Stream.Stream` instances  of `ExpField` typeclass.
instance
  (ExpField a) =>
  ExpField (DS.Stream a)
  where
  exp :: Stream a -> Stream a
exp = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
exp
  log :: Stream a -> Stream a
log = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
log
  ** :: Stream a -> Stream a -> Stream a
(**) = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. ExpField a => a -> a -> a
(**)
  logBase :: Stream a -> Stream a -> Stream a
logBase = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. ExpField a => a -> a -> a
logBase
  sqrt :: Stream a -> Stream a
sqrt = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
sqrt

-- | `Data.Stream.Stream` instances  of `TrigField` typeclass.
instance
  (TrigField a) =>
  TrigField (DS.Stream a)
  where
  -- Constants
  pi :: Stream a
pi = a -> Stream a
forall a. a -> Stream a
DS.repeat a
forall a. TrigField a => a
pi

  -- Basic trig functions
  sin :: Stream a -> Stream a
sin = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
sin
  cos :: Stream a -> Stream a
cos = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
cos
  tan :: Stream a -> Stream a
tan = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
tan

  -- Inverse trig functions
  asin :: Stream a -> Stream a
asin = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
asin
  acos :: Stream a -> Stream a
acos = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
acos
  atan :: Stream a -> Stream a
atan = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
atan
  atan2 :: Stream a -> Stream a -> Stream a
atan2 = (a -> a -> a) -> Stream a -> Stream a -> Stream a
forall a b c. (a -> b -> c) -> Stream a -> Stream b -> Stream c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. TrigField a => a -> a -> a
atan2

  -- Hyperbolic functions
  sinh :: Stream a -> Stream a
sinh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
sinh
  cosh :: Stream a -> Stream a
cosh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
cosh
  tanh :: Stream a -> Stream a
tanh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
tanh

  -- Inverse hyperbolic functions
  asinh :: Stream a -> Stream a
asinh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
asinh
  acosh :: Stream a -> Stream a
acosh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
acosh
  atanh :: Stream a -> Stream a
atanh = (a -> a) -> Stream a -> Stream a
forall a b. (a -> b) -> Stream a -> Stream b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
atanh

-- | `Maybe` instance of `Additive`.
instance
  (Additive a) =>
  Additive (Maybe a)
  where
  zero :: Maybe a
zero = a -> Maybe a
forall a. a -> Maybe a
Just a
forall a. Additive a => a
zero
  + :: Maybe a -> Maybe a -> Maybe a
(+) = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Additive a => a -> a -> a
(+)

-- | `Maybe` instance of `Subtractive`.
instance
  (Subtractive a) =>
  Subtractive (Maybe a)
  where
  negate :: Maybe a -> Maybe a
negate = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Subtractive a => a -> a
negate
  (-) = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)

-- | `Maybe` instance of `Multiplicative`.
instance
  (Multiplicative a) =>
  Multiplicative (Maybe a)
  where
  one :: Maybe a
one = a -> Maybe a
forall a. a -> Maybe a
Just a
forall a. Multiplicative a => a
one
  * :: Maybe a -> Maybe a -> Maybe a
(*) = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Multiplicative a => a -> a -> a
(*)

-- | `Maybe` instance of `Divisive`.
instance
  (Divisive a) =>
  Divisive (Maybe a)
  where
  recip :: Maybe a -> Maybe a
recip = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Divisive a => a -> a
recip
  / :: Maybe a -> Maybe a -> Maybe a
(/) = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Divisive a => a -> a -> a
(/)

-- | `Maybe` instance of `ExpField`.
instance
  (ExpField a) =>
  ExpField (Maybe a)
  where
  exp :: Maybe a -> Maybe a
exp = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
exp
  log :: Maybe a -> Maybe a
log = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
log
  ** :: Maybe a -> Maybe a -> Maybe a
(**) = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. ExpField a => a -> a -> a
(**)
  logBase :: Maybe a -> Maybe a -> Maybe a
logBase = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. ExpField a => a -> a -> a
logBase
  sqrt :: Maybe a -> Maybe a
sqrt = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. ExpField a => a -> a
sqrt

-- | `Maybe` instance of `TrigField`.
instance
  (TrigField a) =>
  TrigField (Maybe a)
  where
  -- Constants
  pi :: Maybe a
pi = a -> Maybe a
forall a. a -> Maybe a
Just a
forall a. TrigField a => a
pi

  -- Basic trig functions
  sin :: Maybe a -> Maybe a
sin = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
sin
  cos :: Maybe a -> Maybe a
cos = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
cos
  tan :: Maybe a -> Maybe a
tan = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
tan

  -- Inverse trig functions
  asin :: Maybe a -> Maybe a
asin = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
asin
  acos :: Maybe a -> Maybe a
acos = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
acos
  atan :: Maybe a -> Maybe a
atan = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
atan
  atan2 :: Maybe a -> Maybe a -> Maybe a
atan2 = (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. TrigField a => a -> a -> a
atan2

  -- Hyperbolic functions
  sinh :: Maybe a -> Maybe a
sinh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
sinh
  cosh :: Maybe a -> Maybe a
cosh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
cosh
  tanh :: Maybe a -> Maybe a
tanh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
tanh

  -- Inverse hyperbolic functions
  asinh :: Maybe a -> Maybe a
asinh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
asinh
  acosh :: Maybe a -> Maybe a
acosh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
acosh
  atanh :: Maybe a -> Maybe a
atanh = (a -> a) -> Maybe a -> Maybe a
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. TrigField a => a -> a
atanh