{-# LANGUAGE CPP, ConstraintKinds, FlexibleContexts, FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving, MultiParamTypeClasses         #-}
{-# LANGUAGE NoImplicitPrelude, NoRebindableSyntax, StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell, TypeFamilies, UndecidableInstances       #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
-- | This module provides drop-in replacement for @'Prelude'@ module in base package,
--   based on algebraic hierarchy provided by
--   <https://hackage.haskell.org/package/algebra algebra> package.
--   You can use this module with @NoImplicitPrelude@ language option.
--
--  This module implicitly exports following modules:
--
--      * "Numeric.Algebra" module, except
--
--          * @'NA.fromInteger'@:
--             this module exports Prelude's @'fromInteger'@ to make number literals
--             work properly.
--            For @'NA.fromInteger'@ from @algebra@ package, use @'fromInteger''@.
--
--          * @('NA.^')@ is renamed to @('^^')@, and @('^')@ is redefined as @'NA.pow'@.
--
--      * The module "Numeric.Algebra.Unital.UnitNormalForm", except for @'NA.normalize'@;
--      hence its name is too general, we export it as @'normaliseUnit'@.
--
--      * Following modules are exported as-is:
--
--            * "Numeric.Decidable.Associates"
--            * "Numeric.Decidable.Units"
--            * "Numeric.Decidable.Zero"
--            * "Numeric.Domain.Class"
--            * "Numeric.Domain.Euclidean"
--            * "Numeric.Domain.GCD"
--            * "Numeric.Domain.Integral"
--            * "Numeric.Domain.PID"
--            * "Numeric.Domain.UFD"
--            * "Numeric.Field.Fraction"
--            * "Numeric.Semiring.ZeroProduct"
--
--      * Non-numeric part of this module is almost same as "BasicPrelude".
--        But the following combinators are not generalized from "Prelude":
--
--          * @'String'@-specific functions: @'getArgs'@, @'getContents'@,
--          @'getLine'@, @'interact'@, @'putStr'@, @'putStrLn'@,
--          @'read'@, @'readFile'@, @'writeFile'@,  @'lines'@, @'unlines'@,
--          @'words'@ and @'unwords'@.
--
--          * @('.')@ is just a function composition; not a Categorical composition.

module AlgebraicPrelude
       (module AlgebraicPrelude,
        -- * Old Prelude's Numeric type classes and functions, without confliction
        P.Num(abs,signum),P.Integral(),P.toInteger, P.Real(..), P.Fractional (),
        P.Floating(..), P.RealFrac(..), P.RealFloat(..),
       ) where
import           BasicPrelude                          as AlgebraicPrelude hiding
                                                                            (Floating (..),
                                                                            Fractional (..),
                                                                            Integral (..),
                                                                            Num (..),
                                                                            Rational,
                                                                            Real (..),
                                                                            RealFloat (..),
                                                                            RealFrac (..),
                                                                            fromShow,
                                                                            gcd,
                                                                            getArgs,
                                                                            getContents,
                                                                            getLine,
                                                                            id,
                                                                            interact,
                                                                            lcm,
                                                                            lines,
                                                                            product,
                                                                            putStr,
                                                                            putStrLn,
                                                                            read,
                                                                            readFile,
                                                                            show,
#if MIN_VERSION_base(4,14,0)
                                                                            singleton,
#endif
                                                                            subtract,
                                                                            sum,
                                                                            unlines,
                                                                            unwords,
                                                                            words,
                                                                            writeFile,
                                                                            (.),
                                                                            (\\),
                                                                            (^),
                                                                            (^^))
import qualified Control.Lens.TH                       as L
import qualified Data.Ratio                            as P
import qualified Data.Semigroup                        as Semi
import           Foreign.Storable                      (Storable)
import           GHC.OverloadedLabels                  as AlgebraicPrelude
import           Numeric.Algebra                       as AlgebraicPrelude hiding
                                                                            (Order (..),
                                                                            fromInteger,
                                                                            (^))
import qualified Numeric.Algebra                       as NA
import           Numeric.Algebra.Unital.UnitNormalForm as AlgebraicPrelude hiding
                                                                            (normalize)
import qualified Numeric.Algebra.Unital.UnitNormalForm as NA
import           Numeric.Decidable.Associates          as AlgebraicPrelude
import           Numeric.Decidable.Units               as AlgebraicPrelude
import           Numeric.Decidable.Zero                as AlgebraicPrelude
import           Numeric.Domain.Class                  as AlgebraicPrelude
import           Numeric.Domain.Euclidean              as AlgebraicPrelude
import           Numeric.Domain.GCD                    as AlgebraicPrelude
import           Numeric.Domain.Integral               as AlgebraicPrelude
import           Numeric.Domain.PID                    as AlgebraicPrelude
import           Numeric.Domain.UFD                    as AlgebraicPrelude
import           Numeric.Field.Fraction                as AlgebraicPrelude
import           Numeric.Semiring.ZeroProduct          as AlgebraicPrelude
import           Prelude                               as AlgebraicPrelude (Num, Show (..),
                                                                            ceiling,
                                                                            div,
                                                                            floor,
                                                                            getContents,
                                                                            getLine,
                                                                            id,
                                                                            interact,
                                                                            lines,
                                                                            mod,
                                                                            putStr,
                                                                            putStrLn,
                                                                            readFile,
                                                                            show,
                                                                            unlines,
                                                                            unwords,
                                                                            words,
                                                                            writeFile,
                                                                            (.))
import qualified Prelude                               as P
-- * Basic types and renamed operations
-- | We use @'Fraction'@ instead of @'Ratio'@ for consistency.
type Rational = Fraction Integer

infixr 8 ^, ^^

-- | To work with Num literals.
fromInteger :: P.Num r => Integer -> r
fromInteger :: Integer -> r
fromInteger = Integer -> r
forall a. Num a => Integer -> a
P.fromInteger
{-# INLINE [1] fromInteger #-}
{-# RULES
"fromInteger/Integer"
  fromInteger = id
  #-}

-- | @algebra@ package's original @'NA.fromInteger'@.
fromInteger' :: Ring r => Integer -> r
fromInteger' :: Integer -> r
fromInteger' = Integer -> r
forall r. Ring r => Integer -> r
NA.fromInteger

fromRational :: DivisionRing r => P.Rational -> r
fromRational :: Rational -> r
fromRational Rational
r = Integer -> r
forall r. Ring r => Integer -> r
NA.fromInteger (Rational -> Integer
forall a. Ratio a -> a
P.numerator Rational
r) r -> r -> r
forall r. Division r => r -> r -> r
/ Integer -> r
forall r. Ring r => Integer -> r
NA.fromInteger (Rational -> Integer
forall a. Ratio a -> a
P.denominator Rational
r)
{-# INLINE [1] fromRational #-}
{-# RULES
"fromRational/Rational" [~1]
  fromRational = id
  #-}

normaliseUnit :: UnitNormalForm r => r -> r
normaliseUnit :: r -> r
normaliseUnit = r -> r
forall r. UnitNormalForm r => r -> r
NA.normalize

-- | Specialised version of @'pow'@ which takes @'Natural'@s as a power.
(^) :: Unital r => r -> Natural -> r
^ :: r -> Natural -> r
(^) = r -> Natural -> r
forall r. Unital r => r -> Natural -> r
pow

-- | The original power function @('NA.^')@ of @algebra@
(^^) :: Division r => r -> Integer -> r
^^ :: r -> Integer -> r
(^^) = r -> Integer -> r
forall r n. (Division r, Integral n) => r -> n -> r
(NA.^)

-- * Combinator to use with @RebindableSyntax@ extensions.
ifThenElse :: Bool -> a -> a -> a
ifThenElse :: Bool -> a -> a -> a
ifThenElse Bool
p a
t a
f = if Bool
p then a
t else a
f

-- * Wrapper types for conversion between @'Num'@ family
--   and algebraic hierarchy provided by @algebra@.

-- | Wrapping Prelude's numerical types to treat with
--   @'Numeric.Algebra'@ hierachy.
--
--   For @'Field'@ or @'Euclidean'@ instances, see @'WrapIntegral'@ and @'WrapField'@.
--
--  __N.B.__ This type provides a mean to convert from @'Num'@s
--           to @'Ring'@s, but there is no guarantee that
--           @'WrapNum' a@ is actually ring.
--           For example, due to precision limitation,
--           @'WrapPreldue' 'Double'@ even fails to be semigroup!
--           For another simpler example, even though  @'Natural'@ comes
--           with @'Num'@ instance, but it doesn't support @'negate'@,
--           so it cannot be @'Group'@.
newtype WrapNum a = WrapNum { WrapNum a -> a
unwrapNum :: a }
                      deriving (ReadPrec [WrapNum a]
ReadPrec (WrapNum a)
Int -> ReadS (WrapNum a)
ReadS [WrapNum a]
(Int -> ReadS (WrapNum a))
-> ReadS [WrapNum a]
-> ReadPrec (WrapNum a)
-> ReadPrec [WrapNum a]
-> Read (WrapNum a)
forall a. Read a => ReadPrec [WrapNum a]
forall a. Read a => ReadPrec (WrapNum a)
forall a. Read a => Int -> ReadS (WrapNum a)
forall a. Read a => ReadS [WrapNum a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WrapNum a]
$creadListPrec :: forall a. Read a => ReadPrec [WrapNum a]
readPrec :: ReadPrec (WrapNum a)
$creadPrec :: forall a. Read a => ReadPrec (WrapNum a)
readList :: ReadS [WrapNum a]
$creadList :: forall a. Read a => ReadS [WrapNum a]
readsPrec :: Int -> ReadS (WrapNum a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WrapNum a)
Read, Int -> WrapNum a -> ShowS
[WrapNum a] -> ShowS
WrapNum a -> String
(Int -> WrapNum a -> ShowS)
-> (WrapNum a -> String)
-> ([WrapNum a] -> ShowS)
-> Show (WrapNum a)
forall a. Show a => Int -> WrapNum a -> ShowS
forall a. Show a => [WrapNum a] -> ShowS
forall a. Show a => WrapNum a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapNum a] -> ShowS
$cshowList :: forall a. Show a => [WrapNum a] -> ShowS
show :: WrapNum a -> String
$cshow :: forall a. Show a => WrapNum a -> String
showsPrec :: Int -> WrapNum a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WrapNum a -> ShowS
Show, WrapNum a -> WrapNum a -> Bool
(WrapNum a -> WrapNum a -> Bool)
-> (WrapNum a -> WrapNum a -> Bool) -> Eq (WrapNum a)
forall a. Eq a => WrapNum a -> WrapNum a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapNum a -> WrapNum a -> Bool
$c/= :: forall a. Eq a => WrapNum a -> WrapNum a -> Bool
== :: WrapNum a -> WrapNum a -> Bool
$c== :: forall a. Eq a => WrapNum a -> WrapNum a -> Bool
Eq, Eq (WrapNum a)
Eq (WrapNum a)
-> (WrapNum a -> WrapNum a -> Ordering)
-> (WrapNum a -> WrapNum a -> Bool)
-> (WrapNum a -> WrapNum a -> Bool)
-> (WrapNum a -> WrapNum a -> Bool)
-> (WrapNum a -> WrapNum a -> Bool)
-> (WrapNum a -> WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a -> WrapNum a)
-> Ord (WrapNum a)
WrapNum a -> WrapNum a -> Bool
WrapNum a -> WrapNum a -> Ordering
WrapNum a -> WrapNum a -> WrapNum a
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
forall a. Ord a => Eq (WrapNum a)
forall a. Ord a => WrapNum a -> WrapNum a -> Bool
forall a. Ord a => WrapNum a -> WrapNum a -> Ordering
forall a. Ord a => WrapNum a -> WrapNum a -> WrapNum a
min :: WrapNum a -> WrapNum a -> WrapNum a
$cmin :: forall a. Ord a => WrapNum a -> WrapNum a -> WrapNum a
max :: WrapNum a -> WrapNum a -> WrapNum a
$cmax :: forall a. Ord a => WrapNum a -> WrapNum a -> WrapNum a
>= :: WrapNum a -> WrapNum a -> Bool
$c>= :: forall a. Ord a => WrapNum a -> WrapNum a -> Bool
> :: WrapNum a -> WrapNum a -> Bool
$c> :: forall a. Ord a => WrapNum a -> WrapNum a -> Bool
<= :: WrapNum a -> WrapNum a -> Bool
$c<= :: forall a. Ord a => WrapNum a -> WrapNum a -> Bool
< :: WrapNum a -> WrapNum a -> Bool
$c< :: forall a. Ord a => WrapNum a -> WrapNum a -> Bool
compare :: WrapNum a -> WrapNum a -> Ordering
$ccompare :: forall a. Ord a => WrapNum a -> WrapNum a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (WrapNum a)
Ord, Integer -> WrapNum a
WrapNum a -> WrapNum a
WrapNum a -> WrapNum a -> WrapNum a
(WrapNum a -> WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a)
-> (WrapNum a -> WrapNum a)
-> (Integer -> WrapNum a)
-> Num (WrapNum a)
forall a. Num a => Integer -> WrapNum a
forall a. Num a => WrapNum a -> WrapNum a
forall a. Num a => WrapNum a -> WrapNum a -> WrapNum a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WrapNum a
$cfromInteger :: forall a. Num a => Integer -> WrapNum a
signum :: WrapNum a -> WrapNum a
$csignum :: forall a. Num a => WrapNum a -> WrapNum a
abs :: WrapNum a -> WrapNum a
$cabs :: forall a. Num a => WrapNum a -> WrapNum a
negate :: WrapNum a -> WrapNum a
$cnegate :: forall a. Num a => WrapNum a -> WrapNum a
* :: WrapNum a -> WrapNum a -> WrapNum a
$c* :: forall a. Num a => WrapNum a -> WrapNum a -> WrapNum a
- :: WrapNum a -> WrapNum a -> WrapNum a
$c- :: forall a. Num a => WrapNum a -> WrapNum a -> WrapNum a
+ :: WrapNum a -> WrapNum a -> WrapNum a
$c+ :: forall a. Num a => WrapNum a -> WrapNum a -> WrapNum a
P.Num, Ptr b -> Int -> IO (WrapNum a)
Ptr b -> Int -> WrapNum a -> IO ()
Ptr (WrapNum a) -> IO (WrapNum a)
Ptr (WrapNum a) -> Int -> IO (WrapNum a)
Ptr (WrapNum a) -> Int -> WrapNum a -> IO ()
Ptr (WrapNum a) -> WrapNum a -> IO ()
WrapNum a -> Int
(WrapNum a -> Int)
-> (WrapNum a -> Int)
-> (Ptr (WrapNum a) -> Int -> IO (WrapNum a))
-> (Ptr (WrapNum a) -> Int -> WrapNum a -> IO ())
-> (forall b. Ptr b -> Int -> IO (WrapNum a))
-> (forall b. Ptr b -> Int -> WrapNum a -> IO ())
-> (Ptr (WrapNum a) -> IO (WrapNum a))
-> (Ptr (WrapNum a) -> WrapNum a -> IO ())
-> Storable (WrapNum a)
forall b. Ptr b -> Int -> IO (WrapNum a)
forall b. Ptr b -> Int -> WrapNum a -> IO ()
forall a. Storable a => Ptr (WrapNum a) -> IO (WrapNum a)
forall a. Storable a => Ptr (WrapNum a) -> Int -> IO (WrapNum a)
forall a.
Storable a =>
Ptr (WrapNum a) -> Int -> WrapNum a -> IO ()
forall a. Storable a => Ptr (WrapNum a) -> WrapNum a -> IO ()
forall a. Storable a => WrapNum a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (WrapNum a)
forall a b. Storable a => Ptr b -> Int -> WrapNum a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (WrapNum a) -> WrapNum a -> IO ()
$cpoke :: forall a. Storable a => Ptr (WrapNum a) -> WrapNum a -> IO ()
peek :: Ptr (WrapNum a) -> IO (WrapNum a)
$cpeek :: forall a. Storable a => Ptr (WrapNum a) -> IO (WrapNum a)
pokeByteOff :: Ptr b -> Int -> WrapNum a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> WrapNum a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (WrapNum a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (WrapNum a)
pokeElemOff :: Ptr (WrapNum a) -> Int -> WrapNum a -> IO ()
$cpokeElemOff :: forall a.
Storable a =>
Ptr (WrapNum a) -> Int -> WrapNum a -> IO ()
peekElemOff :: Ptr (WrapNum a) -> Int -> IO (WrapNum a)
$cpeekElemOff :: forall a. Storable a => Ptr (WrapNum a) -> Int -> IO (WrapNum a)
alignment :: WrapNum a -> Int
$calignment :: forall a. Storable a => WrapNum a -> Int
sizeOf :: WrapNum a -> Int
$csizeOf :: forall a. Storable a => WrapNum a -> Int
Storable)

instance (P.Num a) => Additive (WrapNum a) where
  WrapNum a
a + :: WrapNum a -> WrapNum a -> WrapNum a
+ WrapNum a
b = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.+ a
b)
  {-# INLINE (+) #-}
  sinnum1p :: Natural -> WrapNum a -> WrapNum a
sinnum1p Natural
n (WrapNum a
a) = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum ((a
1 a -> a -> a
forall a. Num a => a -> a -> a
P.+ Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n) a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum1p #-}

instance (P.Num a) => LeftModule Natural (WrapNum a) where
  Natural
n .* :: Natural -> WrapNum a -> WrapNum a
.* WrapNum a
r = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Natural (WrapNum a) where
  WrapNum a
r *. :: WrapNum a -> Natural -> WrapNum a
*. Natural
n = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Monoidal (WrapNum a) where
  zero :: WrapNum a
zero = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
0)
  {-# INLINE zero #-}
  sinnum :: Natural -> WrapNum a -> WrapNum a
sinnum Natural
n (WrapNum a
a) = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum #-}

instance (P.Num a) => LeftModule Integer (WrapNum a) where
  Integer
n .* :: Integer -> WrapNum a -> WrapNum a
.* WrapNum a
r = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Integer (WrapNum a) where
  WrapNum a
r *. :: WrapNum a -> Integer -> WrapNum a
*. Integer
n = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Group (WrapNum a) where
  negate :: WrapNum a -> WrapNum a
negate (WrapNum a
a) = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> a -> WrapNum a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Num a => a -> a
P.negate a
a
  {-# INLINE negate #-}
  WrapNum a
a - :: WrapNum a -> WrapNum a -> WrapNum a
- WrapNum a
b = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.- a
b)
  {-# INLINE (-) #-}
  subtract :: WrapNum a -> WrapNum a -> WrapNum a
subtract (WrapNum a
a) (WrapNum a
b) = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> a -> a
forall a. Num a => a -> a -> a
P.subtract a
a a
b)
  {-# INLINE subtract #-}
  times :: n -> WrapNum a -> WrapNum a
times n
n (WrapNum a
a) = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> a -> WrapNum a
forall a b. (a -> b) -> a -> b
$ n -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral n
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a
  {-# INLINE times #-}

instance (P.Num a) => Multiplicative (WrapNum a) where
  WrapNum a
p * :: WrapNum a -> WrapNum a -> WrapNum a
* WrapNum a
q = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
p a -> a -> a
forall a. Num a => a -> a -> a
P.* a
q)
  {-# INLINE (*) #-}
  pow1p :: WrapNum a -> Natural -> WrapNum a
pow1p (WrapNum a
p) Natural
n = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a
p a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ (Natural
n Natural -> Natural -> Natural
forall r. Additive r => r -> r -> r
+ Natural
1))
  {-# INLINE pow1p #-}

instance (P.Num a) => Unital (WrapNum a) where
  one :: WrapNum a
one = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> a -> WrapNum a
forall a b. (a -> b) -> a -> b
$ Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
1
  {-# INLINE one #-}
  pow :: WrapNum a -> Natural -> WrapNum a
pow (WrapNum a
a) Natural
n = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> a -> WrapNum a
forall a b. (a -> b) -> a -> b
$ a
a a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ Natural
n
  {-# INLINE pow #-}

instance P.Num a => Abelian (WrapNum a)
instance P.Num a => Semiring (WrapNum a)
instance P.Num a => Rig (WrapNum a) where
  fromNatural :: Natural -> WrapNum a
fromNatural = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> (Natural -> a) -> Natural -> WrapNum a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral
  {-# INLINE fromNatural #-}
instance P.Num a => Ring (WrapNum a) where
  fromInteger :: Integer -> WrapNum a
fromInteger = a -> WrapNum a
forall a. a -> WrapNum a
WrapNum (a -> WrapNum a) -> (Integer -> a) -> Integer -> WrapNum a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
P.fromInteger
  {-# INLINE fromInteger #-}

instance P.Num a => Commutative (WrapNum a)

instance (P.Num a, Eq a) => DecidableZero (WrapNum a) where
  isZero :: WrapNum a -> Bool
isZero (WrapNum a
a) = a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0
  {-# INLINE isZero #-}

-- | Similar to @'WrapNum'@, but produces @'Field'@ instances from
--   @'Fractional'@s.
--
--   See also: @'WrapIntegral'@ and @'WrapNum'@.
newtype WrapFractional a = WrapFractional { WrapFractional a -> a
unwrapFractional :: a }
  deriving (ReadPrec [WrapFractional a]
ReadPrec (WrapFractional a)
Int -> ReadS (WrapFractional a)
ReadS [WrapFractional a]
(Int -> ReadS (WrapFractional a))
-> ReadS [WrapFractional a]
-> ReadPrec (WrapFractional a)
-> ReadPrec [WrapFractional a]
-> Read (WrapFractional a)
forall a. Read a => ReadPrec [WrapFractional a]
forall a. Read a => ReadPrec (WrapFractional a)
forall a. Read a => Int -> ReadS (WrapFractional a)
forall a. Read a => ReadS [WrapFractional a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WrapFractional a]
$creadListPrec :: forall a. Read a => ReadPrec [WrapFractional a]
readPrec :: ReadPrec (WrapFractional a)
$creadPrec :: forall a. Read a => ReadPrec (WrapFractional a)
readList :: ReadS [WrapFractional a]
$creadList :: forall a. Read a => ReadS [WrapFractional a]
readsPrec :: Int -> ReadS (WrapFractional a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WrapFractional a)
Read, Int -> WrapFractional a -> ShowS
[WrapFractional a] -> ShowS
WrapFractional a -> String
(Int -> WrapFractional a -> ShowS)
-> (WrapFractional a -> String)
-> ([WrapFractional a] -> ShowS)
-> Show (WrapFractional a)
forall a. Show a => Int -> WrapFractional a -> ShowS
forall a. Show a => [WrapFractional a] -> ShowS
forall a. Show a => WrapFractional a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapFractional a] -> ShowS
$cshowList :: forall a. Show a => [WrapFractional a] -> ShowS
show :: WrapFractional a -> String
$cshow :: forall a. Show a => WrapFractional a -> String
showsPrec :: Int -> WrapFractional a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WrapFractional a -> ShowS
Show, WrapFractional a -> WrapFractional a -> Bool
(WrapFractional a -> WrapFractional a -> Bool)
-> (WrapFractional a -> WrapFractional a -> Bool)
-> Eq (WrapFractional a)
forall a. Eq a => WrapFractional a -> WrapFractional a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapFractional a -> WrapFractional a -> Bool
$c/= :: forall a. Eq a => WrapFractional a -> WrapFractional a -> Bool
== :: WrapFractional a -> WrapFractional a -> Bool
$c== :: forall a. Eq a => WrapFractional a -> WrapFractional a -> Bool
Eq, Eq (WrapFractional a)
Eq (WrapFractional a)
-> (WrapFractional a -> WrapFractional a -> Ordering)
-> (WrapFractional a -> WrapFractional a -> Bool)
-> (WrapFractional a -> WrapFractional a -> Bool)
-> (WrapFractional a -> WrapFractional a -> Bool)
-> (WrapFractional a -> WrapFractional a -> Bool)
-> (WrapFractional a -> WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a -> WrapFractional a)
-> Ord (WrapFractional a)
WrapFractional a -> WrapFractional a -> Bool
WrapFractional a -> WrapFractional a -> Ordering
WrapFractional a -> WrapFractional a -> WrapFractional a
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
forall a. Ord a => Eq (WrapFractional a)
forall a. Ord a => WrapFractional a -> WrapFractional a -> Bool
forall a. Ord a => WrapFractional a -> WrapFractional a -> Ordering
forall a.
Ord a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
min :: WrapFractional a -> WrapFractional a -> WrapFractional a
$cmin :: forall a.
Ord a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
max :: WrapFractional a -> WrapFractional a -> WrapFractional a
$cmax :: forall a.
Ord a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
>= :: WrapFractional a -> WrapFractional a -> Bool
$c>= :: forall a. Ord a => WrapFractional a -> WrapFractional a -> Bool
> :: WrapFractional a -> WrapFractional a -> Bool
$c> :: forall a. Ord a => WrapFractional a -> WrapFractional a -> Bool
<= :: WrapFractional a -> WrapFractional a -> Bool
$c<= :: forall a. Ord a => WrapFractional a -> WrapFractional a -> Bool
< :: WrapFractional a -> WrapFractional a -> Bool
$c< :: forall a. Ord a => WrapFractional a -> WrapFractional a -> Bool
compare :: WrapFractional a -> WrapFractional a -> Ordering
$ccompare :: forall a. Ord a => WrapFractional a -> WrapFractional a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (WrapFractional a)
Ord, Integer -> WrapFractional a
WrapFractional a -> WrapFractional a
WrapFractional a -> WrapFractional a -> WrapFractional a
(WrapFractional a -> WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a)
-> (Integer -> WrapFractional a)
-> Num (WrapFractional a)
forall a. Num a => Integer -> WrapFractional a
forall a. Num a => WrapFractional a -> WrapFractional a
forall a.
Num a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WrapFractional a
$cfromInteger :: forall a. Num a => Integer -> WrapFractional a
signum :: WrapFractional a -> WrapFractional a
$csignum :: forall a. Num a => WrapFractional a -> WrapFractional a
abs :: WrapFractional a -> WrapFractional a
$cabs :: forall a. Num a => WrapFractional a -> WrapFractional a
negate :: WrapFractional a -> WrapFractional a
$cnegate :: forall a. Num a => WrapFractional a -> WrapFractional a
* :: WrapFractional a -> WrapFractional a -> WrapFractional a
$c* :: forall a.
Num a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
- :: WrapFractional a -> WrapFractional a -> WrapFractional a
$c- :: forall a.
Num a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
+ :: WrapFractional a -> WrapFractional a -> WrapFractional a
$c+ :: forall a.
Num a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
Num, Int -> WrapFractional a
WrapFractional a -> Int
WrapFractional a -> [WrapFractional a]
WrapFractional a -> WrapFractional a
WrapFractional a -> WrapFractional a -> [WrapFractional a]
WrapFractional a
-> WrapFractional a -> WrapFractional a -> [WrapFractional a]
(WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a)
-> (Int -> WrapFractional a)
-> (WrapFractional a -> Int)
-> (WrapFractional a -> [WrapFractional a])
-> (WrapFractional a -> WrapFractional a -> [WrapFractional a])
-> (WrapFractional a -> WrapFractional a -> [WrapFractional a])
-> (WrapFractional a
    -> WrapFractional a -> WrapFractional a -> [WrapFractional a])
-> Enum (WrapFractional a)
forall a. Enum a => Int -> WrapFractional a
forall a. Enum a => WrapFractional a -> Int
forall a. Enum a => WrapFractional a -> [WrapFractional a]
forall a. Enum a => WrapFractional a -> WrapFractional a
forall a.
Enum a =>
WrapFractional a -> WrapFractional a -> [WrapFractional a]
forall a.
Enum a =>
WrapFractional a
-> WrapFractional a -> WrapFractional a -> [WrapFractional a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WrapFractional a
-> WrapFractional a -> WrapFractional a -> [WrapFractional a]
$cenumFromThenTo :: forall a.
Enum a =>
WrapFractional a
-> WrapFractional a -> WrapFractional a -> [WrapFractional a]
enumFromTo :: WrapFractional a -> WrapFractional a -> [WrapFractional a]
$cenumFromTo :: forall a.
Enum a =>
WrapFractional a -> WrapFractional a -> [WrapFractional a]
enumFromThen :: WrapFractional a -> WrapFractional a -> [WrapFractional a]
$cenumFromThen :: forall a.
Enum a =>
WrapFractional a -> WrapFractional a -> [WrapFractional a]
enumFrom :: WrapFractional a -> [WrapFractional a]
$cenumFrom :: forall a. Enum a => WrapFractional a -> [WrapFractional a]
fromEnum :: WrapFractional a -> Int
$cfromEnum :: forall a. Enum a => WrapFractional a -> Int
toEnum :: Int -> WrapFractional a
$ctoEnum :: forall a. Enum a => Int -> WrapFractional a
pred :: WrapFractional a -> WrapFractional a
$cpred :: forall a. Enum a => WrapFractional a -> WrapFractional a
succ :: WrapFractional a -> WrapFractional a
$csucc :: forall a. Enum a => WrapFractional a -> WrapFractional a
Enum, Num (WrapFractional a)
Ord (WrapFractional a)
Num (WrapFractional a)
-> Ord (WrapFractional a)
-> (WrapFractional a -> Rational)
-> Real (WrapFractional a)
WrapFractional a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. Real a => Num (WrapFractional a)
forall a. Real a => Ord (WrapFractional a)
forall a. Real a => WrapFractional a -> Rational
toRational :: WrapFractional a -> Rational
$ctoRational :: forall a. Real a => WrapFractional a -> Rational
$cp2Real :: forall a. Real a => Ord (WrapFractional a)
$cp1Real :: forall a. Real a => Num (WrapFractional a)
P.Real, Num (WrapFractional a)
Num (WrapFractional a)
-> (WrapFractional a -> WrapFractional a -> WrapFractional a)
-> (WrapFractional a -> WrapFractional a)
-> (Rational -> WrapFractional a)
-> Fractional (WrapFractional a)
Rational -> WrapFractional a
WrapFractional a -> WrapFractional a
WrapFractional a -> WrapFractional a -> WrapFractional a
forall a. Fractional a => Num (WrapFractional a)
forall a. Fractional a => Rational -> WrapFractional a
forall a. Fractional a => WrapFractional a -> WrapFractional a
forall a.
Fractional a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> WrapFractional a
$cfromRational :: forall a. Fractional a => Rational -> WrapFractional a
recip :: WrapFractional a -> WrapFractional a
$crecip :: forall a. Fractional a => WrapFractional a -> WrapFractional a
/ :: WrapFractional a -> WrapFractional a -> WrapFractional a
$c/ :: forall a.
Fractional a =>
WrapFractional a -> WrapFractional a -> WrapFractional a
$cp1Fractional :: forall a. Fractional a => Num (WrapFractional a)
P.Fractional, Ptr b -> Int -> IO (WrapFractional a)
Ptr b -> Int -> WrapFractional a -> IO ()
Ptr (WrapFractional a) -> IO (WrapFractional a)
Ptr (WrapFractional a) -> Int -> IO (WrapFractional a)
Ptr (WrapFractional a) -> Int -> WrapFractional a -> IO ()
Ptr (WrapFractional a) -> WrapFractional a -> IO ()
WrapFractional a -> Int
(WrapFractional a -> Int)
-> (WrapFractional a -> Int)
-> (Ptr (WrapFractional a) -> Int -> IO (WrapFractional a))
-> (Ptr (WrapFractional a) -> Int -> WrapFractional a -> IO ())
-> (forall b. Ptr b -> Int -> IO (WrapFractional a))
-> (forall b. Ptr b -> Int -> WrapFractional a -> IO ())
-> (Ptr (WrapFractional a) -> IO (WrapFractional a))
-> (Ptr (WrapFractional a) -> WrapFractional a -> IO ())
-> Storable (WrapFractional a)
forall b. Ptr b -> Int -> IO (WrapFractional a)
forall b. Ptr b -> Int -> WrapFractional a -> IO ()
forall a.
Storable a =>
Ptr (WrapFractional a) -> IO (WrapFractional a)
forall a.
Storable a =>
Ptr (WrapFractional a) -> Int -> IO (WrapFractional a)
forall a.
Storable a =>
Ptr (WrapFractional a) -> Int -> WrapFractional a -> IO ()
forall a.
Storable a =>
Ptr (WrapFractional a) -> WrapFractional a -> IO ()
forall a. Storable a => WrapFractional a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (WrapFractional a)
forall a b. Storable a => Ptr b -> Int -> WrapFractional a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (WrapFractional a) -> WrapFractional a -> IO ()
$cpoke :: forall a.
Storable a =>
Ptr (WrapFractional a) -> WrapFractional a -> IO ()
peek :: Ptr (WrapFractional a) -> IO (WrapFractional a)
$cpeek :: forall a.
Storable a =>
Ptr (WrapFractional a) -> IO (WrapFractional a)
pokeByteOff :: Ptr b -> Int -> WrapFractional a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> WrapFractional a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (WrapFractional a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (WrapFractional a)
pokeElemOff :: Ptr (WrapFractional a) -> Int -> WrapFractional a -> IO ()
$cpokeElemOff :: forall a.
Storable a =>
Ptr (WrapFractional a) -> Int -> WrapFractional a -> IO ()
peekElemOff :: Ptr (WrapFractional a) -> Int -> IO (WrapFractional a)
$cpeekElemOff :: forall a.
Storable a =>
Ptr (WrapFractional a) -> Int -> IO (WrapFractional a)
alignment :: WrapFractional a -> Int
$calignment :: forall a. Storable a => WrapFractional a -> Int
sizeOf :: WrapFractional a -> Int
$csizeOf :: forall a. Storable a => WrapFractional a -> Int
Storable)

instance (P.Num a) => Additive (WrapFractional a) where
  WrapFractional a
a + :: WrapFractional a -> WrapFractional a -> WrapFractional a
+ WrapFractional a
b = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.+ a
b)
  {-# INLINE (+) #-}
  sinnum1p :: Natural -> WrapFractional a -> WrapFractional a
sinnum1p Natural
n (WrapFractional a
a) = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional ((a
1 a -> a -> a
forall a. Num a => a -> a -> a
P.+ Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n) a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum1p #-}

instance (P.Num a) => LeftModule Natural (WrapFractional a) where
  Natural
n .* :: Natural -> WrapFractional a -> WrapFractional a
.* WrapFractional a
r = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Natural (WrapFractional a) where
  WrapFractional a
r *. :: WrapFractional a -> Natural -> WrapFractional a
*. Natural
n = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Monoidal (WrapFractional a) where
  zero :: WrapFractional a
zero = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
0)
  {-# INLINE zero #-}
  sinnum :: Natural -> WrapFractional a -> WrapFractional a
sinnum Natural
n (WrapFractional a
a) = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum #-}

instance (P.Num a) => LeftModule Integer (WrapFractional a) where
  Integer
n .* :: Integer -> WrapFractional a -> WrapFractional a
.* WrapFractional a
r = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Integer (WrapFractional a) where
  WrapFractional a
r *. :: WrapFractional a -> Integer -> WrapFractional a
*. Integer
n = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Group (WrapFractional a) where
  negate :: WrapFractional a -> WrapFractional a
negate (WrapFractional a
a) = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Num a => a -> a
P.negate a
a
  {-# INLINE negate #-}
  WrapFractional a
a - :: WrapFractional a -> WrapFractional a -> WrapFractional a
- WrapFractional a
b = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.- a
b)
  {-# INLINE (-) #-}
  subtract :: WrapFractional a -> WrapFractional a -> WrapFractional a
subtract (WrapFractional a
a) (WrapFractional a
b) = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> a -> a
forall a. Num a => a -> a -> a
P.subtract a
a a
b)
  {-# INLINE subtract #-}
  times :: n -> WrapFractional a -> WrapFractional a
times n
n (WrapFractional a
a) = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ n -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral n
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a
  {-# INLINE times #-}

instance (P.Num a) => Multiplicative (WrapFractional a) where
  WrapFractional a
p * :: WrapFractional a -> WrapFractional a -> WrapFractional a
* WrapFractional a
q = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
p a -> a -> a
forall a. Num a => a -> a -> a
P.* a
q)
  {-# INLINE (*) #-}
  pow1p :: WrapFractional a -> Natural -> WrapFractional a
pow1p (WrapFractional a
p) Natural
n = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
p a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ (Natural
n Natural -> Natural -> Natural
forall r. Additive r => r -> r -> r
+ Natural
1))
  {-# INLINE pow1p #-}

instance (P.Num a) => Unital (WrapFractional a) where
  one :: WrapFractional a
one = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
1
  {-# INLINE one #-}
  pow :: WrapFractional a -> Natural -> WrapFractional a
pow (WrapFractional a
a) Natural
n = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ a
a a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ Natural
n
  {-# INLINE pow #-}

instance P.Num a => Abelian (WrapFractional a)
instance P.Num a => Semiring (WrapFractional a)
instance P.Num a => Rig (WrapFractional a) where
  fromNatural :: Natural -> WrapFractional a
fromNatural = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a)
-> (Natural -> a) -> Natural -> WrapFractional a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral
  {-# INLINE fromNatural #-}
instance P.Num a => Ring (WrapFractional a) where
  fromInteger :: Integer -> WrapFractional a
fromInteger = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a)
-> (Integer -> a) -> Integer -> WrapFractional a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
P.fromInteger
  {-# INLINE fromInteger #-}

instance P.Num a => Commutative (WrapFractional a)

instance (P.Num a, Eq a) => DecidableZero (WrapFractional a) where
  isZero :: WrapFractional a -> Bool
isZero (WrapFractional a
a) = a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0
  {-# INLINE isZero #-}

instance P.Fractional a => Division (WrapFractional a) where
  recip :: WrapFractional a -> WrapFractional a
recip = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a)
-> (WrapFractional a -> a) -> WrapFractional a -> WrapFractional a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Fractional a => a -> a
P.recip (a -> a) -> (WrapFractional a -> a) -> WrapFractional a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapFractional a -> a
forall a. WrapFractional a -> a
unwrapFractional
  {-# INLINE recip #-}
  WrapFractional a
a / :: WrapFractional a -> WrapFractional a -> WrapFractional a
/ WrapFractional a
b = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ a
a a -> a -> a
forall a. Fractional a => a -> a -> a
P./ a
b
  {-# INLINE (/) #-}
  WrapFractional a
a \\ :: WrapFractional a -> WrapFractional a -> WrapFractional a
\\ WrapFractional a
b = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Fractional a => a -> a
P.recip a
a a -> a -> a
forall a. Num a => a -> a -> a
P.* a
b
  {-# INLINE (\\) #-}
  WrapFractional a
a ^ :: WrapFractional a -> n -> WrapFractional a
^ n
n = a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a
a a -> n -> a
forall a b. (Fractional a, Integral b) => a -> b -> a
P.^^ n
n)
  {-# INLINE (^) #-}

instance (Eq a, P.Fractional a) => ZeroProductSemiring (WrapFractional a)
instance (Eq a, P.Fractional a) => DecidableUnits (WrapFractional a) where
  isUnit :: WrapFractional a -> Bool
isUnit (WrapFractional a
r) = a
r a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
0
  {-# INLINE isUnit #-}

  recipUnit :: WrapFractional a -> Maybe (WrapFractional a)
recipUnit (WrapFractional a
r) =
    if a
r a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0
    then Maybe (WrapFractional a)
forall a. Maybe a
Nothing
    else WrapFractional a -> Maybe (WrapFractional a)
forall a. a -> Maybe a
Just (a -> WrapFractional a
forall a. a -> WrapFractional a
WrapFractional (a -> WrapFractional a) -> a -> WrapFractional a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Fractional a => a -> a
P.recip a
r)
  {-# INLINE recipUnit #-}

instance (Eq a, P.Fractional a) => DecidableAssociates (WrapFractional a) where
  isAssociate :: WrapFractional a -> WrapFractional a -> Bool
isAssociate (WrapFractional a
a) (WrapFractional a
b) =
    (a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0 Bool -> Bool -> Bool
&& a
b a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0) Bool -> Bool -> Bool
|| (a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
0 Bool -> Bool -> Bool
&& a
b a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
0)
  {-# INLINE isAssociate #-}

instance (Eq a, P.Fractional a) => UnitNormalForm (WrapFractional a)
instance (Eq a, P.Fractional a) => IntegralDomain (WrapFractional a)
instance (Eq a, P.Fractional a) => GCDDomain (WrapFractional a)
instance (Eq a, P.Fractional a) => Euclidean (WrapFractional a)
instance (Eq a, P.Fractional a) => PID (WrapFractional a)
instance (Eq a, P.Fractional a) => UFD (WrapFractional a)

-- | Similar to @'WrapNum'@, but produces @'Euclidean'@ instances from
--   @'Integral'@s.
--
--   See also: @'WrapFractional'@ and @'WrapNum'@.
newtype WrapIntegral a = WrapIntegral { WrapIntegral a -> a
unwrapIntegral :: a }
  deriving (ReadPrec [WrapIntegral a]
ReadPrec (WrapIntegral a)
Int -> ReadS (WrapIntegral a)
ReadS [WrapIntegral a]
(Int -> ReadS (WrapIntegral a))
-> ReadS [WrapIntegral a]
-> ReadPrec (WrapIntegral a)
-> ReadPrec [WrapIntegral a]
-> Read (WrapIntegral a)
forall a. Read a => ReadPrec [WrapIntegral a]
forall a. Read a => ReadPrec (WrapIntegral a)
forall a. Read a => Int -> ReadS (WrapIntegral a)
forall a. Read a => ReadS [WrapIntegral a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WrapIntegral a]
$creadListPrec :: forall a. Read a => ReadPrec [WrapIntegral a]
readPrec :: ReadPrec (WrapIntegral a)
$creadPrec :: forall a. Read a => ReadPrec (WrapIntegral a)
readList :: ReadS [WrapIntegral a]
$creadList :: forall a. Read a => ReadS [WrapIntegral a]
readsPrec :: Int -> ReadS (WrapIntegral a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WrapIntegral a)
Read, Int -> WrapIntegral a -> ShowS
[WrapIntegral a] -> ShowS
WrapIntegral a -> String
(Int -> WrapIntegral a -> ShowS)
-> (WrapIntegral a -> String)
-> ([WrapIntegral a] -> ShowS)
-> Show (WrapIntegral a)
forall a. Show a => Int -> WrapIntegral a -> ShowS
forall a. Show a => [WrapIntegral a] -> ShowS
forall a. Show a => WrapIntegral a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapIntegral a] -> ShowS
$cshowList :: forall a. Show a => [WrapIntegral a] -> ShowS
show :: WrapIntegral a -> String
$cshow :: forall a. Show a => WrapIntegral a -> String
showsPrec :: Int -> WrapIntegral a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WrapIntegral a -> ShowS
Show, WrapIntegral a -> WrapIntegral a -> Bool
(WrapIntegral a -> WrapIntegral a -> Bool)
-> (WrapIntegral a -> WrapIntegral a -> Bool)
-> Eq (WrapIntegral a)
forall a. Eq a => WrapIntegral a -> WrapIntegral a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapIntegral a -> WrapIntegral a -> Bool
$c/= :: forall a. Eq a => WrapIntegral a -> WrapIntegral a -> Bool
== :: WrapIntegral a -> WrapIntegral a -> Bool
$c== :: forall a. Eq a => WrapIntegral a -> WrapIntegral a -> Bool
Eq, Eq (WrapIntegral a)
Eq (WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> Ordering)
-> (WrapIntegral a -> WrapIntegral a -> Bool)
-> (WrapIntegral a -> WrapIntegral a -> Bool)
-> (WrapIntegral a -> WrapIntegral a -> Bool)
-> (WrapIntegral a -> WrapIntegral a -> Bool)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> Ord (WrapIntegral a)
WrapIntegral a -> WrapIntegral a -> Bool
WrapIntegral a -> WrapIntegral a -> Ordering
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
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
forall a. Ord a => Eq (WrapIntegral a)
forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Bool
forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Ordering
forall a.
Ord a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
min :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cmin :: forall a.
Ord a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
max :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cmax :: forall a.
Ord a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
>= :: WrapIntegral a -> WrapIntegral a -> Bool
$c>= :: forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Bool
> :: WrapIntegral a -> WrapIntegral a -> Bool
$c> :: forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Bool
<= :: WrapIntegral a -> WrapIntegral a -> Bool
$c<= :: forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Bool
< :: WrapIntegral a -> WrapIntegral a -> Bool
$c< :: forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Bool
compare :: WrapIntegral a -> WrapIntegral a -> Ordering
$ccompare :: forall a. Ord a => WrapIntegral a -> WrapIntegral a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (WrapIntegral a)
Ord, Integer -> WrapIntegral a
WrapIntegral a -> WrapIntegral a
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
(WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a)
-> (Integer -> WrapIntegral a)
-> Num (WrapIntegral a)
forall a. Num a => Integer -> WrapIntegral a
forall a. Num a => WrapIntegral a -> WrapIntegral a
forall a.
Num a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WrapIntegral a
$cfromInteger :: forall a. Num a => Integer -> WrapIntegral a
signum :: WrapIntegral a -> WrapIntegral a
$csignum :: forall a. Num a => WrapIntegral a -> WrapIntegral a
abs :: WrapIntegral a -> WrapIntegral a
$cabs :: forall a. Num a => WrapIntegral a -> WrapIntegral a
negate :: WrapIntegral a -> WrapIntegral a
$cnegate :: forall a. Num a => WrapIntegral a -> WrapIntegral a
* :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$c* :: forall a.
Num a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
- :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$c- :: forall a.
Num a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
+ :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$c+ :: forall a.
Num a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
P.Num, Num (WrapIntegral a)
Ord (WrapIntegral a)
Num (WrapIntegral a)
-> Ord (WrapIntegral a)
-> (WrapIntegral a -> Rational)
-> Real (WrapIntegral a)
WrapIntegral a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. Real a => Num (WrapIntegral a)
forall a. Real a => Ord (WrapIntegral a)
forall a. Real a => WrapIntegral a -> Rational
toRational :: WrapIntegral a -> Rational
$ctoRational :: forall a. Real a => WrapIntegral a -> Rational
$cp2Real :: forall a. Real a => Ord (WrapIntegral a)
$cp1Real :: forall a. Real a => Num (WrapIntegral a)
P.Real, Int -> WrapIntegral a
WrapIntegral a -> Int
WrapIntegral a -> [WrapIntegral a]
WrapIntegral a -> WrapIntegral a
WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
WrapIntegral a
-> WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
(WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a)
-> (Int -> WrapIntegral a)
-> (WrapIntegral a -> Int)
-> (WrapIntegral a -> [WrapIntegral a])
-> (WrapIntegral a -> WrapIntegral a -> [WrapIntegral a])
-> (WrapIntegral a -> WrapIntegral a -> [WrapIntegral a])
-> (WrapIntegral a
    -> WrapIntegral a -> WrapIntegral a -> [WrapIntegral a])
-> Enum (WrapIntegral a)
forall a. Enum a => Int -> WrapIntegral a
forall a. Enum a => WrapIntegral a -> Int
forall a. Enum a => WrapIntegral a -> [WrapIntegral a]
forall a. Enum a => WrapIntegral a -> WrapIntegral a
forall a.
Enum a =>
WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
forall a.
Enum a =>
WrapIntegral a
-> WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WrapIntegral a
-> WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
$cenumFromThenTo :: forall a.
Enum a =>
WrapIntegral a
-> WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
enumFromTo :: WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
$cenumFromTo :: forall a.
Enum a =>
WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
enumFromThen :: WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
$cenumFromThen :: forall a.
Enum a =>
WrapIntegral a -> WrapIntegral a -> [WrapIntegral a]
enumFrom :: WrapIntegral a -> [WrapIntegral a]
$cenumFrom :: forall a. Enum a => WrapIntegral a -> [WrapIntegral a]
fromEnum :: WrapIntegral a -> Int
$cfromEnum :: forall a. Enum a => WrapIntegral a -> Int
toEnum :: Int -> WrapIntegral a
$ctoEnum :: forall a. Enum a => Int -> WrapIntegral a
pred :: WrapIntegral a -> WrapIntegral a
$cpred :: forall a. Enum a => WrapIntegral a -> WrapIntegral a
succ :: WrapIntegral a -> WrapIntegral a
$csucc :: forall a. Enum a => WrapIntegral a -> WrapIntegral a
P.Enum, Enum (WrapIntegral a)
Real (WrapIntegral a)
Real (WrapIntegral a)
-> Enum (WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a -> WrapIntegral a -> WrapIntegral a)
-> (WrapIntegral a
    -> WrapIntegral a -> (WrapIntegral a, WrapIntegral a))
-> (WrapIntegral a
    -> WrapIntegral a -> (WrapIntegral a, WrapIntegral a))
-> (WrapIntegral a -> Integer)
-> Integral (WrapIntegral a)
WrapIntegral a -> Integer
WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
forall a. Integral a => Enum (WrapIntegral a)
forall a. Integral a => Real (WrapIntegral a)
forall a. Integral a => WrapIntegral a -> Integer
forall a.
Integral a =>
WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
forall a.
Integral a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: WrapIntegral a -> Integer
$ctoInteger :: forall a. Integral a => WrapIntegral a -> Integer
divMod :: WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
$cdivMod :: forall a.
Integral a =>
WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
quotRem :: WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
$cquotRem :: forall a.
Integral a =>
WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
mod :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cmod :: forall a.
Integral a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
div :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cdiv :: forall a.
Integral a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
rem :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$crem :: forall a.
Integral a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
quot :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cquot :: forall a.
Integral a =>
WrapIntegral a -> WrapIntegral a -> WrapIntegral a
$cp2Integral :: forall a. Integral a => Enum (WrapIntegral a)
$cp1Integral :: forall a. Integral a => Real (WrapIntegral a)
P.Integral, Ptr b -> Int -> IO (WrapIntegral a)
Ptr b -> Int -> WrapIntegral a -> IO ()
Ptr (WrapIntegral a) -> IO (WrapIntegral a)
Ptr (WrapIntegral a) -> Int -> IO (WrapIntegral a)
Ptr (WrapIntegral a) -> Int -> WrapIntegral a -> IO ()
Ptr (WrapIntegral a) -> WrapIntegral a -> IO ()
WrapIntegral a -> Int
(WrapIntegral a -> Int)
-> (WrapIntegral a -> Int)
-> (Ptr (WrapIntegral a) -> Int -> IO (WrapIntegral a))
-> (Ptr (WrapIntegral a) -> Int -> WrapIntegral a -> IO ())
-> (forall b. Ptr b -> Int -> IO (WrapIntegral a))
-> (forall b. Ptr b -> Int -> WrapIntegral a -> IO ())
-> (Ptr (WrapIntegral a) -> IO (WrapIntegral a))
-> (Ptr (WrapIntegral a) -> WrapIntegral a -> IO ())
-> Storable (WrapIntegral a)
forall b. Ptr b -> Int -> IO (WrapIntegral a)
forall b. Ptr b -> Int -> WrapIntegral a -> IO ()
forall a. Storable a => Ptr (WrapIntegral a) -> IO (WrapIntegral a)
forall a.
Storable a =>
Ptr (WrapIntegral a) -> Int -> IO (WrapIntegral a)
forall a.
Storable a =>
Ptr (WrapIntegral a) -> Int -> WrapIntegral a -> IO ()
forall a.
Storable a =>
Ptr (WrapIntegral a) -> WrapIntegral a -> IO ()
forall a. Storable a => WrapIntegral a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (WrapIntegral a)
forall a b. Storable a => Ptr b -> Int -> WrapIntegral a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (WrapIntegral a) -> WrapIntegral a -> IO ()
$cpoke :: forall a.
Storable a =>
Ptr (WrapIntegral a) -> WrapIntegral a -> IO ()
peek :: Ptr (WrapIntegral a) -> IO (WrapIntegral a)
$cpeek :: forall a. Storable a => Ptr (WrapIntegral a) -> IO (WrapIntegral a)
pokeByteOff :: Ptr b -> Int -> WrapIntegral a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> WrapIntegral a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (WrapIntegral a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (WrapIntegral a)
pokeElemOff :: Ptr (WrapIntegral a) -> Int -> WrapIntegral a -> IO ()
$cpokeElemOff :: forall a.
Storable a =>
Ptr (WrapIntegral a) -> Int -> WrapIntegral a -> IO ()
peekElemOff :: Ptr (WrapIntegral a) -> Int -> IO (WrapIntegral a)
$cpeekElemOff :: forall a.
Storable a =>
Ptr (WrapIntegral a) -> Int -> IO (WrapIntegral a)
alignment :: WrapIntegral a -> Int
$calignment :: forall a. Storable a => WrapIntegral a -> Int
sizeOf :: WrapIntegral a -> Int
$csizeOf :: forall a. Storable a => WrapIntegral a -> Int
Storable)

instance (P.Num a) => Additive (WrapIntegral a) where
  WrapIntegral a
a + :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
+ WrapIntegral a
b = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.+ a
b)
  {-# INLINE (+) #-}
  sinnum1p :: Natural -> WrapIntegral a -> WrapIntegral a
sinnum1p Natural
n (WrapIntegral a
a) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral ((a
1 a -> a -> a
forall a. Num a => a -> a -> a
P.+ Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n) a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum1p #-}

instance (P.Num a) => LeftModule Natural (WrapIntegral a) where
  Natural
n .* :: Natural -> WrapIntegral a -> WrapIntegral a
.* WrapIntegral a
r = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Natural (WrapIntegral a) where
  WrapIntegral a
r *. :: WrapIntegral a -> Natural -> WrapIntegral a
*. Natural
n = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Natural
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Monoidal (WrapIntegral a) where
  zero :: WrapIntegral a
zero = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
0)
  {-# INLINE zero #-}
  sinnum :: Natural -> WrapIntegral a -> WrapIntegral a
sinnum Natural
n (WrapIntegral a
a) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (Natural -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a)
  {-# INLINE sinnum #-}

instance (P.Num a) => LeftModule Integer (WrapIntegral a) where
  Integer
n .* :: Integer -> WrapIntegral a -> WrapIntegral a
.* WrapIntegral a
r = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
r)
  {-# INLINE (.*) #-}

instance (P.Num a) => RightModule Integer (WrapIntegral a) where
  WrapIntegral a
r *. :: WrapIntegral a -> Integer -> WrapIntegral a
*. Integer
n = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
r a -> a -> a
forall a. Num a => a -> a -> a
P.* Integer -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral Integer
n)
  {-# INLINE (*.) #-}

instance (P.Num a) => Group (WrapIntegral a) where
  negate :: WrapIntegral a -> WrapIntegral a
negate (WrapIntegral a
a) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Num a => a -> a
P.negate a
a
  {-# INLINE negate #-}
  WrapIntegral a
a - :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
- WrapIntegral a
b = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
a a -> a -> a
forall a. Num a => a -> a -> a
P.- a
b)
  {-# INLINE (-) #-}
  subtract :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
subtract (WrapIntegral a
a) (WrapIntegral a
b) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> a -> a
forall a. Num a => a -> a -> a
P.subtract a
a a
b)
  {-# INLINE subtract #-}
  times :: n -> WrapIntegral a -> WrapIntegral a
times n
n (WrapIntegral a
a) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ n -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral n
n a -> a -> a
forall a. Num a => a -> a -> a
P.* a
a
  {-# INLINE times #-}

instance (P.Num a) => Multiplicative (WrapIntegral a) where
  WrapIntegral a
p * :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
* WrapIntegral a
q = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
p a -> a -> a
forall a. Num a => a -> a -> a
P.* a
q)
  {-# INLINE (*) #-}
  pow1p :: WrapIntegral a -> Natural -> WrapIntegral a
pow1p (WrapIntegral a
p) Natural
n = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a
p a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ (Natural
n Natural -> Natural -> Natural
forall r. Additive r => r -> r -> r
+ Natural
1))
  {-# INLINE pow1p #-}

instance (P.Num a) => Unital (WrapIntegral a) where
  one :: WrapIntegral a
one = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ Integer -> a
forall a. Num a => Integer -> a
P.fromInteger Integer
1
  {-# INLINE one #-}
  pow :: WrapIntegral a -> Natural -> WrapIntegral a
pow (WrapIntegral a
a) Natural
n = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a
a a -> Natural -> a
forall a b. (Num a, Integral b) => a -> b -> a
P.^ Natural
n
  {-# INLINE pow #-}

instance P.Num a => Abelian (WrapIntegral a)
instance P.Num a => Semiring (WrapIntegral a)
instance P.Num a => Rig (WrapIntegral a) where
  fromNatural :: Natural -> WrapIntegral a
fromNatural = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a)
-> (Natural -> a) -> Natural -> WrapIntegral a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> a
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral
  {-# INLINE fromNatural #-}
instance P.Num a => Ring (WrapIntegral a) where
  fromInteger :: Integer -> WrapIntegral a
fromInteger = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a)
-> (Integer -> a) -> Integer -> WrapIntegral a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
P.fromInteger
  {-# INLINE fromInteger #-}

instance P.Num a => Commutative (WrapIntegral a)

instance (P.Num a, Eq a) => DecidableZero (WrapIntegral a) where
  isZero :: WrapIntegral a -> Bool
isZero (WrapIntegral a
a) = a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0
  {-# INLINE isZero #-}

instance (Eq a, P.Integral a) => ZeroProductSemiring (WrapIntegral a)
instance (Eq a, P.Integral a) => DecidableUnits (WrapIntegral a) where
  isUnit :: WrapIntegral a -> Bool
isUnit (WrapIntegral a
r) = a
r a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
1 Bool -> Bool -> Bool
|| a
r a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a -> a
forall a. Num a => a -> a
P.negate a
1
  {-# INLINE isUnit #-}

  recipUnit :: WrapIntegral a -> Maybe (WrapIntegral a)
recipUnit (WrapIntegral a
r) =
    if WrapIntegral a -> Bool
forall r. DecidableUnits r => r -> Bool
isUnit (a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
r)
    then WrapIntegral a -> Maybe (WrapIntegral a)
forall a. a -> Maybe a
Just (a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
r)
    else Maybe (WrapIntegral a)
forall a. Maybe a
Nothing
  {-# INLINE recipUnit #-}

instance (Eq a, P.Integral a) => DecidableAssociates (WrapIntegral a) where
  isAssociate :: WrapIntegral a -> WrapIntegral a -> Bool
isAssociate (WrapIntegral a
a) (WrapIntegral a
b) = a -> a
forall a. Num a => a -> a
P.abs a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a -> a
forall a. Num a => a -> a
P.abs a
b
  {-# INLINE isAssociate #-}

instance (Eq a, P.Integral a) => UnitNormalForm (WrapIntegral a) where
  splitUnit :: WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
splitUnit (WrapIntegral a
0) = (a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
1, a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
0)
  splitUnit (WrapIntegral a
a) = (a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Num a => a -> a
P.signum a
a, a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Num a => a -> a
P.abs a
a)
  {-# INLINE splitUnit #-}

instance (Eq a, P.Integral a) => IntegralDomain (WrapIntegral a)
instance (Eq a, P.Integral a) => GCDDomain (WrapIntegral a) where
  gcd :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
gcd (WrapIntegral a
a) (WrapIntegral a
b) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> a -> a
forall a. Integral a => a -> a -> a
P.gcd a
a a
b)
  {-# INLINE gcd #-}

  lcm :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
lcm (WrapIntegral a
a) (WrapIntegral a
b) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> a -> a
forall a. Integral a => a -> a -> a
P.lcm a
a a
b)
  {-# INLINE lcm #-}

instance (Eq a, P.Integral a) => Euclidean (WrapIntegral a) where
  divide :: WrapIntegral a
-> WrapIntegral a -> (WrapIntegral a, WrapIntegral a)
divide (WrapIntegral a
f) (WrapIntegral a
g) =
    let (a
q, a
r) = a -> a -> (a, a)
forall a. Integral a => a -> a -> (a, a)
P.divMod a
f a
g
    in (a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
q, a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral a
r)
  {-# INLINE divide #-}
  degree :: WrapIntegral a -> Maybe Natural
degree (WrapIntegral a
0) = Maybe Natural
forall a. Maybe a
Nothing
  degree (WrapIntegral a
a) = Natural -> Maybe Natural
forall a. a -> Maybe a
Just (Natural -> Maybe Natural) -> Natural -> Maybe Natural
forall a b. (a -> b) -> a -> b
$ a -> Natural
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (a -> a
forall a. Num a => a -> a
P.abs a
a)
  {-# INLINE degree #-}

  quot :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
quot (WrapIntegral a
a) (WrapIntegral a
b) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a -> a -> a
forall a. Integral a => a -> a -> a
P.div a
a a
b
  {-# INLINE quot #-}
  rem :: WrapIntegral a -> WrapIntegral a -> WrapIntegral a
rem  (WrapIntegral a
a) (WrapIntegral a
b) = a -> WrapIntegral a
forall a. a -> WrapIntegral a
WrapIntegral (a -> WrapIntegral a) -> a -> WrapIntegral a
forall a b. (a -> b) -> a -> b
$ a -> a -> a
forall a. Integral a => a -> a -> a
P.mod a
a a
b
  {-# INLINE rem #-}

instance (Eq a, P.Integral a) => PID (WrapIntegral a)
instance (Eq a, P.Integral a) => UFD (WrapIntegral a)

-- | Turning types from @'Numeric.Algebra'@ into Prelude's Num instances.
--
--   N.B. Since @'Real'@'s @'toRational'@ constraint is too tight,
--        we won't provide the inverse of @'WrapIntegral'@ and
--        provide @'Fractional'@ instance only.
newtype WrapAlgebra a = WrapAlgebra { WrapAlgebra a -> a
unwrapAlgebra :: a }
                      deriving ( ReadPrec [WrapAlgebra a]
ReadPrec (WrapAlgebra a)
Int -> ReadS (WrapAlgebra a)
ReadS [WrapAlgebra a]
(Int -> ReadS (WrapAlgebra a))
-> ReadS [WrapAlgebra a]
-> ReadPrec (WrapAlgebra a)
-> ReadPrec [WrapAlgebra a]
-> Read (WrapAlgebra a)
forall a. Read a => ReadPrec [WrapAlgebra a]
forall a. Read a => ReadPrec (WrapAlgebra a)
forall a. Read a => Int -> ReadS (WrapAlgebra a)
forall a. Read a => ReadS [WrapAlgebra a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WrapAlgebra a]
$creadListPrec :: forall a. Read a => ReadPrec [WrapAlgebra a]
readPrec :: ReadPrec (WrapAlgebra a)
$creadPrec :: forall a. Read a => ReadPrec (WrapAlgebra a)
readList :: ReadS [WrapAlgebra a]
$creadList :: forall a. Read a => ReadS [WrapAlgebra a]
readsPrec :: Int -> ReadS (WrapAlgebra a)
$creadsPrec :: forall a. Read a => Int -> ReadS (WrapAlgebra a)
Read, Int -> WrapAlgebra a -> ShowS
[WrapAlgebra a] -> ShowS
WrapAlgebra a -> String
(Int -> WrapAlgebra a -> ShowS)
-> (WrapAlgebra a -> String)
-> ([WrapAlgebra a] -> ShowS)
-> Show (WrapAlgebra a)
forall a. Show a => Int -> WrapAlgebra a -> ShowS
forall a. Show a => [WrapAlgebra a] -> ShowS
forall a. Show a => WrapAlgebra a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapAlgebra a] -> ShowS
$cshowList :: forall a. Show a => [WrapAlgebra a] -> ShowS
show :: WrapAlgebra a -> String
$cshow :: forall a. Show a => WrapAlgebra a -> String
showsPrec :: Int -> WrapAlgebra a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> WrapAlgebra a -> ShowS
Show, WrapAlgebra a -> WrapAlgebra a -> Bool
(WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool) -> Eq (WrapAlgebra a)
forall a. Eq a => WrapAlgebra a -> WrapAlgebra a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c/= :: forall a. Eq a => WrapAlgebra a -> WrapAlgebra a -> Bool
== :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c== :: forall a. Eq a => WrapAlgebra a -> WrapAlgebra a -> Bool
Eq, Eq (WrapAlgebra a)
Eq (WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> Ordering)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> Ord (WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> Bool
WrapAlgebra a -> WrapAlgebra a -> Ordering
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
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
forall a. Ord a => Eq (WrapAlgebra a)
forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Bool
forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Ordering
forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
min :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$cmin :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
max :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$cmax :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
>= :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c>= :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Bool
> :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c> :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Bool
<= :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c<= :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Bool
< :: WrapAlgebra a -> WrapAlgebra a -> Bool
$c< :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Bool
compare :: WrapAlgebra a -> WrapAlgebra a -> Ordering
$ccompare :: forall a. Ord a => WrapAlgebra a -> WrapAlgebra a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (WrapAlgebra a)
Ord, Natural -> WrapAlgebra a -> WrapAlgebra a
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
(WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (Natural -> WrapAlgebra a -> WrapAlgebra a)
-> (forall (f :: * -> *) a.
    Foldable1 f =>
    (a -> WrapAlgebra a) -> f a -> WrapAlgebra a)
-> Additive (WrapAlgebra a)
forall a. Additive a => Natural -> WrapAlgebra a -> WrapAlgebra a
forall a.
Additive a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall a (f :: * -> *) a.
(Additive a, Foldable1 f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
forall r.
(r -> r -> r)
-> (Natural -> r -> r)
-> (forall (f :: * -> *) a. Foldable1 f => (a -> r) -> f a -> r)
-> Additive r
forall (f :: * -> *) a.
Foldable1 f =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
sumWith1 :: (a -> WrapAlgebra a) -> f a -> WrapAlgebra a
$csumWith1 :: forall a (f :: * -> *) a.
(Additive a, Foldable1 f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
sinnum1p :: Natural -> WrapAlgebra a -> WrapAlgebra a
$csinnum1p :: forall a. Additive a => Natural -> WrapAlgebra a -> WrapAlgebra a
+ :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$c+ :: forall a.
Additive a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
Additive
                               , Multiplicative (WrapAlgebra a)
WrapAlgebra a
Multiplicative (WrapAlgebra a)
-> WrapAlgebra a
-> (WrapAlgebra a -> Natural -> WrapAlgebra a)
-> (forall (f :: * -> *) a.
    Foldable f =>
    (a -> WrapAlgebra a) -> f a -> WrapAlgebra a)
-> Unital (WrapAlgebra a)
WrapAlgebra a -> Natural -> WrapAlgebra a
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
forall r.
Multiplicative r
-> r
-> (r -> Natural -> r)
-> (forall (f :: * -> *) a. Foldable f => (a -> r) -> f a -> r)
-> Unital r
forall a. Unital a => Multiplicative (WrapAlgebra a)
forall a. Unital a => WrapAlgebra a
forall a. Unital a => WrapAlgebra a -> Natural -> WrapAlgebra a
forall a (f :: * -> *) a.
(Unital a, Foldable f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
forall (f :: * -> *) a.
Foldable f =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
productWith :: (a -> WrapAlgebra a) -> f a -> WrapAlgebra a
$cproductWith :: forall a (f :: * -> *) a.
(Unital a, Foldable f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
pow :: WrapAlgebra a -> Natural -> WrapAlgebra a
$cpow :: forall a. Unital a => WrapAlgebra a -> Natural -> WrapAlgebra a
one :: WrapAlgebra a
$cone :: forall a. Unital a => WrapAlgebra a
$cp1Unital :: forall a. Unital a => Multiplicative (WrapAlgebra a)
Unital, WrapAlgebra a -> Natural -> WrapAlgebra a
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
(WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a -> Natural -> WrapAlgebra a)
-> (forall (f :: * -> *) a.
    Foldable1 f =>
    (a -> WrapAlgebra a) -> f a -> WrapAlgebra a)
-> Multiplicative (WrapAlgebra a)
forall a.
Multiplicative a =>
WrapAlgebra a -> Natural -> WrapAlgebra a
forall a.
Multiplicative a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall a (f :: * -> *) a.
(Multiplicative a, Foldable1 f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
forall r.
(r -> r -> r)
-> (r -> Natural -> r)
-> (forall (f :: * -> *) a. Foldable1 f => (a -> r) -> f a -> r)
-> Multiplicative r
forall (f :: * -> *) a.
Foldable1 f =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
productWith1 :: (a -> WrapAlgebra a) -> f a -> WrapAlgebra a
$cproductWith1 :: forall a (f :: * -> *) a.
(Multiplicative a, Foldable1 f) =>
(a -> WrapAlgebra a) -> f a -> WrapAlgebra a
pow1p :: WrapAlgebra a -> Natural -> WrapAlgebra a
$cpow1p :: forall a.
Multiplicative a =>
WrapAlgebra a -> Natural -> WrapAlgebra a
* :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$c* :: forall a.
Multiplicative a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
Multiplicative, Additive (WrapAlgebra a)
Additive (WrapAlgebra a) -> Abelian (WrapAlgebra a)
forall r. Additive r -> Abelian r
forall a. Additive a => Additive (WrapAlgebra a)
Abelian
                               , Multiplicative (WrapAlgebra a)
Multiplicative (WrapAlgebra a) -> Commutative (WrapAlgebra a)
forall a. Multiplicative a => Multiplicative (WrapAlgebra a)
forall r. Multiplicative r -> Commutative r
Commutative, Abelian (WrapAlgebra a)
Additive (WrapAlgebra a)
Multiplicative (WrapAlgebra a)
Additive (WrapAlgebra a)
-> Abelian (WrapAlgebra a)
-> Multiplicative (WrapAlgebra a)
-> Semiring (WrapAlgebra a)
forall r. Additive r -> Abelian r -> Multiplicative r -> Semiring r
forall a. (Additive a, Multiplicative a) => Abelian (WrapAlgebra a)
forall a.
(Additive a, Multiplicative a) =>
Additive (WrapAlgebra a)
forall a.
(Additive a, Multiplicative a) =>
Multiplicative (WrapAlgebra a)
$cp3Semiring :: forall a.
(Additive a, Multiplicative a) =>
Multiplicative (WrapAlgebra a)
$cp2Semiring :: forall a. (Additive a, Multiplicative a) => Abelian (WrapAlgebra a)
$cp1Semiring :: forall a.
(Additive a, Multiplicative a) =>
Additive (WrapAlgebra a)
Semiring, Monoidal (WrapAlgebra a)
Semiring (WrapAlgebra a)
Unital (WrapAlgebra a)
Natural -> WrapAlgebra a
Semiring (WrapAlgebra a)
-> Unital (WrapAlgebra a)
-> Monoidal (WrapAlgebra a)
-> (Natural -> WrapAlgebra a)
-> Rig (WrapAlgebra a)
forall r.
Semiring r -> Unital r -> Monoidal r -> (Natural -> r) -> Rig r
forall a. Rig a => Monoidal (WrapAlgebra a)
forall a. Rig a => Semiring (WrapAlgebra a)
forall a. Rig a => Unital (WrapAlgebra a)
forall a. Rig a => Natural -> WrapAlgebra a
fromNatural :: Natural -> WrapAlgebra a
$cfromNatural :: forall a. Rig a => Natural -> WrapAlgebra a
$cp3Rig :: forall a. Rig a => Monoidal (WrapAlgebra a)
$cp2Rig :: forall a. Rig a => Unital (WrapAlgebra a)
$cp1Rig :: forall a. Rig a => Semiring (WrapAlgebra a)
Rig
                               , Rig (WrapAlgebra a)
Rng (WrapAlgebra a)
Integer -> WrapAlgebra a
Rig (WrapAlgebra a)
-> Rng (WrapAlgebra a)
-> (Integer -> WrapAlgebra a)
-> Ring (WrapAlgebra a)
forall r. Rig r -> Rng r -> (Integer -> r) -> Ring r
forall a. Ring a => Rig (WrapAlgebra a)
forall a. Ring a => Rng (WrapAlgebra a)
forall a. Ring a => Integer -> WrapAlgebra a
fromInteger :: Integer -> WrapAlgebra a
$cfromInteger :: forall a. Ring a => Integer -> WrapAlgebra a
$cp2Ring :: forall a. Ring a => Rng (WrapAlgebra a)
$cp1Ring :: forall a. Ring a => Rig (WrapAlgebra a)
Ring, Unital (WrapAlgebra a)
Unital (WrapAlgebra a)
-> (WrapAlgebra a -> Maybe (WrapAlgebra a))
-> (WrapAlgebra a -> Bool)
-> (forall n.
    Integral n =>
    WrapAlgebra a -> n -> Maybe (WrapAlgebra a))
-> DecidableUnits (WrapAlgebra a)
WrapAlgebra a -> Bool
WrapAlgebra a -> Maybe (WrapAlgebra a)
WrapAlgebra a -> n -> Maybe (WrapAlgebra a)
forall n. Integral n => WrapAlgebra a -> n -> Maybe (WrapAlgebra a)
forall r.
Unital r
-> (r -> Maybe r)
-> (r -> Bool)
-> (forall n. Integral n => r -> n -> Maybe r)
-> DecidableUnits r
forall a. DecidableUnits a => Unital (WrapAlgebra a)
forall a. DecidableUnits a => WrapAlgebra a -> Bool
forall a.
DecidableUnits a =>
WrapAlgebra a -> Maybe (WrapAlgebra a)
forall a n.
(DecidableUnits a, Integral n) =>
WrapAlgebra a -> n -> Maybe (WrapAlgebra a)
^? :: WrapAlgebra a -> n -> Maybe (WrapAlgebra a)
$c^? :: forall a n.
(DecidableUnits a, Integral n) =>
WrapAlgebra a -> n -> Maybe (WrapAlgebra a)
isUnit :: WrapAlgebra a -> Bool
$cisUnit :: forall a. DecidableUnits a => WrapAlgebra a -> Bool
recipUnit :: WrapAlgebra a -> Maybe (WrapAlgebra a)
$crecipUnit :: forall a.
DecidableUnits a =>
WrapAlgebra a -> Maybe (WrapAlgebra a)
$cp1DecidableUnits :: forall a. DecidableUnits a => Unital (WrapAlgebra a)
DecidableUnits, DecidableAssociates (WrapAlgebra a)
DecidableUnits (WrapAlgebra a)
DecidableUnits (WrapAlgebra a)
-> DecidableAssociates (WrapAlgebra a)
-> (WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a))
-> UnitNormalForm (WrapAlgebra a)
WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
forall r.
DecidableUnits r
-> DecidableAssociates r -> (r -> (r, r)) -> UnitNormalForm r
forall a. UnitNormalForm a => DecidableAssociates (WrapAlgebra a)
forall a. UnitNormalForm a => DecidableUnits (WrapAlgebra a)
forall a.
UnitNormalForm a =>
WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
splitUnit :: WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
$csplitUnit :: forall a.
UnitNormalForm a =>
WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
$cp2UnitNormalForm :: forall a. UnitNormalForm a => DecidableAssociates (WrapAlgebra a)
$cp1UnitNormalForm :: forall a. UnitNormalForm a => DecidableUnits (WrapAlgebra a)
UnitNormalForm
                               , Monoidal (WrapAlgebra a)
Monoidal (WrapAlgebra a)
-> (WrapAlgebra a -> Bool) -> DecidableZero (WrapAlgebra a)
WrapAlgebra a -> Bool
forall r. Monoidal r -> (r -> Bool) -> DecidableZero r
forall a. DecidableZero a => Monoidal (WrapAlgebra a)
forall a. DecidableZero a => WrapAlgebra a -> Bool
isZero :: WrapAlgebra a -> Bool
$cisZero :: forall a. DecidableZero a => WrapAlgebra a -> Bool
$cp1DecidableZero :: forall a. DecidableZero a => Monoidal (WrapAlgebra a)
DecidableZero, PID (WrapAlgebra a)
PID (WrapAlgebra a)
-> (WrapAlgebra a -> Maybe Natural)
-> (WrapAlgebra a
    -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a))
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> Euclidean (WrapAlgebra a)
WrapAlgebra a -> Maybe Natural
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall a. Euclidean a => PID (WrapAlgebra a)
forall a. Euclidean a => WrapAlgebra a -> Maybe Natural
forall a.
Euclidean a =>
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
forall a.
Euclidean a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall d.
PID d
-> (d -> Maybe Natural)
-> (d -> d -> (d, d))
-> (d -> d -> d)
-> (d -> d -> d)
-> Euclidean d
rem :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$crem :: forall a.
Euclidean a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
quot :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$cquot :: forall a.
Euclidean a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
divide :: WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
$cdivide :: forall a.
Euclidean a =>
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
degree :: WrapAlgebra a -> Maybe Natural
$cdegree :: forall a. Euclidean a => WrapAlgebra a -> Maybe Natural
$cp1Euclidean :: forall a. Euclidean a => PID (WrapAlgebra a)
Euclidean, Unital (WrapAlgebra a)
Unital (WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (forall n. Integral n => WrapAlgebra a -> n -> WrapAlgebra a)
-> Division (WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a
WrapAlgebra a -> n -> WrapAlgebra a
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall n. Integral n => WrapAlgebra a -> n -> WrapAlgebra a
forall a. Division a => Unital (WrapAlgebra a)
forall a. Division a => WrapAlgebra a -> WrapAlgebra a
forall a.
Division a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall a n.
(Division a, Integral n) =>
WrapAlgebra a -> n -> WrapAlgebra a
forall r.
Unital r
-> (r -> r)
-> (r -> r -> r)
-> (r -> r -> r)
-> (forall n. Integral n => r -> n -> r)
-> Division r
^ :: WrapAlgebra a -> n -> WrapAlgebra a
$c^ :: forall a n.
(Division a, Integral n) =>
WrapAlgebra a -> n -> WrapAlgebra a
\\ :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$c\\ :: forall a.
Division a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
/ :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$c/ :: forall a.
Division a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
recip :: WrapAlgebra a -> WrapAlgebra a
$crecip :: forall a. Division a => WrapAlgebra a -> WrapAlgebra a
$cp1Division :: forall a. Division a => Unital (WrapAlgebra a)
Division
                               , UFD (WrapAlgebra a)
UFD (WrapAlgebra a)
-> (WrapAlgebra a
    -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a, WrapAlgebra a))
-> PID (WrapAlgebra a)
WrapAlgebra a
-> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a, WrapAlgebra a)
forall a. PID a => UFD (WrapAlgebra a)
forall a.
PID a =>
WrapAlgebra a
-> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a, WrapAlgebra a)
forall d. UFD d -> (d -> d -> (d, d, d)) -> PID d
egcd :: WrapAlgebra a
-> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a, WrapAlgebra a)
$cegcd :: forall a.
PID a =>
WrapAlgebra a
-> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a, WrapAlgebra a)
$cp1PID :: forall a. PID a => UFD (WrapAlgebra a)
PID , GCDDomain (WrapAlgebra a)
GCDDomain (WrapAlgebra a) -> UFD (WrapAlgebra a)
forall a. GCDDomain a => GCDDomain (WrapAlgebra a)
forall d. GCDDomain d -> UFD d
UFD, Unital (WrapAlgebra a)
Unital (WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> DecidableAssociates (WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> Bool
forall r. Unital r -> (r -> r -> Bool) -> DecidableAssociates r
forall a. DecidableAssociates a => Unital (WrapAlgebra a)
forall a.
DecidableAssociates a =>
WrapAlgebra a -> WrapAlgebra a -> Bool
isAssociate :: WrapAlgebra a -> WrapAlgebra a -> Bool
$cisAssociate :: forall a.
DecidableAssociates a =>
WrapAlgebra a -> WrapAlgebra a -> Bool
$cp1DecidableAssociates :: forall a. DecidableAssociates a => Unital (WrapAlgebra a)
DecidableAssociates
                               , Commutative (WrapAlgebra a)
Domain (WrapAlgebra a)
Domain (WrapAlgebra a)
-> Commutative (WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> Bool)
-> (WrapAlgebra a -> WrapAlgebra a -> Maybe (WrapAlgebra a))
-> IntegralDomain (WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> Bool
WrapAlgebra a -> WrapAlgebra a -> Maybe (WrapAlgebra a)
forall d.
Domain d
-> Commutative d
-> (d -> d -> Bool)
-> (d -> d -> Maybe d)
-> IntegralDomain d
forall a. IntegralDomain a => Commutative (WrapAlgebra a)
forall a. IntegralDomain a => Domain (WrapAlgebra a)
forall a.
IntegralDomain a =>
WrapAlgebra a -> WrapAlgebra a -> Bool
forall a.
IntegralDomain a =>
WrapAlgebra a -> WrapAlgebra a -> Maybe (WrapAlgebra a)
maybeQuot :: WrapAlgebra a -> WrapAlgebra a -> Maybe (WrapAlgebra a)
$cmaybeQuot :: forall a.
IntegralDomain a =>
WrapAlgebra a -> WrapAlgebra a -> Maybe (WrapAlgebra a)
divides :: WrapAlgebra a -> WrapAlgebra a -> Bool
$cdivides :: forall a.
IntegralDomain a =>
WrapAlgebra a -> WrapAlgebra a -> Bool
$cp2IntegralDomain :: forall a. IntegralDomain a => Commutative (WrapAlgebra a)
$cp1IntegralDomain :: forall a. IntegralDomain a => Domain (WrapAlgebra a)
IntegralDomain, DecidableZero (WrapAlgebra a)
UnitNormalForm (WrapAlgebra a)
IntegralDomain (WrapAlgebra a)
IntegralDomain (WrapAlgebra a)
-> UnitNormalForm (WrapAlgebra a)
-> DecidableZero (WrapAlgebra a)
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> (WrapAlgebra a
    -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a))
-> (WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a)
-> GCDDomain (WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
forall d.
IntegralDomain d
-> UnitNormalForm d
-> DecidableZero d
-> (d -> d -> d)
-> (d -> d -> (d, d))
-> (d -> d -> d)
-> GCDDomain d
forall a. GCDDomain a => DecidableZero (WrapAlgebra a)
forall a. GCDDomain a => UnitNormalForm (WrapAlgebra a)
forall a. GCDDomain a => IntegralDomain (WrapAlgebra a)
forall a.
GCDDomain a =>
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
forall a.
GCDDomain a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
lcm :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$clcm :: forall a.
GCDDomain a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
reduceFraction :: WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
$creduceFraction :: forall a.
GCDDomain a =>
WrapAlgebra a -> WrapAlgebra a -> (WrapAlgebra a, WrapAlgebra a)
gcd :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$cgcd :: forall a.
GCDDomain a =>
WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
$cp3GCDDomain :: forall a. GCDDomain a => DecidableZero (WrapAlgebra a)
$cp2GCDDomain :: forall a. GCDDomain a => UnitNormalForm (WrapAlgebra a)
$cp1GCDDomain :: forall a. GCDDomain a => IntegralDomain (WrapAlgebra a)
GCDDomain
                               , Monoidal (WrapAlgebra a)
Semiring (WrapAlgebra a)
Monoidal (WrapAlgebra a)
-> Semiring (WrapAlgebra a) -> ZeroProductSemiring (WrapAlgebra a)
forall a.
(Monoidal a, Multiplicative a) =>
Monoidal (WrapAlgebra a)
forall a.
(Monoidal a, Multiplicative a) =>
Semiring (WrapAlgebra a)
forall r. Monoidal r -> Semiring r -> ZeroProductSemiring r
$cp2ZeroProductSemiring :: forall a.
(Monoidal a, Multiplicative a) =>
Semiring (WrapAlgebra a)
$cp1ZeroProductSemiring :: forall a.
(Monoidal a, Multiplicative a) =>
Monoidal (WrapAlgebra a)
ZeroProductSemiring, Ptr b -> Int -> IO (WrapAlgebra a)
Ptr b -> Int -> WrapAlgebra a -> IO ()
Ptr (WrapAlgebra a) -> IO (WrapAlgebra a)
Ptr (WrapAlgebra a) -> Int -> IO (WrapAlgebra a)
Ptr (WrapAlgebra a) -> Int -> WrapAlgebra a -> IO ()
Ptr (WrapAlgebra a) -> WrapAlgebra a -> IO ()
WrapAlgebra a -> Int
(WrapAlgebra a -> Int)
-> (WrapAlgebra a -> Int)
-> (Ptr (WrapAlgebra a) -> Int -> IO (WrapAlgebra a))
-> (Ptr (WrapAlgebra a) -> Int -> WrapAlgebra a -> IO ())
-> (forall b. Ptr b -> Int -> IO (WrapAlgebra a))
-> (forall b. Ptr b -> Int -> WrapAlgebra a -> IO ())
-> (Ptr (WrapAlgebra a) -> IO (WrapAlgebra a))
-> (Ptr (WrapAlgebra a) -> WrapAlgebra a -> IO ())
-> Storable (WrapAlgebra a)
forall b. Ptr b -> Int -> IO (WrapAlgebra a)
forall b. Ptr b -> Int -> WrapAlgebra a -> IO ()
forall a. Storable a => Ptr (WrapAlgebra a) -> IO (WrapAlgebra a)
forall a.
Storable a =>
Ptr (WrapAlgebra a) -> Int -> IO (WrapAlgebra a)
forall a.
Storable a =>
Ptr (WrapAlgebra a) -> Int -> WrapAlgebra a -> IO ()
forall a.
Storable a =>
Ptr (WrapAlgebra a) -> WrapAlgebra a -> IO ()
forall a. Storable a => WrapAlgebra a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (WrapAlgebra a)
forall a b. Storable a => Ptr b -> Int -> WrapAlgebra a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (WrapAlgebra a) -> WrapAlgebra a -> IO ()
$cpoke :: forall a.
Storable a =>
Ptr (WrapAlgebra a) -> WrapAlgebra a -> IO ()
peek :: Ptr (WrapAlgebra a) -> IO (WrapAlgebra a)
$cpeek :: forall a. Storable a => Ptr (WrapAlgebra a) -> IO (WrapAlgebra a)
pokeByteOff :: Ptr b -> Int -> WrapAlgebra a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> WrapAlgebra a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (WrapAlgebra a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (WrapAlgebra a)
pokeElemOff :: Ptr (WrapAlgebra a) -> Int -> WrapAlgebra a -> IO ()
$cpokeElemOff :: forall a.
Storable a =>
Ptr (WrapAlgebra a) -> Int -> WrapAlgebra a -> IO ()
peekElemOff :: Ptr (WrapAlgebra a) -> Int -> IO (WrapAlgebra a)
$cpeekElemOff :: forall a.
Storable a =>
Ptr (WrapAlgebra a) -> Int -> IO (WrapAlgebra a)
alignment :: WrapAlgebra a -> Int
$calignment :: forall a. Storable a => WrapAlgebra a -> Int
sizeOf :: WrapAlgebra a -> Int
$csizeOf :: forall a. Storable a => WrapAlgebra a -> Int
Storable)

deriving instance LeftModule Natural a => LeftModule Natural (WrapAlgebra a)
deriving instance RightModule Natural a => RightModule Natural (WrapAlgebra a)
deriving instance LeftModule Integer a => LeftModule Integer (WrapAlgebra a)
deriving instance RightModule Integer a => RightModule Integer (WrapAlgebra a)
deriving instance Monoidal a => Monoidal (WrapAlgebra a)
deriving instance Group    a => Group    (WrapAlgebra a)

instance (Ring a, UnitNormalForm a) => P.Num (WrapAlgebra a) where
  WrapAlgebra a
a + :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
+ WrapAlgebra a
b = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a) -> a -> WrapAlgebra a
forall a b. (a -> b) -> a -> b
$ a
a a -> a -> a
forall r. Additive r => r -> r -> r
NA.+ a
b
  {-# INLINE (+) #-}
  WrapAlgebra a
a - :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
- WrapAlgebra a
b = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a) -> a -> WrapAlgebra a
forall a b. (a -> b) -> a -> b
$ a
a a -> a -> a
forall r. Group r => r -> r -> r
NA.- a
b
  {-# INLINE (-) #-}
  WrapAlgebra a
a * :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
* WrapAlgebra a
b = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a) -> a -> WrapAlgebra a
forall a b. (a -> b) -> a -> b
$ a
a a -> a -> a
forall r. Multiplicative r => r -> r -> r
NA.* a
b
  {-# INLINE (*) #-}
  fromInteger :: Integer -> WrapAlgebra a
fromInteger = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a) -> (Integer -> a) -> Integer -> WrapAlgebra a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall r. Ring r => Integer -> r
NA.fromInteger
  {-# INLINE fromInteger #-}
  signum :: WrapAlgebra a -> WrapAlgebra a
signum = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a)
-> (WrapAlgebra a -> a) -> WrapAlgebra a -> WrapAlgebra a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall r. UnitNormalForm r => r -> r
leadingUnit (a -> a) -> (WrapAlgebra a -> a) -> WrapAlgebra a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapAlgebra a -> a
forall a. WrapAlgebra a -> a
unwrapAlgebra
  {-# INLINE signum #-}
  abs :: WrapAlgebra a -> WrapAlgebra a
abs    = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a)
-> (WrapAlgebra a -> a) -> WrapAlgebra a -> WrapAlgebra a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall r. UnitNormalForm r => r -> r
normaliseUnit (a -> a) -> (WrapAlgebra a -> a) -> WrapAlgebra a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapAlgebra a -> a
forall a. WrapAlgebra a -> a
unwrapAlgebra
  {-# INLINE abs #-}
  negate :: WrapAlgebra a -> WrapAlgebra a
negate = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a)
-> (WrapAlgebra a -> a) -> WrapAlgebra a -> WrapAlgebra a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall r. Group r => r -> r
negate (a -> a) -> (WrapAlgebra a -> a) -> WrapAlgebra a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapAlgebra a -> a
forall a. WrapAlgebra a -> a
unwrapAlgebra
  {-# INLINE negate #-}

instance (DivisionRing a, UnitNormalForm a) => P.Fractional (WrapAlgebra a) where
  WrapAlgebra a
a / :: WrapAlgebra a -> WrapAlgebra a -> WrapAlgebra a
/ WrapAlgebra a
b = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a
a a -> a -> a
forall r. Division r => r -> r -> r
/ a
b)
  {-# INLINE (/) #-}
  recip :: WrapAlgebra a -> WrapAlgebra a
recip (WrapAlgebra a
a) = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> a
forall r. Division r => r -> r
recip a
a)
  {-# INLINE recip #-}
  fromRational :: Rational -> WrapAlgebra a
fromRational = a -> WrapAlgebra a
forall a. a -> WrapAlgebra a
WrapAlgebra (a -> WrapAlgebra a)
-> (Rational -> a) -> Rational -> WrapAlgebra a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall r. DivisionRing r => Rational -> r
fromRational
  {-# INLINE fromRational #-}

instance Euclidean a => P.Num (Fraction a) where
  {-# SPECIALISE instance P.Num (Fraction Integer) #-}
  + :: Fraction a -> Fraction a -> Fraction a
(+) = Fraction a -> Fraction a -> Fraction a
forall r. Additive r => r -> r -> r
(NA.+)
  (-) = Fraction a -> Fraction a -> Fraction a
forall r. Group r => r -> r -> r
(NA.-)
  negate :: Fraction a -> Fraction a
negate = Fraction a -> Fraction a
forall r. Group r => r -> r
NA.negate
  * :: Fraction a -> Fraction a -> Fraction a
(*) = Fraction a -> Fraction a -> Fraction a
forall r. Multiplicative r => r -> r -> r
(NA.*)
  fromInteger :: Integer -> Fraction a
fromInteger = Integer -> Fraction a
forall r. Ring r => Integer -> r
NA.fromInteger
  abs :: Fraction a -> Fraction a
abs = Fraction a -> Fraction a
forall r. UnitNormalForm r => r -> r
normaliseUnit
  signum :: Fraction a -> Fraction a
signum = Fraction a -> Fraction a
forall r. UnitNormalForm r => r -> r
leadingUnit

instance Euclidean d => P.Fractional (Fraction d) where
  {-# SPECIALISE instance P.Fractional (Fraction Integer) #-}
  fromRational :: Rational -> Fraction d
fromRational Rational
r = Integer -> d
forall r. Ring r => Integer -> r
fromInteger' (Rational -> Integer
forall a. Ratio a -> a
P.numerator Rational
r) d -> d -> Fraction d
forall d. GCDDomain d => d -> d -> Fraction d
% Integer -> d
forall r. Ring r => Integer -> r
fromInteger' (Rational -> Integer
forall a. Ratio a -> a
P.denominator Rational
r)
  recip :: Fraction d -> Fraction d
recip = Fraction d -> Fraction d
forall r. Division r => r -> r
NA.recip
  / :: Fraction d -> Fraction d -> Fraction d
(/) = Fraction d -> Fraction d -> Fraction d
forall r. Division r => r -> r -> r
(NA./)

-- | @'Monoid'@ instances for @'Additive'@s.
--   N.B. Unlike @'WrapNum'@, @'P.Num'@ instance is
--   just inhereted from the unwrapped data.
newtype Add a = Add { Add a -> a
runAdd :: a }
              deriving (ReadPrec [Add a]
ReadPrec (Add a)
Int -> ReadS (Add a)
ReadS [Add a]
(Int -> ReadS (Add a))
-> ReadS [Add a]
-> ReadPrec (Add a)
-> ReadPrec [Add a]
-> Read (Add a)
forall a. Read a => ReadPrec [Add a]
forall a. Read a => ReadPrec (Add a)
forall a. Read a => Int -> ReadS (Add a)
forall a. Read a => ReadS [Add a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Add a]
$creadListPrec :: forall a. Read a => ReadPrec [Add a]
readPrec :: ReadPrec (Add a)
$creadPrec :: forall a. Read a => ReadPrec (Add a)
readList :: ReadS [Add a]
$creadList :: forall a. Read a => ReadS [Add a]
readsPrec :: Int -> ReadS (Add a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Add a)
Read, Int -> Add a -> ShowS
[Add a] -> ShowS
Add a -> String
(Int -> Add a -> ShowS)
-> (Add a -> String) -> ([Add a] -> ShowS) -> Show (Add a)
forall a. Show a => Int -> Add a -> ShowS
forall a. Show a => [Add a] -> ShowS
forall a. Show a => Add a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Add a] -> ShowS
$cshowList :: forall a. Show a => [Add a] -> ShowS
show :: Add a -> String
$cshow :: forall a. Show a => Add a -> String
showsPrec :: Int -> Add a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Add a -> ShowS
Show, Add a -> Add a -> Bool
(Add a -> Add a -> Bool) -> (Add a -> Add a -> Bool) -> Eq (Add a)
forall a. Eq a => Add a -> Add a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Add a -> Add a -> Bool
$c/= :: forall a. Eq a => Add a -> Add a -> Bool
== :: Add a -> Add a -> Bool
$c== :: forall a. Eq a => Add a -> Add a -> Bool
Eq, Eq (Add a)
Eq (Add a)
-> (Add a -> Add a -> Ordering)
-> (Add a -> Add a -> Bool)
-> (Add a -> Add a -> Bool)
-> (Add a -> Add a -> Bool)
-> (Add a -> Add a -> Bool)
-> (Add a -> Add a -> Add a)
-> (Add a -> Add a -> Add a)
-> Ord (Add a)
Add a -> Add a -> Bool
Add a -> Add a -> Ordering
Add a -> Add a -> Add a
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
forall a. Ord a => Eq (Add a)
forall a. Ord a => Add a -> Add a -> Bool
forall a. Ord a => Add a -> Add a -> Ordering
forall a. Ord a => Add a -> Add a -> Add a
min :: Add a -> Add a -> Add a
$cmin :: forall a. Ord a => Add a -> Add a -> Add a
max :: Add a -> Add a -> Add a
$cmax :: forall a. Ord a => Add a -> Add a -> Add a
>= :: Add a -> Add a -> Bool
$c>= :: forall a. Ord a => Add a -> Add a -> Bool
> :: Add a -> Add a -> Bool
$c> :: forall a. Ord a => Add a -> Add a -> Bool
<= :: Add a -> Add a -> Bool
$c<= :: forall a. Ord a => Add a -> Add a -> Bool
< :: Add a -> Add a -> Bool
$c< :: forall a. Ord a => Add a -> Add a -> Bool
compare :: Add a -> Add a -> Ordering
$ccompare :: forall a. Ord a => Add a -> Add a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Add a)
Ord, Integer -> Add a
Add a -> Add a
Add a -> Add a -> Add a
(Add a -> Add a -> Add a)
-> (Add a -> Add a -> Add a)
-> (Add a -> Add a -> Add a)
-> (Add a -> Add a)
-> (Add a -> Add a)
-> (Add a -> Add a)
-> (Integer -> Add a)
-> Num (Add a)
forall a. Num a => Integer -> Add a
forall a. Num a => Add a -> Add a
forall a. Num a => Add a -> Add a -> Add a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Add a
$cfromInteger :: forall a. Num a => Integer -> Add a
signum :: Add a -> Add a
$csignum :: forall a. Num a => Add a -> Add a
abs :: Add a -> Add a
$cabs :: forall a. Num a => Add a -> Add a
negate :: Add a -> Add a
$cnegate :: forall a. Num a => Add a -> Add a
* :: Add a -> Add a -> Add a
$c* :: forall a. Num a => Add a -> Add a -> Add a
- :: Add a -> Add a -> Add a
$c- :: forall a. Num a => Add a -> Add a -> Add a
+ :: Add a -> Add a -> Add a
$c+ :: forall a. Num a => Add a -> Add a -> Add a
P.Num, Natural -> Add a -> Add a
Add a -> Add a -> Add a
(a -> Add a) -> f a -> Add a
(Add a -> Add a -> Add a)
-> (Natural -> Add a -> Add a)
-> (forall (f :: * -> *) a.
    Foldable1 f =>
    (a -> Add a) -> f a -> Add a)
-> Additive (Add a)
forall a. Additive a => Natural -> Add a -> Add a
forall a. Additive a => Add a -> Add a -> Add a
forall a (f :: * -> *) a.
(Additive a, Foldable1 f) =>
(a -> Add a) -> f a -> Add a
forall r.
(r -> r -> r)
-> (Natural -> r -> r)
-> (forall (f :: * -> *) a. Foldable1 f => (a -> r) -> f a -> r)
-> Additive r
forall (f :: * -> *) a. Foldable1 f => (a -> Add a) -> f a -> Add a
sumWith1 :: (a -> Add a) -> f a -> Add a
$csumWith1 :: forall a (f :: * -> *) a.
(Additive a, Foldable1 f) =>
(a -> Add a) -> f a -> Add a
sinnum1p :: Natural -> Add a -> Add a
$csinnum1p :: forall a. Additive a => Natural -> Add a -> Add a
+ :: Add a -> Add a -> Add a
$c+ :: forall a. Additive a => Add a -> Add a -> Add a
Additive, Additive (Add a)
Additive (Add a) -> Abelian (Add a)
forall r. Additive r -> Abelian r
forall a. Additive a => Additive (Add a)
Abelian, Ptr b -> Int -> IO (Add a)
Ptr b -> Int -> Add a -> IO ()
Ptr (Add a) -> IO (Add a)
Ptr (Add a) -> Int -> IO (Add a)
Ptr (Add a) -> Int -> Add a -> IO ()
Ptr (Add a) -> Add a -> IO ()
Add a -> Int
(Add a -> Int)
-> (Add a -> Int)
-> (Ptr (Add a) -> Int -> IO (Add a))
-> (Ptr (Add a) -> Int -> Add a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Add a))
-> (forall b. Ptr b -> Int -> Add a -> IO ())
-> (Ptr (Add a) -> IO (Add a))
-> (Ptr (Add a) -> Add a -> IO ())
-> Storable (Add a)
forall b. Ptr b -> Int -> IO (Add a)
forall b. Ptr b -> Int -> Add a -> IO ()
forall a. Storable a => Ptr (Add a) -> IO (Add a)
forall a. Storable a => Ptr (Add a) -> Int -> IO (Add a)
forall a. Storable a => Ptr (Add a) -> Int -> Add a -> IO ()
forall a. Storable a => Ptr (Add a) -> Add a -> IO ()
forall a. Storable a => Add a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (Add a)
forall a b. Storable a => Ptr b -> Int -> Add a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (Add a) -> Add a -> IO ()
$cpoke :: forall a. Storable a => Ptr (Add a) -> Add a -> IO ()
peek :: Ptr (Add a) -> IO (Add a)
$cpeek :: forall a. Storable a => Ptr (Add a) -> IO (Add a)
pokeByteOff :: Ptr b -> Int -> Add a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> Add a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (Add a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (Add a)
pokeElemOff :: Ptr (Add a) -> Int -> Add a -> IO ()
$cpokeElemOff :: forall a. Storable a => Ptr (Add a) -> Int -> Add a -> IO ()
peekElemOff :: Ptr (Add a) -> Int -> IO (Add a)
$cpeekElemOff :: forall a. Storable a => Ptr (Add a) -> Int -> IO (Add a)
alignment :: Add a -> Int
$calignment :: forall a. Storable a => Add a -> Int
sizeOf :: Add a -> Int
$csizeOf :: forall a. Storable a => Add a -> Int
Storable)

deriving instance LeftModule Natural a => LeftModule Natural (Add a)
deriving instance RightModule Natural a => RightModule Natural (Add a)
deriving instance LeftModule Integer a => LeftModule Integer (Add a)
deriving instance RightModule Integer a => RightModule Integer (Add a)
deriving instance Monoidal a => Monoidal (Add a)


instance Additive a => Semi.Semigroup (Add a) where
  Add a
a <> :: Add a -> Add a -> Add a
<> Add a
b = a -> Add a
forall a. a -> Add a
Add (a
a a -> a -> a
forall r. Additive r => r -> r -> r
NA.+ a
b)
  {-# INLINE (<>) #-}

  sconcat :: NonEmpty (Add a) -> Add a
sconcat = a -> Add a
forall a. a -> Add a
Add (a -> Add a)
-> (NonEmpty (Add a) -> a) -> NonEmpty (Add a) -> Add a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> a
forall (f :: * -> *) r. (Foldable1 f, Additive r) => f r -> r
sum1 (NonEmpty a -> a)
-> (NonEmpty (Add a) -> NonEmpty a) -> NonEmpty (Add a) -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Add a -> a) -> NonEmpty (Add a) -> NonEmpty a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map Add a -> a
forall a. Add a -> a
runAdd
  {-# INLINE sconcat #-}

  stimes :: b -> Add a -> Add a
stimes b
n  = a -> Add a
forall a. a -> Add a
Add (a -> Add a) -> (Add a -> a) -> Add a -> Add a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> a -> a
forall r. Additive r => Natural -> r -> r
sinnum1p (b -> Natural
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral b
n Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
P.- Natural
1) (a -> a) -> (Add a -> a) -> Add a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Add a -> a
forall a. Add a -> a
runAdd
  {-# INLINE stimes #-}

instance Monoidal a => Monoid (Add a) where
  mappend :: Add a -> Add a -> Add a
mappend = Add a -> Add a -> Add a
forall a. Semigroup a => a -> a -> a
(Semi.<>)
  {-# INLINE mappend #-}
  mempty :: Add a
mempty = a -> Add a
forall a. a -> Add a
Add a
forall m. Monoidal m => m
zero
  {-# INLINE mempty #-}
  mconcat :: [Add a] -> Add a
mconcat = a -> Add a
forall a. a -> Add a
Add (a -> Add a) -> ([Add a] -> a) -> [Add a] -> Add a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> a
forall (f :: * -> *) m. (Foldable f, Monoidal m) => f m -> m
sum ([a] -> a) -> ([Add a] -> [a]) -> [Add a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Add a -> a) -> [Add a] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map Add a -> a
forall a. Add a -> a
runAdd
  {-# INLINE mconcat #-}

-- | @'Monoid'@ instances for @'Additive'@s.
--   N.B. Unlike @'WrapNum'@, @'P.Num'@ instance is
--   just inhereted from the unwrapped data.
newtype Mult a = Mult { Mult a -> a
runMult :: a }
              deriving (ReadPrec [Mult a]
ReadPrec (Mult a)
Int -> ReadS (Mult a)
ReadS [Mult a]
(Int -> ReadS (Mult a))
-> ReadS [Mult a]
-> ReadPrec (Mult a)
-> ReadPrec [Mult a]
-> Read (Mult a)
forall a. Read a => ReadPrec [Mult a]
forall a. Read a => ReadPrec (Mult a)
forall a. Read a => Int -> ReadS (Mult a)
forall a. Read a => ReadS [Mult a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Mult a]
$creadListPrec :: forall a. Read a => ReadPrec [Mult a]
readPrec :: ReadPrec (Mult a)
$creadPrec :: forall a. Read a => ReadPrec (Mult a)
readList :: ReadS [Mult a]
$creadList :: forall a. Read a => ReadS [Mult a]
readsPrec :: Int -> ReadS (Mult a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Mult a)
Read, Int -> Mult a -> ShowS
[Mult a] -> ShowS
Mult a -> String
(Int -> Mult a -> ShowS)
-> (Mult a -> String) -> ([Mult a] -> ShowS) -> Show (Mult a)
forall a. Show a => Int -> Mult a -> ShowS
forall a. Show a => [Mult a] -> ShowS
forall a. Show a => Mult a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mult a] -> ShowS
$cshowList :: forall a. Show a => [Mult a] -> ShowS
show :: Mult a -> String
$cshow :: forall a. Show a => Mult a -> String
showsPrec :: Int -> Mult a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Mult a -> ShowS
Show, Mult a -> Mult a -> Bool
(Mult a -> Mult a -> Bool)
-> (Mult a -> Mult a -> Bool) -> Eq (Mult a)
forall a. Eq a => Mult a -> Mult a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mult a -> Mult a -> Bool
$c/= :: forall a. Eq a => Mult a -> Mult a -> Bool
== :: Mult a -> Mult a -> Bool
$c== :: forall a. Eq a => Mult a -> Mult a -> Bool
Eq, Eq (Mult a)
Eq (Mult a)
-> (Mult a -> Mult a -> Ordering)
-> (Mult a -> Mult a -> Bool)
-> (Mult a -> Mult a -> Bool)
-> (Mult a -> Mult a -> Bool)
-> (Mult a -> Mult a -> Bool)
-> (Mult a -> Mult a -> Mult a)
-> (Mult a -> Mult a -> Mult a)
-> Ord (Mult a)
Mult a -> Mult a -> Bool
Mult a -> Mult a -> Ordering
Mult a -> Mult a -> Mult a
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
forall a. Ord a => Eq (Mult a)
forall a. Ord a => Mult a -> Mult a -> Bool
forall a. Ord a => Mult a -> Mult a -> Ordering
forall a. Ord a => Mult a -> Mult a -> Mult a
min :: Mult a -> Mult a -> Mult a
$cmin :: forall a. Ord a => Mult a -> Mult a -> Mult a
max :: Mult a -> Mult a -> Mult a
$cmax :: forall a. Ord a => Mult a -> Mult a -> Mult a
>= :: Mult a -> Mult a -> Bool
$c>= :: forall a. Ord a => Mult a -> Mult a -> Bool
> :: Mult a -> Mult a -> Bool
$c> :: forall a. Ord a => Mult a -> Mult a -> Bool
<= :: Mult a -> Mult a -> Bool
$c<= :: forall a. Ord a => Mult a -> Mult a -> Bool
< :: Mult a -> Mult a -> Bool
$c< :: forall a. Ord a => Mult a -> Mult a -> Bool
compare :: Mult a -> Mult a -> Ordering
$ccompare :: forall a. Ord a => Mult a -> Mult a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Mult a)
Ord, Integer -> Mult a
Mult a -> Mult a
Mult a -> Mult a -> Mult a
(Mult a -> Mult a -> Mult a)
-> (Mult a -> Mult a -> Mult a)
-> (Mult a -> Mult a -> Mult a)
-> (Mult a -> Mult a)
-> (Mult a -> Mult a)
-> (Mult a -> Mult a)
-> (Integer -> Mult a)
-> Num (Mult a)
forall a. Num a => Integer -> Mult a
forall a. Num a => Mult a -> Mult a
forall a. Num a => Mult a -> Mult a -> Mult a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Mult a
$cfromInteger :: forall a. Num a => Integer -> Mult a
signum :: Mult a -> Mult a
$csignum :: forall a. Num a => Mult a -> Mult a
abs :: Mult a -> Mult a
$cabs :: forall a. Num a => Mult a -> Mult a
negate :: Mult a -> Mult a
$cnegate :: forall a. Num a => Mult a -> Mult a
* :: Mult a -> Mult a -> Mult a
$c* :: forall a. Num a => Mult a -> Mult a -> Mult a
- :: Mult a -> Mult a -> Mult a
$c- :: forall a. Num a => Mult a -> Mult a -> Mult a
+ :: Mult a -> Mult a -> Mult a
$c+ :: forall a. Num a => Mult a -> Mult a -> Mult a
P.Num,
                        Mult a -> Natural -> Mult a
Mult a -> Mult a -> Mult a
(a -> Mult a) -> f a -> Mult a
(Mult a -> Mult a -> Mult a)
-> (Mult a -> Natural -> Mult a)
-> (forall (f :: * -> *) a.
    Foldable1 f =>
    (a -> Mult a) -> f a -> Mult a)
-> Multiplicative (Mult a)
forall a. Multiplicative a => Mult a -> Natural -> Mult a
forall a. Multiplicative a => Mult a -> Mult a -> Mult a
forall a (f :: * -> *) a.
(Multiplicative a, Foldable1 f) =>
(a -> Mult a) -> f a -> Mult a
forall r.
(r -> r -> r)
-> (r -> Natural -> r)
-> (forall (f :: * -> *) a. Foldable1 f => (a -> r) -> f a -> r)
-> Multiplicative r
forall (f :: * -> *) a.
Foldable1 f =>
(a -> Mult a) -> f a -> Mult a
productWith1 :: (a -> Mult a) -> f a -> Mult a
$cproductWith1 :: forall a (f :: * -> *) a.
(Multiplicative a, Foldable1 f) =>
(a -> Mult a) -> f a -> Mult a
pow1p :: Mult a -> Natural -> Mult a
$cpow1p :: forall a. Multiplicative a => Mult a -> Natural -> Mult a
* :: Mult a -> Mult a -> Mult a
$c* :: forall a. Multiplicative a => Mult a -> Mult a -> Mult a
Multiplicative, Multiplicative (Mult a)
Mult a
Multiplicative (Mult a)
-> Mult a
-> (Mult a -> Natural -> Mult a)
-> (forall (f :: * -> *) a.
    Foldable f =>
    (a -> Mult a) -> f a -> Mult a)
-> Unital (Mult a)
Mult a -> Natural -> Mult a
(a -> Mult a) -> f a -> Mult a
forall r.
Multiplicative r
-> r
-> (r -> Natural -> r)
-> (forall (f :: * -> *) a. Foldable f => (a -> r) -> f a -> r)
-> Unital r
forall a. Unital a => Multiplicative (Mult a)
forall a. Unital a => Mult a
forall a. Unital a => Mult a -> Natural -> Mult a
forall a (f :: * -> *) a.
(Unital a, Foldable f) =>
(a -> Mult a) -> f a -> Mult a
forall (f :: * -> *) a.
Foldable f =>
(a -> Mult a) -> f a -> Mult a
productWith :: (a -> Mult a) -> f a -> Mult a
$cproductWith :: forall a (f :: * -> *) a.
(Unital a, Foldable f) =>
(a -> Mult a) -> f a -> Mult a
pow :: Mult a -> Natural -> Mult a
$cpow :: forall a. Unital a => Mult a -> Natural -> Mult a
one :: Mult a
$cone :: forall a. Unital a => Mult a
$cp1Unital :: forall a. Unital a => Multiplicative (Mult a)
Unital, Multiplicative (Mult a)
Multiplicative (Mult a) -> Commutative (Mult a)
forall a. Multiplicative a => Multiplicative (Mult a)
forall r. Multiplicative r -> Commutative r
Commutative, Ptr b -> Int -> IO (Mult a)
Ptr b -> Int -> Mult a -> IO ()
Ptr (Mult a) -> IO (Mult a)
Ptr (Mult a) -> Int -> IO (Mult a)
Ptr (Mult a) -> Int -> Mult a -> IO ()
Ptr (Mult a) -> Mult a -> IO ()
Mult a -> Int
(Mult a -> Int)
-> (Mult a -> Int)
-> (Ptr (Mult a) -> Int -> IO (Mult a))
-> (Ptr (Mult a) -> Int -> Mult a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Mult a))
-> (forall b. Ptr b -> Int -> Mult a -> IO ())
-> (Ptr (Mult a) -> IO (Mult a))
-> (Ptr (Mult a) -> Mult a -> IO ())
-> Storable (Mult a)
forall b. Ptr b -> Int -> IO (Mult a)
forall b. Ptr b -> Int -> Mult a -> IO ()
forall a. Storable a => Ptr (Mult a) -> IO (Mult a)
forall a. Storable a => Ptr (Mult a) -> Int -> IO (Mult a)
forall a. Storable a => Ptr (Mult a) -> Int -> Mult a -> IO ()
forall a. Storable a => Ptr (Mult a) -> Mult a -> IO ()
forall a. Storable a => Mult a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (Mult a)
forall a b. Storable a => Ptr b -> Int -> Mult a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (Mult a) -> Mult a -> IO ()
$cpoke :: forall a. Storable a => Ptr (Mult a) -> Mult a -> IO ()
peek :: Ptr (Mult a) -> IO (Mult a)
$cpeek :: forall a. Storable a => Ptr (Mult a) -> IO (Mult a)
pokeByteOff :: Ptr b -> Int -> Mult a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> Mult a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (Mult a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (Mult a)
pokeElemOff :: Ptr (Mult a) -> Int -> Mult a -> IO ()
$cpokeElemOff :: forall a. Storable a => Ptr (Mult a) -> Int -> Mult a -> IO ()
peekElemOff :: Ptr (Mult a) -> Int -> IO (Mult a)
$cpeekElemOff :: forall a. Storable a => Ptr (Mult a) -> Int -> IO (Mult a)
alignment :: Mult a -> Int
$calignment :: forall a. Storable a => Mult a -> Int
sizeOf :: Mult a -> Int
$csizeOf :: forall a. Storable a => Mult a -> Int
Storable)

instance Multiplicative a => Semi.Semigroup (Mult a) where
  Mult a
a <> :: Mult a -> Mult a -> Mult a
<> Mult a
b = a -> Mult a
forall a. a -> Mult a
Mult (a
a a -> a -> a
forall r. Multiplicative r => r -> r -> r
NA.* a
b)
  {-# INLINE (<>) #-}

  sconcat :: NonEmpty (Mult a) -> Mult a
sconcat = a -> Mult a
forall a. a -> Mult a
Mult (a -> Mult a)
-> (NonEmpty (Mult a) -> a) -> NonEmpty (Mult a) -> Mult a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> a
forall (f :: * -> *) r. (Foldable1 f, Multiplicative r) => f r -> r
product1 (NonEmpty a -> a)
-> (NonEmpty (Mult a) -> NonEmpty a) -> NonEmpty (Mult a) -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Mult a -> a) -> NonEmpty (Mult a) -> NonEmpty a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map Mult a -> a
forall a. Mult a -> a
runMult
  {-# INLINE sconcat #-}

  stimes :: b -> Mult a -> Mult a
stimes b
n = a -> Mult a
forall a. a -> Mult a
Mult (a -> Mult a) -> (Mult a -> a) -> Mult a -> Mult a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Natural -> a) -> Natural -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> Natural -> a
forall r. Multiplicative r => r -> Natural -> r
pow1p (b -> Natural
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral b
n Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
P.- Natural
1) (a -> a) -> (Mult a -> a) -> Mult a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Mult a -> a
forall a. Mult a -> a
runMult
  {-# INLINE stimes #-}

instance Unital a => Monoid (Mult a) where
  mappend :: Mult a -> Mult a -> Mult a
mappend = Mult a -> Mult a -> Mult a
forall a. Semigroup a => a -> a -> a
(Semi.<>)
  {-# INLINE mappend #-}
  mempty :: Mult a
mempty = a -> Mult a
forall a. a -> Mult a
Mult a
forall r. Unital r => r
one
  {-# INLINE mempty #-}
  mconcat :: [Mult a] -> Mult a
mconcat = a -> Mult a
forall a. a -> Mult a
Mult (a -> Mult a) -> ([Mult a] -> a) -> [Mult a] -> Mult a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> a
forall (f :: * -> *) r. (Foldable f, Unital r) => f r -> r
product ([a] -> a) -> ([Mult a] -> [a]) -> [Mult a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Mult a -> a) -> [Mult a] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map Mult a -> a
forall a. Mult a -> a
runMult
  {-# INLINE mconcat #-}

L.makeWrapped ''WrapNum
L.makeWrapped ''WrapIntegral
L.makeWrapped ''WrapFractional
L.makeWrapped ''WrapAlgebra
L.makeWrapped ''Add
L.makeWrapped ''Mult

{-# ANN module "Hlint: ignore Redundant fromInteger" #-}