-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A numeric tower
--   
--   A heirarchy of classes for numbers and algebras that combine them: a
--   numeric tower.
--   
--   Performance testing, notes and examples can be found in
--   <a>tower-dev</a>.
--   
--   The tower looks something like:
--   
--   
--   To use the library:
--   
--   <pre>
--   import Tower.Prelude
--   print $ 1 + 1
--   </pre>
@package tower
@version 0.1.0


-- | Algebra
module Tower.Algebra

-- | A <a>Magma</a> is a tuple (T,⊕) consisting of
--   
--   <ul>
--   <li>a type a, and</li>
--   <li>a function (⊕) :: T -&gt; T -&gt; T</li>
--   </ul>
--   
--   The mathematical laws for a magma are:
--   
--   <ul>
--   <li>⊕ is defined for all possible pairs of type T, and</li>
--   <li>⊕ is closed in the set of all possible values of type T</li>
--   </ul>
--   
--   or, more tersly,
--   
--   <pre>
--   ∀ a, b ∈ T: a ⊕ b ∈ T
--   </pre>
--   
--   These laws are true by construction in haskell: the type signature of
--   <tt>magma</tt> and the above mathematical laws are synonyms.
class Magma a
(⊕) :: Magma a => a -> a -> a

-- | A Unital Magma
--   
--   <pre>
--   unit ⊕ a = a
--   a ⊕ unit = a
--   </pre>
class Magma a => Unital a
unit :: Unital a => a

-- | An Associative Magma
--   
--   <pre>
--   (a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)
--   </pre>
class Magma a => Associative a

-- | A Commutative Magma
--   
--   <pre>
--   a ⊕ b = b ⊕ a
--   </pre>
class Magma a => Commutative a

-- | An Invertible Magma
--   
--   <pre>
--   ∀ a ∈ T: inv a ∈ T
--   </pre>
--   
--   law is true by construction in Haskell
class Magma a => Invertible a
inv :: Invertible a => a -> a

-- | An Idempotent Magma
--   
--   <pre>
--   a ⊕ a = a
--   </pre>
class Magma a => Idempotent a

-- | A Homomorphic between two Magmas
--   
--   <pre>
--   ∀ a ∈ A: hom a ∈ B
--   </pre>
--   
--   law is true by construction in Haskell
class (Magma a, Magma b) => Homomorphic a b
hom :: Homomorphic a b => a -> b

-- | A Monoidal Magma is associative and unital.
class (Associative a, Unital a) => Monoidal a

-- | A CMonoidal Magma is commutative, associative and unital.
class (Commutative a, Associative a, Unital a) => CMonoidal a

-- | A Loop is unital and invertible
class (Unital a, Invertible a) => Loop a

-- | A Group is associative, unital and invertible
class (Associative a, Unital a, Invertible a) => Group a

-- | An Abelian Group is associative, unital, invertible and commutative
class (Associative a, Unital a, Invertible a, Commutative a) => Abelian a

-- | <a>plus</a> is used for the additive magma to distinguish from
--   <a>+</a> which, by convention, implies commutativity
class AdditiveMagma a
plus :: AdditiveMagma a => a -> a -> a

-- | AdditiveUnital
--   
--   <pre>
--   zero `plus` a == a
--   a `plus` zero == a
--   </pre>
class AdditiveMagma a => AdditiveUnital a
zero :: AdditiveUnital a => a

-- | AdditiveAssociative
--   
--   <pre>
--   (a `plus` b) `plus` c == a `plus` (b `plus` c)
--   </pre>
class AdditiveMagma a => AdditiveAssociative a

-- | AdditiveCommutative
--   
--   <pre>
--   a `plus` b == b `plus` a
--   </pre>
class AdditiveMagma a => AdditiveCommutative a

-- | AdditiveInvertible
--   
--   <pre>
--   ∀ a ∈ A: negate a ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class AdditiveMagma a => AdditiveInvertible a
negate :: AdditiveInvertible a => a -> a

-- | AdditiveHomomorphic
--   
--   <pre>
--   ∀ a ∈ A: plushom a ∈ B
--   </pre>
--   
--   law is true by construction in Haskell
class (AdditiveMagma a, AdditiveMagma b) => AdditiveHomomorphic a b
plushom :: AdditiveHomomorphic a b => a -> b

-- | AdditiveMonoidal
class (AdditiveUnital a, AdditiveAssociative a) => AdditiveMonoidal a

-- | Additive is commutative, unital and associative under addition
--   
--   <pre>
--   a + b = b + a
--   </pre>
--   
--   <pre>
--   (a + b) + c = a + (b + c)
--   </pre>
--   
--   <pre>
--   zero + a = a
--   </pre>
--   
--   <pre>
--   a + zero = a
--   </pre>
class (AdditiveCommutative a, AdditiveUnital a, AdditiveAssociative a) => Additive a where a + b = plus a b
(+) :: Additive a => a -> a -> a

-- | AdditiveGroup
--   
--   <pre>
--   a - a = zero
--   </pre>
--   
--   <pre>
--   negate a = zero - a
--   </pre>
--   
--   <pre>
--   negate a + a = zero
--   </pre>
class (Additive a, AdditiveInvertible a) => AdditiveGroup a where (-) a b = a `plus` negate b
(-) :: AdditiveGroup a => a -> a -> a

-- | <a>times</a> is used for the multiplicative magma to distinguish from
--   <a>*</a> which, by convention, implies commutativity
class MultiplicativeMagma a
times :: MultiplicativeMagma a => a -> a -> a

-- | MultiplicativeUnital
--   
--   <pre>
--   one `times` a == a
--   a `times` one == a
--   </pre>
class MultiplicativeMagma a => MultiplicativeUnital a
one :: MultiplicativeUnital a => a

-- | MultiplicativeAssociative
--   
--   <pre>
--   (a `times` b) `times` c == a `times` (b `times` c)
--   </pre>
class MultiplicativeMagma a => MultiplicativeAssociative a

-- | MultiplicativeCommutative
--   
--   <pre>
--   a `times` b == b `times` a
--   </pre>
class MultiplicativeMagma a => MultiplicativeCommutative a

-- | MultiplicativeInvertible
--   
--   <pre>
--   ∀ a ∈ A: recip a ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class MultiplicativeMagma a => MultiplicativeInvertible a
recip :: MultiplicativeInvertible a => a -> a

-- | MultiplicativeHomomorphic
--   
--   <pre>
--   ∀ a ∈ A: timeshom a ∈ B
--   </pre>
--   
--   law is true by construction in Haskell
class (MultiplicativeMagma a, MultiplicativeMagma b) => MultiplicativeHomomorphic a b
timeshom :: MultiplicativeHomomorphic a b => a -> b

-- | MultiplicativeMonoidal
class (MultiplicativeUnital a, MultiplicativeAssociative a) => MultiplicativeMonoidal a

-- | Multiplicative is commutative, associative and unital under
--   multiplication
--   
--   <pre>
--   a * b = b * a
--   </pre>
--   
--   <pre>
--   (a * b) * c = a * (b * c)
--   </pre>
--   
--   <pre>
--   one * a = a
--   </pre>
--   
--   <pre>
--   a * one = a
--   </pre>
class (MultiplicativeCommutative a, MultiplicativeUnital a, MultiplicativeAssociative a) => Multiplicative a where a * b = times a b
(*) :: Multiplicative a => a -> a -> a

-- | MultiplicativeGroup
--   
--   <pre>
--   a / a = one
--   </pre>
--   
--   <pre>
--   recip a = one / a
--   </pre>
--   
--   <pre>
--   recip a * a = one
--   </pre>
class (Multiplicative a, MultiplicativeInvertible a) => MultiplicativeGroup a where (/) a b = a `times` recip b
(/) :: MultiplicativeGroup a => a -> a -> a

-- | Distributive
--   
--   <pre>
--   a . (b + c) == a . b + a . c
--   </pre>
--   
--   <pre>
--   (a + b) . c == a . c + b . c
--   </pre>
class (Additive a, MultiplicativeMagma a) => Distributive a

-- | a semiring
class (Additive a, MultiplicativeAssociative a, MultiplicativeUnital a, Distributive a) => Semiring a

-- | Ring
class (AdditiveGroup a, MultiplicativeAssociative a, MultiplicativeUnital a, Distributive a) => Ring a

-- | Field
class (AdditiveGroup a, MultiplicativeGroup a, Distributive a) => Field a

-- | AdditiveBasis element by element addition
class (Additive a, AdditiveHomomorphic a a) => AdditiveBasis a where a .+. b = plushom a + plushom b
(.+.) :: AdditiveBasis a => a -> a -> a

-- | AdditiveGroupBasis element by element subtraction
class (AdditiveGroup a, AdditiveHomomorphic a a) => AdditiveGroupBasis a where a .-. b = plushom a - plushom b
(.-.) :: AdditiveGroupBasis a => a -> a -> a

-- | AdditiveModule
class (Additive a, Additive s, AdditiveHomomorphic s a) => AdditiveModule s a where s .+ a = plushom s + a a +. s = a + plushom s
(.+) :: (AdditiveModule s a, AdditiveModule s a) => s -> a -> a
(+.) :: (AdditiveModule s a, AdditiveModule s a) => a -> s -> a

-- | AdditiveGroupModule
class (AdditiveModule s a, AdditiveGroup a) => AdditiveGroupModule s a where s .- a = plushom s + a a -. s = a - plushom s
(.-) :: (AdditiveGroupModule s a, AdditiveModule s a) => s -> a -> a
(-.) :: (AdditiveGroupModule s a, AdditiveModule s a) => a -> s -> a

-- | MultiplicativeBasis element by element addition
class (Multiplicative a, MultiplicativeHomomorphic a a) => MultiplicativeBasis a where a .*. b = timeshom a * timeshom b
(.*.) :: MultiplicativeBasis a => a -> a -> a

-- | MultiplicativeGroupBasis element by element subtraction
class (MultiplicativeGroup a, MultiplicativeHomomorphic a a) => MultiplicativeGroupBasis a where a ./. b = timeshom a / timeshom b
(./.) :: MultiplicativeGroupBasis a => a -> a -> a

-- | MultiplicativeModule
class (Multiplicative a, Multiplicative s, MultiplicativeHomomorphic s a) => MultiplicativeModule s a where s .* a = timeshom s * a a *. s = a * timeshom s
(.*) :: (MultiplicativeModule s a, MultiplicativeModule s a) => s -> a -> a
(*.) :: (MultiplicativeModule s a, MultiplicativeModule s a) => a -> s -> a

-- | MultiplicativeGroupModule
class (MultiplicativeModule s a, MultiplicativeGroup a) => MultiplicativeGroupModule s a where s ./ a = timeshom s * a a /. s = a / timeshom s
(./) :: (MultiplicativeGroupModule s a, MultiplicativeModule s a) => s -> a -> a
(/.) :: (MultiplicativeGroupModule s a, MultiplicativeModule s a) => a -> s -> a

-- | Integral
--   
--   <pre>
--   b == zero || b * (a `div` b) + (a `mod` b) == a
--   b == zero || b * (a `quot` b) + (a `rem` b) == a
--   </pre>
class (Additive a, Multiplicative a) => Integral a where div a1 a2 = fst (divMod a1 a2) mod a1 a2 = snd (divMod a1 a2)
toInteger :: Integral a => a -> Integer

-- | truncates towards negative infinity
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
divMod :: Integral a => a -> a -> (a, a)

-- | Metric
class Metric r m
d :: Metric r m => m -> m -> r

-- | Normed
class Normed a
size :: Normed a => a -> a

-- | abs
abs :: Normed a => a -> a

-- | Banach
class (MultiplicativeGroup a, MultiplicativeModule a a, MultiplicativeGroupModule a a, MultiplicativeInvertible a, Normed a) => Banach a where normalize a = a ./ size a
normalize :: Banach a => a -> a

-- | BoundedField
class (Field a, Bounded a) => BoundedField a where nan = zero / zero
nan :: BoundedField a => a

-- | infinity
infinity :: BoundedField a => a

-- | ExpRing
class Ring a => ExpRing a where (**) = undefined
logBase :: ExpRing a => a -> a -> a
(**) :: (ExpRing a, ExpRing a) => a -> a -> a

-- | (^)
(^) :: ExpRing a => a -> a -> a

-- | ExpField
class (Field a, ExpRing a) => ExpField a where sqrt a = a ** (one / one + one)
sqrt :: ExpField a => a -> a
exp :: ExpField a => a -> a
log :: ExpField a => a -> a

-- | Hilbert
class (Banach a, TensorAlgebra a, ExpField r, AdditiveGroup a) => Hilbert a r
(<?>) :: Hilbert a r => a -> a -> r

-- | TensorAlgebra
class TensorAlgebra a
(><) :: TensorAlgebra a => a -> a -> (a >< a)
timesleft :: TensorAlgebra a => a -> (a >< a) -> a
timesright :: TensorAlgebra a => (a >< a) -> a -> a

-- | squaredInnerProductNorm
squaredInnerProductNorm :: Hilbert v r => v -> r

-- | innerProductNorm
innerProductNorm :: (Hilbert v r) => v -> r

-- | innerProductDistance
innerProductDistance :: Hilbert v r => v -> v -> r
instance Tower.Algebra.Magma a => Tower.Algebra.Homomorphic a a
instance Tower.Algebra.AdditiveMagma GHC.Types.Double
instance Tower.Algebra.AdditiveMagma GHC.Types.Float
instance Tower.Algebra.AdditiveMagma GHC.Types.Int
instance Tower.Algebra.AdditiveUnital GHC.Types.Double
instance Tower.Algebra.AdditiveUnital GHC.Types.Float
instance Tower.Algebra.AdditiveUnital GHC.Types.Int
instance Tower.Algebra.AdditiveAssociative GHC.Types.Double
instance Tower.Algebra.AdditiveAssociative GHC.Types.Float
instance Tower.Algebra.AdditiveAssociative GHC.Types.Int
instance Tower.Algebra.AdditiveCommutative GHC.Types.Double
instance Tower.Algebra.AdditiveCommutative GHC.Types.Float
instance Tower.Algebra.AdditiveCommutative GHC.Types.Int
instance Tower.Algebra.AdditiveInvertible GHC.Types.Double
instance Tower.Algebra.AdditiveInvertible GHC.Types.Float
instance Tower.Algebra.AdditiveInvertible GHC.Types.Int
instance Tower.Algebra.AdditiveMagma a => Tower.Algebra.AdditiveHomomorphic a a
instance Tower.Algebra.Additive GHC.Types.Double
instance Tower.Algebra.Additive GHC.Types.Float
instance Tower.Algebra.Additive GHC.Types.Int
instance Tower.Algebra.AdditiveGroup GHC.Types.Double
instance Tower.Algebra.AdditiveGroup GHC.Types.Float
instance Tower.Algebra.AdditiveGroup GHC.Types.Int
instance Tower.Algebra.MultiplicativeMagma GHC.Types.Double
instance Tower.Algebra.MultiplicativeMagma GHC.Types.Float
instance Tower.Algebra.MultiplicativeMagma GHC.Types.Int
instance Tower.Algebra.MultiplicativeUnital GHC.Types.Double
instance Tower.Algebra.MultiplicativeUnital GHC.Types.Float
instance Tower.Algebra.MultiplicativeUnital GHC.Types.Int
instance Tower.Algebra.MultiplicativeCommutative GHC.Types.Double
instance Tower.Algebra.MultiplicativeCommutative GHC.Types.Float
instance Tower.Algebra.MultiplicativeCommutative GHC.Types.Int
instance Tower.Algebra.MultiplicativeAssociative GHC.Types.Double
instance Tower.Algebra.MultiplicativeAssociative GHC.Types.Float
instance Tower.Algebra.MultiplicativeAssociative GHC.Types.Int
instance Tower.Algebra.MultiplicativeInvertible GHC.Types.Double
instance Tower.Algebra.MultiplicativeInvertible GHC.Types.Float
instance Tower.Algebra.MultiplicativeMagma a => Tower.Algebra.MultiplicativeHomomorphic a a
instance Tower.Algebra.Multiplicative GHC.Types.Double
instance Tower.Algebra.Multiplicative GHC.Types.Float
instance Tower.Algebra.Multiplicative GHC.Types.Int
instance Tower.Algebra.MultiplicativeGroup GHC.Types.Double
instance Tower.Algebra.MultiplicativeGroup GHC.Types.Float
instance Tower.Algebra.Distributive GHC.Types.Double
instance Tower.Algebra.Distributive GHC.Types.Float
instance Tower.Algebra.Distributive GHC.Types.Int
instance Tower.Algebra.Semiring GHC.Types.Double
instance Tower.Algebra.Semiring GHC.Types.Float
instance Tower.Algebra.Semiring GHC.Types.Int
instance Tower.Algebra.Ring GHC.Types.Double
instance Tower.Algebra.Ring GHC.Types.Float
instance Tower.Algebra.DivisionRing GHC.Types.Double
instance Tower.Algebra.DivisionRing GHC.Types.Float
instance Tower.Algebra.Field GHC.Types.Double
instance Tower.Algebra.Field GHC.Types.Float
instance Tower.Algebra.Integral GHC.Types.Int
instance GHC.Enum.Bounded GHC.Types.Float
instance Tower.Algebra.BoundedField GHC.Types.Float
instance GHC.Enum.Bounded GHC.Types.Double
instance Tower.Algebra.BoundedField GHC.Types.Double


-- | Applicative-style vector
module Tower.VectorA

-- | a wrapped fixed-size traversable container
newtype VectorA n f a
VectorA :: ((Traversable f, KnownNat n, Applicative f, Functor f) => f a) -> VectorA n f a
[unvec] :: VectorA n f a -> (Traversable f, KnownNat n, Applicative f, Functor f) => f a
instance (GHC.TypeLits.KnownNat n, Data.Traversable.Traversable f, GHC.Base.Applicative f, GHC.Classes.Eq (f a)) => GHC.Classes.Eq (Tower.VectorA.VectorA n f a)
instance (GHC.TypeLits.KnownNat n, Data.Traversable.Traversable f, GHC.Base.Applicative f, GHC.Show.Show (f a)) => GHC.Show.Show (Tower.VectorA.VectorA n f a)
instance (GHC.Num.Num a, Tower.Algebra.AdditiveUnital a, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (Tower.VectorA.VectorA 5 [] a)
instance GHC.Base.Functor (Tower.VectorA.Supply s)
instance GHC.Base.Applicative (Tower.VectorA.Supply s)
instance Tower.Algebra.AdditiveMagma a => Tower.Algebra.AdditiveMagma (Tower.VectorA.VectorA n f a)
instance Tower.Algebra.AdditiveAssociative a => Tower.Algebra.AdditiveAssociative (Tower.VectorA.VectorA n f a)
instance Tower.Algebra.AdditiveCommutative a => Tower.Algebra.AdditiveCommutative (Tower.VectorA.VectorA n f a)
instance (Tower.Algebra.AdditiveUnital a, GHC.TypeLits.KnownNat n) => Tower.Algebra.AdditiveUnital (Tower.VectorA.VectorA n [] a)
instance Tower.Algebra.AdditiveInvertible a => Tower.Algebra.AdditiveInvertible (Tower.VectorA.VectorA n f a)
instance (Tower.Algebra.Additive a, GHC.TypeLits.KnownNat n) => Tower.Algebra.Additive (Tower.VectorA.VectorA n [] a)
instance (Tower.Algebra.AdditiveGroup a, GHC.TypeLits.KnownNat n) => Tower.Algebra.AdditiveGroup (Tower.VectorA.VectorA n [] a)
instance (Tower.Algebra.AdditiveMagma a, GHC.TypeLits.KnownNat n) => Tower.Algebra.AdditiveHomomorphic a (Tower.VectorA.VectorA n [] a)
instance (Tower.Algebra.Additive a, GHC.TypeLits.KnownNat n) => Tower.Algebra.AdditiveModule a (Tower.VectorA.VectorA n [] a)
instance Tower.Algebra.MultiplicativeMagma a => Tower.Algebra.MultiplicativeMagma (Tower.VectorA.VectorA n f a)
instance Tower.Algebra.MultiplicativeAssociative a => Tower.Algebra.MultiplicativeAssociative (Tower.VectorA.VectorA n f a)
instance Tower.Algebra.MultiplicativeCommutative a => Tower.Algebra.MultiplicativeCommutative (Tower.VectorA.VectorA n f a)
instance (Tower.Algebra.MultiplicativeUnital a, GHC.TypeLits.KnownNat n) => Tower.Algebra.MultiplicativeUnital (Tower.VectorA.VectorA n [] a)
instance Tower.Algebra.MultiplicativeInvertible a => Tower.Algebra.MultiplicativeInvertible (Tower.VectorA.VectorA n f a)
instance (Tower.Algebra.Multiplicative a, GHC.TypeLits.KnownNat n) => Tower.Algebra.Multiplicative (Tower.VectorA.VectorA n [] a)
instance Tower.Algebra.MultiplicativeMagma a => Tower.Algebra.MultiplicativeHomomorphic a (Tower.VectorA.VectorA n f a)
instance (Tower.Algebra.Multiplicative a, GHC.TypeLits.KnownNat n) => Tower.Algebra.MultiplicativeModule a (Tower.VectorA.VectorA n [] a)
instance (Tower.Algebra.Distributive a, GHC.TypeLits.KnownNat n) => Tower.Algebra.Distributive (Tower.VectorA.VectorA n [] a)


-- | unboxed vector
module Tower.VectorU

-- | wrapped fixed-size unboxed vector
data VectorU (n :: Nat) a
VectorU :: Vector a -> VectorU a
[v] :: VectorU a -> Vector a

-- | toVectorU right pads with zeros, if necessary which introduces an
--   extra AdditiveUnital constraint
toVectorU :: forall a n. (AdditiveUnital a, Unbox a, KnownNat n) => [a] -> VectorU (n :: Nat) a
instance (Data.Vector.Unboxed.Base.Unbox a, GHC.Show.Show a) => GHC.Show.Show (Tower.VectorU.VectorU n a)
instance (GHC.Classes.Eq a, Data.Vector.Unboxed.Base.Unbox a) => GHC.Classes.Eq (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Test.QuickCheck.Arbitrary.Arbitrary a, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a) => Test.QuickCheck.Arbitrary.Arbitrary (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveMagma a) => Tower.Algebra.AdditiveMagma (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveAssociative a) => Tower.Algebra.AdditiveAssociative (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveCommutative a) => Tower.Algebra.AdditiveCommutative (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a) => Tower.Algebra.AdditiveUnital (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveInvertible a) => Tower.Algebra.AdditiveInvertible (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.Additive a) => Tower.Algebra.Additive (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveGroup a) => Tower.Algebra.AdditiveGroup (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.AdditiveMagma a) => Tower.Algebra.AdditiveHomomorphic a (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.Additive a) => Tower.Algebra.AdditiveModule a (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.MultiplicativeMagma a) => Tower.Algebra.MultiplicativeMagma (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.MultiplicativeAssociative a) => Tower.Algebra.MultiplicativeAssociative (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.MultiplicativeCommutative a) => Tower.Algebra.MultiplicativeCommutative (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.MultiplicativeUnital a) => Tower.Algebra.MultiplicativeUnital (Tower.VectorU.VectorU n a)
instance (Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.MultiplicativeInvertible a) => Tower.Algebra.MultiplicativeInvertible (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.Multiplicative a) => Tower.Algebra.Multiplicative (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.MultiplicativeGroup a) => Tower.Algebra.MultiplicativeGroup (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.MultiplicativeUnital a, Tower.Algebra.MultiplicativeMagma a) => Tower.Algebra.MultiplicativeHomomorphic a (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.AdditiveUnital a, Tower.Algebra.Multiplicative a) => Tower.Algebra.MultiplicativeModule a (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.Distributive a) => Tower.Algebra.Distributive (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.Ring a) => Tower.Algebra.Ring (Tower.VectorU.VectorU n a)
instance (GHC.TypeLits.KnownNat n, Data.Vector.Unboxed.Base.Unbox a, Tower.Algebra.Integral a) => Tower.Algebra.Integral (Tower.VectorU.VectorU n a)


-- | exactly protolude hiding tower api
module Tower.Prelude