{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Copyright   :  (c) Edward Kmett 2021
-- License     :  BSD3
-- Maintainer  :  ekmett@gmail.com
-- Stability   :  experimental
-- Portability :  GHC only
--
-----------------------------------------------------------------------------

module Numeric.AD.Internal.Or
  ( Or(..)
  , F, T
  , runL, runR
  , Chosen(..)
  , chosen
  , unary
  , binary
  ) where

import Data.Number.Erf
import Data.Typeable
import Numeric.AD.Mode

runL :: Or F a b -> a
runL :: forall a b. Or F a b -> a
runL (L a
a) = a
a

runR :: Or T a b -> b
runR :: forall a b. Or T a b -> b
runR (R b
b) = b
b

------------------------------------------------------------------------------
-- On
------------------------------------------------------------------------------

chosen :: (a -> r) -> (b -> r) -> Or s a b -> r
chosen :: forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen a -> r
f b -> r
_ (L a
a) = a -> r
f a
a
chosen a -> r
_ b -> r
g (R b
b) = b -> r
g b
b

unary :: (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary :: forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary a -> a
f b -> b
_ (L a
a) = forall a b. a -> Or F a b
L (a -> a
f a
a)
unary a -> a
_ b -> b
g (R b
a) = forall b a. b -> Or T a b
R (b -> b
g b
a)

binary :: (a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary :: forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary a -> a -> a
f b -> b -> b
_ (L a
a) (L a
b) = forall a b. a -> Or F a b
L (a -> a -> a
f a
a a
b)
binary a -> a -> a
_ b -> b -> b
g (R b
a) (R b
b) = forall b a. b -> Or T a b
R (b -> b -> b
g b
a b
b)

data F
data T

class Chosen s where
  choose :: a -> b -> Or s a b

instance Chosen F where
  choose :: forall a b. a -> b -> Or F a b
choose a
x b
_ = forall a b. a -> Or F a b
L a
x

instance Chosen T where
  choose :: forall a b. a -> b -> Or T a b
choose a
_ b
x = forall b a. b -> Or T a b
R b
x

#ifndef HLINT
-- | The choice between two AD modes is an AD mode in its own right
data Or s a b where
  L :: a -> Or F a b
  R :: b -> Or T a b
  deriving Typeable
#endif

instance (Eq a, Eq b) => Eq (Or s a b) where
  L a
a == :: Or s a b -> Or s a b -> Bool
== L a
b = a
a forall a. Eq a => a -> a -> Bool
== a
b
  R b
a == R b
b = b
a forall a. Eq a => a -> a -> Bool
== b
b

instance (Ord a, Ord b) => Ord (Or s a b) where
  L a
a compare :: Or s a b -> Or s a b -> Ordering
`compare` L a
b = forall a. Ord a => a -> a -> Ordering
compare a
a a
b
  R b
a `compare` R b
b = forall a. Ord a => a -> a -> Ordering
compare b
a b
b

instance (Enum a, Enum b, Chosen s) => Enum (Or s a b) where
  pred :: Or s a b -> Or s a b
pred = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Enum a => a -> a
pred forall a. Enum a => a -> a
pred
  succ :: Or s a b -> Or s a b
succ = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Enum a => a -> a
succ forall a. Enum a => a -> a
succ
  toEnum :: Int -> Or s a b
toEnum Int
i = forall s a b. Chosen s => a -> b -> Or s a b
choose (forall a. Enum a => Int -> a
toEnum Int
i) (forall a. Enum a => Int -> a
toEnum Int
i)
  fromEnum :: Or s a b -> Int
fromEnum = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. Enum a => a -> Int
fromEnum forall a. Enum a => a -> Int
fromEnum
  enumFrom :: Or s a b -> [Or s a b]
enumFrom (L a
a) = forall a b. a -> Or F a b
L forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> [a]
enumFrom a
a
  enumFrom (R b
a) = forall b a. b -> Or T a b
R forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> [a]
enumFrom b
a
  enumFromThen :: Or s a b -> Or s a b -> [Or s a b]
enumFromThen (L a
a) (L a
b) = forall a b. a -> Or F a b
L forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> [a]
enumFromThen a
a a
b
  enumFromThen (R b
a) (R b
b) = forall b a. b -> Or T a b
R forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> [a]
enumFromThen b
a b
b
  enumFromTo :: Or s a b -> Or s a b -> [Or s a b]
enumFromTo (L a
a) (L a
b) = forall a b. a -> Or F a b
L forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> [a]
enumFromTo a
a a
b
  enumFromTo (R b
a) (R b
b) = forall b a. b -> Or T a b
R forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> [a]
enumFromTo b
a b
b
  enumFromThenTo :: Or s a b -> Or s a b -> Or s a b -> [Or s a b]
enumFromThenTo (L a
a) (L a
b) (L a
c) = forall a b. a -> Or F a b
L forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo a
a a
b a
c
  enumFromThenTo (R b
a) (R b
b) (R b
c) = forall b a. b -> Or T a b
R forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo b
a b
b b
c

instance (Bounded a, Bounded b, Chosen s) => Bounded (Or s a b) where
  maxBound :: Or s a b
maxBound = forall s a b. Chosen s => a -> b -> Or s a b
choose forall a. Bounded a => a
maxBound forall a. Bounded a => a
maxBound
  minBound :: Or s a b
minBound = forall s a b. Chosen s => a -> b -> Or s a b
choose forall a. Bounded a => a
minBound forall a. Bounded a => a
minBound

instance (Num a, Num b, Chosen s) => Num (Or s a b) where
  + :: Or s a b -> Or s a b -> Or s a b
(+) = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. Num a => a -> a -> a
(+) forall a. Num a => a -> a -> a
(+)
  (-) = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary (-) (-)
  * :: Or s a b -> Or s a b -> Or s a b
(*) = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. Num a => a -> a -> a
(*) forall a. Num a => a -> a -> a
(*)
  negate :: Or s a b -> Or s a b
negate = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Num a => a -> a
negate forall a. Num a => a -> a
negate
  abs :: Or s a b -> Or s a b
abs = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Num a => a -> a
abs forall a. Num a => a -> a
abs
  signum :: Or s a b -> Or s a b
signum = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Num a => a -> a
signum forall a. Num a => a -> a
signum
  fromInteger :: Integer -> Or s a b
fromInteger = forall s a b. Chosen s => a -> b -> Or s a b
choose forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Num a => Integer -> a
fromInteger forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Num a => Integer -> a
fromInteger

instance (Real a, Real b, Chosen s) => Real (Or s a b) where
  toRational :: Or s a b -> Rational
toRational = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. Real a => a -> Rational
toRational forall a. Real a => a -> Rational
toRational

instance (Fractional a, Fractional b, Chosen s) => Fractional (Or s a b) where
  / :: Or s a b -> Or s a b -> Or s a b
(/) = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. Fractional a => a -> a -> a
(/) forall a. Fractional a => a -> a -> a
(/)
  recip :: Or s a b -> Or s a b
recip = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Fractional a => a -> a
recip forall a. Fractional a => a -> a
recip
  fromRational :: Rational -> Or s a b
fromRational = forall s a b. Chosen s => a -> b -> Or s a b
choose forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Fractional a => Rational -> a
fromRational forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Fractional a => Rational -> a
fromRational

instance (RealFrac a, RealFrac b, Chosen s) => RealFrac (Or s a b) where
  properFraction :: forall b. Integral b => Or s a b -> (b, Or s a b)
properFraction (L a
a) = case forall a b. (RealFrac a, Integral b) => a -> (b, a)
properFraction a
a of
    (b
b, a
c) -> (b
b, forall a b. a -> Or F a b
L a
c)
  properFraction (R b
a) = case forall a b. (RealFrac a, Integral b) => a -> (b, a)
properFraction b
a of
    (b
b, b
c) -> (b
b, forall b a. b -> Or T a b
R b
c)
  truncate :: forall b. Integral b => Or s a b -> b
truncate = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a b. (RealFrac a, Integral b) => a -> b
truncate forall a b. (RealFrac a, Integral b) => a -> b
truncate
  round :: forall b. Integral b => Or s a b -> b
round = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a b. (RealFrac a, Integral b) => a -> b
round forall a b. (RealFrac a, Integral b) => a -> b
round
  ceiling :: forall b. Integral b => Or s a b -> b
ceiling = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a b. (RealFrac a, Integral b) => a -> b
ceiling forall a b. (RealFrac a, Integral b) => a -> b
ceiling
  floor :: forall b. Integral b => Or s a b -> b
floor = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a b. (RealFrac a, Integral b) => a -> b
floor forall a b. (RealFrac a, Integral b) => a -> b
floor

instance (Floating a, Floating b, Chosen s) => Floating (Or s a b) where
  pi :: Or s a b
pi = forall s a b. Chosen s => a -> b -> Or s a b
choose forall a. Floating a => a
pi forall a. Floating a => a
pi
  exp :: Or s a b -> Or s a b
exp = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
exp forall a. Floating a => a -> a
exp
  sqrt :: Or s a b -> Or s a b
sqrt = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
sqrt forall a. Floating a => a -> a
sqrt
  log :: Or s a b -> Or s a b
log = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
log forall a. Floating a => a -> a
log
  ** :: Or s a b -> Or s a b -> Or s a b
(**) = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. Floating a => a -> a -> a
(**) forall a. Floating a => a -> a -> a
(**)
  logBase :: Or s a b -> Or s a b -> Or s a b
logBase = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. Floating a => a -> a -> a
logBase forall a. Floating a => a -> a -> a
logBase
  sin :: Or s a b -> Or s a b
sin = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
sin forall a. Floating a => a -> a
sin
  tan :: Or s a b -> Or s a b
tan = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
tan forall a. Floating a => a -> a
tan
  cos :: Or s a b -> Or s a b
cos = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
cos forall a. Floating a => a -> a
cos
  asin :: Or s a b -> Or s a b
asin = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
asin forall a. Floating a => a -> a
asin
  atan :: Or s a b -> Or s a b
atan = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
atan forall a. Floating a => a -> a
atan
  acos :: Or s a b -> Or s a b
acos = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
acos forall a. Floating a => a -> a
acos
  sinh :: Or s a b -> Or s a b
sinh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
sinh forall a. Floating a => a -> a
sinh
  tanh :: Or s a b -> Or s a b
tanh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
tanh forall a. Floating a => a -> a
tanh
  cosh :: Or s a b -> Or s a b
cosh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
cosh forall a. Floating a => a -> a
cosh
  asinh :: Or s a b -> Or s a b
asinh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
asinh forall a. Floating a => a -> a
asinh
  atanh :: Or s a b -> Or s a b
atanh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
atanh forall a. Floating a => a -> a
atanh
  acosh :: Or s a b -> Or s a b
acosh = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Floating a => a -> a
acosh forall a. Floating a => a -> a
acosh

instance (Erf a, Erf b, Chosen s) => Erf (Or s a b) where
  erf :: Or s a b -> Or s a b
erf = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Erf a => a -> a
erf forall a. Erf a => a -> a
erf
  erfc :: Or s a b -> Or s a b
erfc = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Erf a => a -> a
erfc forall a. Erf a => a -> a
erfc
  erfcx :: Or s a b -> Or s a b
erfcx = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Erf a => a -> a
erfcx forall a. Erf a => a -> a
erfcx
  normcdf :: Or s a b -> Or s a b
normcdf = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. Erf a => a -> a
normcdf forall a. Erf a => a -> a
normcdf

instance (InvErf a, InvErf b, Chosen s) => InvErf (Or s a b) where
  inverf :: Or s a b -> Or s a b
inverf = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. InvErf a => a -> a
inverf forall a. InvErf a => a -> a
inverf
  inverfc :: Or s a b -> Or s a b
inverfc = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. InvErf a => a -> a
inverfc forall a. InvErf a => a -> a
inverfc
  invnormcdf :: Or s a b -> Or s a b
invnormcdf = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. InvErf a => a -> a
invnormcdf forall a. InvErf a => a -> a
invnormcdf

instance (RealFloat a, RealFloat b, Chosen s) => RealFloat (Or s a b) where
  floatRadix :: Or s a b -> Integer
floatRadix = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Integer
floatRadix forall a. RealFloat a => a -> Integer
floatRadix
  floatDigits :: Or s a b -> Int
floatDigits = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Int
floatDigits forall a. RealFloat a => a -> Int
floatDigits
  floatRange :: Or s a b -> (Int, Int)
floatRange = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> (Int, Int)
floatRange forall a. RealFloat a => a -> (Int, Int)
floatRange
  decodeFloat :: Or s a b -> (Integer, Int)
decodeFloat = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> (Integer, Int)
decodeFloat forall a. RealFloat a => a -> (Integer, Int)
decodeFloat
  encodeFloat :: Integer -> Int -> Or s a b
encodeFloat Integer
i Int
j = forall s a b. Chosen s => a -> b -> Or s a b
choose (forall a. RealFloat a => Integer -> Int -> a
encodeFloat Integer
i Int
j) (forall a. RealFloat a => Integer -> Int -> a
encodeFloat Integer
i Int
j)
  exponent :: Or s a b -> Int
exponent = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Int
exponent forall a. RealFloat a => a -> Int
exponent
  significand :: Or s a b -> Or s a b
significand = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall a. RealFloat a => a -> a
significand forall a. RealFloat a => a -> a
significand
  scaleFloat :: Int -> Or s a b -> Or s a b
scaleFloat = forall a b s. (a -> a) -> (b -> b) -> Or s a b -> Or s a b
unary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. RealFloat a => Int -> a -> a
scaleFloat forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. RealFloat a => Int -> a -> a
scaleFloat
  isNaN :: Or s a b -> Bool
isNaN = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Bool
isNaN forall a. RealFloat a => a -> Bool
isNaN
  isInfinite :: Or s a b -> Bool
isInfinite = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Bool
isInfinite forall a. RealFloat a => a -> Bool
isInfinite
  isDenormalized :: Or s a b -> Bool
isDenormalized = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Bool
isDenormalized forall a. RealFloat a => a -> Bool
isDenormalized
  isNegativeZero :: Or s a b -> Bool
isNegativeZero = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Bool
isNegativeZero forall a. RealFloat a => a -> Bool
isNegativeZero
  isIEEE :: Or s a b -> Bool
isIEEE = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall a. RealFloat a => a -> Bool
isIEEE forall a. RealFloat a => a -> Bool
isIEEE
  atan2 :: Or s a b -> Or s a b -> Or s a b
atan2 = forall a b s.
(a -> a -> a) -> (b -> b -> b) -> Or s a b -> Or s a b -> Or s a b
binary forall a. RealFloat a => a -> a -> a
atan2 forall a. RealFloat a => a -> a -> a
atan2


instance (Mode a, Mode b, Chosen s, Scalar a ~ Scalar b) => Mode (Or s a b) where
  type Scalar (Or s a b) = Scalar a
  auto :: Scalar (Or s a b) -> Or s a b
auto = forall s a b. Chosen s => a -> b -> Or s a b
choose forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t. Mode t => Scalar t -> t
auto forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall t. Mode t => Scalar t -> t
auto
  isKnownConstant :: Or s a b -> Bool
isKnownConstant = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall t. Mode t => t -> Bool
isKnownConstant forall t. Mode t => t -> Bool
isKnownConstant
  asKnownConstant :: Or s a b -> Maybe (Scalar (Or s a b))
asKnownConstant (L a
a) = forall t. Mode t => t -> Maybe (Scalar t)
asKnownConstant a
a
  asKnownConstant (R b
b) = forall t. Mode t => t -> Maybe (Scalar t)
asKnownConstant b
b
  isKnownZero :: Or s a b -> Bool
isKnownZero = forall a r b s. (a -> r) -> (b -> r) -> Or s a b -> r
chosen forall t. Mode t => t -> Bool
isKnownZero forall t. Mode t => t -> Bool
isKnownZero
  Scalar (Or s a b)
x *^ :: Scalar (Or s a b) -> Or s a b -> Or s a b
*^ L a
a = forall a b. a -> Or F a b
L (Scalar (Or s a b)
x forall t. Mode t => Scalar t -> t -> t
*^ a
a)
  Scalar (Or s a b)
x *^ R b
a = forall b a. b -> Or T a b
R (Scalar (Or s a b)
x forall t. Mode t => Scalar t -> t -> t
*^ b
a)
  L a
a ^* :: Or s a b -> Scalar (Or s a b) -> Or s a b
^* Scalar (Or s a b)
x = forall a b. a -> Or F a b
L (a
a forall t. Mode t => t -> Scalar t -> t
^* Scalar (Or s a b)
x)
  R b
a ^* Scalar (Or s a b)
x = forall b a. b -> Or T a b
R (b
a forall t. Mode t => t -> Scalar t -> t
^* Scalar (Or s a b)
x)
  L a
a ^/ :: Fractional (Scalar (Or s a b)) =>
Or s a b -> Scalar (Or s a b) -> Or s a b
^/ Scalar (Or s a b)
x = forall a b. a -> Or F a b
L (a
a forall t. (Mode t, Fractional (Scalar t)) => t -> Scalar t -> t
^/ Scalar (Or s a b)
x)
  R b
a ^/ Scalar (Or s a b)
x = forall b a. b -> Or T a b
R (b
a forall t. (Mode t, Fractional (Scalar t)) => t -> Scalar t -> t
^/ Scalar (Or s a b)
x)
  zero :: Or s a b
zero = forall s a b. Chosen s => a -> b -> Or s a b
choose forall t. Mode t => t
zero forall t. Mode t => t
zero