module Numeric.Module.Representable
(
addRep, replicate1pRep
, zeroRep, replicateRep
, negateRep, minusRep, subtractRep, timesRep
, mulRep
, oneRep
, fromNaturalRep
, fromIntegerRep
) where
import Control.Applicative
import Data.Functor
import Data.Functor.Representable
import Data.Key
import Numeric.Additive.Class
import Numeric.Additive.Group
import Numeric.Algebra.Class
import Numeric.Algebra.Unital
import Numeric.Natural.Internal
import Numeric.Rig.Class
import Numeric.Ring.Class
import Control.Category
import Prelude (($), Integral(..),Integer)
addRep :: (Zip m, Additive r) => m r -> m r -> m r
addRep = zipWith (+)
replicate1pRep :: (Whole n, Functor m, Additive r) => n -> m r -> m r
replicate1pRep = fmap . replicate1p
zeroRep :: (Applicative m, Monoidal r) => m r
zeroRep = pure zero
replicateRep :: (Whole n, Functor m, Monoidal r) => n -> m r -> m r
replicateRep = fmap . replicate
negateRep :: (Functor m, Group r) => m r -> m r
negateRep = fmap negate
minusRep :: (Zip m, Group r) => m r -> m r -> m r
minusRep = zipWith ()
subtractRep :: (Zip m, Group r) => m r -> m r -> m r
subtractRep = zipWith subtract
timesRep :: (Integral n, Functor m, Group r) => n -> m r -> m r
timesRep = fmap . times
mulRep :: (Representable m, Algebra r (Key m)) => m r -> m r -> m r
mulRep m n = tabulate $ mult (\b1 b2 -> index m b1 * index n b2)
oneRep :: (Representable m, Unital r, UnitalAlgebra r (Key m)) => m r
oneRep = tabulate $ unit one
fromNaturalRep :: (UnitalAlgebra r (Key m), Representable m, Rig r) => Natural -> m r
fromNaturalRep n = tabulate $ unit (fromNatural n)
fromIntegerRep :: (UnitalAlgebra r (Key m), Representable m, Ring r) => Integer -> m r
fromIntegerRep n = tabulate $ unit (fromInteger n)