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


-- | A numeric prelude
--   
--   Classes for numbers, higher-dimension representable objects, and
--   algebras that combine them. See NumHask.Examples for usage.
--   
--   <pre>
--   import NumHask.Prelude
--   </pre>
@package numhask
@version 0.0.1


-- | multi-dimensional numbers with a shape
module NumHask.HasShape

-- | Could possibly be integrated with <tt>Representable</tt> instance
--   creation
class HasShape f where type Shape f where {
    type family Shape f;
}
shape :: (HasShape f, HasShape f) => f -> Shape f
ndim :: (HasShape f, HasShape f) => f -> Int


-- | Multiplicate structure Many treatments of a numeric tower treat
--   multiplication differently to addition. NumHask treats these two as
--   exactly symmetrical, and thus departs from the usual mathematical
--   terminology.
module NumHask.Algebra.Multiplicative

-- | <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 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

-- | Non-commutative right divide
class (MultiplicativeUnital a, MultiplicativeAssociative a, MultiplicativeInvertible a) => MultiplicativeRightCancellative a where a /~ b = a `times` recip b
(/~) :: MultiplicativeRightCancellative a => a -> a -> a

-- | Non-commutative left divide
class (MultiplicativeUnital a, MultiplicativeAssociative a, MultiplicativeInvertible a) => MultiplicativeLeftCancellative a where a ~/ b = recip b `times` a
(~/) :: MultiplicativeLeftCancellative 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
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeMagma a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeCommutative a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeAssociative a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeInvertible GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeInvertible GHC.Types.Float
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (r a)
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeMagma a) => NumHask.Algebra.Multiplicative.MultiplicativeHomomorphic a (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma a => NumHask.Algebra.Multiplicative.MultiplicativeHomomorphic a a
instance NumHask.Algebra.Multiplicative.MultiplicativeMonoidal GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeMonoidal GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeMonoidal GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeMonoidal GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeMonoidal GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeMonoidal a) => NumHask.Algebra.Multiplicative.MultiplicativeMonoidal (r a)
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.Multiplicative (r a)
instance NumHask.Algebra.Multiplicative.MultiplicativeGroup GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeGroup GHC.Types.Float
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (r a)


-- | Magma
module NumHask.Algebra.Magma

-- | 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 Homomorph 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

-- | major conceptual clashidge with many other libraries
class (Magma a, Magma b) => Isomorphic a b
isomorph :: Isomorphic a b => (a -> b, b -> a)

-- | 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

-- | see <a>http://chris-taylor.github.io/blog/2013/02/25/xor-trick/</a>
groupSwap :: (Group a) => (a, a) -> (a, a)

-- | An Abelian Group is associative, unital, invertible and commutative
class (Associative a, Unital a, Invertible a, Commutative a) => Abelian a
instance NumHask.Algebra.Magma.Magma a => NumHask.Algebra.Magma.Homomorphic a a


-- | A bit of extra Ordering taken from gaia.
module NumHask.Algebra.Ordering

-- | P's just to avoid name clashes
class POrd s
pcompare :: POrd s => s -> s -> POrdering

-- | Equal to, Less than, Greater than, Not comparable to
data POrdering
PEQ :: POrdering
PLT :: POrdering
PGT :: POrdering
PNC :: POrdering

-- | Topped
class POrd s => Topped s
top :: Topped s => s

-- | Bottomed
class POrd s => Bottomed s
bottom :: Bottomed s => s

-- | Replaces the Bounded in base. Is this a good idea?
class (Topped a, Bottomed a) => Bounded a

-- | which creates a nice alternative for negate
class (Lattice a, Isomorphic (Inf a) (Sup a)) => Negated a where negated a = coerce (fst isomorph (coerce a :: Inf a) :: Sup a) :: a
negated :: Negated a => a -> a

-- | Semilattice
class (Associative a, Commutative a, Idempotent a) => Semilattice a

-- | a nice Lattice, but the types explode the instance requirements
class (Coercible a (Sup a), Coercible a (Inf a), Semilattice (Sup a), Semilattice (Inf a), POrd a) => Lattice a where type Inf a type Sup a (/\) = coerce ((⊕) :: Sup a -> Sup a -> Sup a) (\/) = coerce ((⊕) :: Inf a -> Inf a -> Inf a) where {
    type family Inf a;
    type family Sup a;
}
(/\) :: Lattice a => a -> a -> a
(\/) :: Lattice a => a -> a -> a

-- | conversion
ord2pord :: Ordering -> POrdering
instance GHC.Classes.Ord a => NumHask.Algebra.Ordering.POrd a
instance NumHask.Algebra.Ordering.Topped GHC.Types.Int
instance NumHask.Algebra.Ordering.Bottomed GHC.Types.Int
instance NumHask.Algebra.Ordering.Bounded GHC.Types.Int
instance NumHask.Algebra.Ordering.Topped GHC.Types.Bool
instance NumHask.Algebra.Ordering.Bottomed GHC.Types.Bool
instance NumHask.Algebra.Ordering.Bounded GHC.Types.Bool
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.SupInt NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.InfInt NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.SupInt NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.InfInt NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.SupInt
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.InfInt
instance NumHask.Algebra.Ordering.Lattice GHC.Types.Int
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.SupInteger NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.InfInteger NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.SupInteger NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.InfInteger NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.SupInteger
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.InfInteger
instance NumHask.Algebra.Ordering.Lattice GHC.Integer.Type.Integer
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.SupFloat NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.InfFloat NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.SupFloat NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.InfFloat NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.SupFloat
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.InfFloat
instance NumHask.Algebra.Ordering.Lattice GHC.Types.Float
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Magma NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Associative NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Magma.Commutative NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Magma.Idempotent NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.SupDouble NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Homomorphic NumHask.Algebra.Ordering.InfDouble NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.SupDouble NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Magma.Isomorphic NumHask.Algebra.Ordering.InfDouble NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.SupDouble
instance NumHask.Algebra.Ordering.Semilattice NumHask.Algebra.Ordering.InfDouble
instance NumHask.Algebra.Ordering.Lattice GHC.Types.Double


-- | Additive Structure
module NumHask.Algebra.Additive

-- | <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 b) => AdditiveHomomorphic a b
plushom :: AdditiveHomomorphic a b => a -> b

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

-- | 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

-- | Non-commutative right minus
class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveRightCancellative a where (-~) a b = a `plus` negate b
(-~) :: AdditiveRightCancellative a => a -> a -> a

-- | Non-commutative left minus
class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveLeftCancellative a where (~-) a b = negate b `plus` a
(~-) :: AdditiveLeftCancellative 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
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveMagma a) => NumHask.Algebra.Additive.AdditiveMagma (r a)
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveUnital a) => NumHask.Algebra.Additive.AdditiveUnital (r a)
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveAssociative a) => NumHask.Algebra.Additive.AdditiveAssociative (r a)
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveCommutative a) => NumHask.Algebra.Additive.AdditiveCommutative (r a)
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveInvertible (r a)
instance NumHask.Algebra.Additive.AdditiveMagma a => NumHask.Algebra.Additive.AdditiveHomomorphic a a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveMagma a) => NumHask.Algebra.Additive.AdditiveHomomorphic a (r a)
instance NumHask.Algebra.Additive.AdditiveIdempotent GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveMonoidal GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveMonoidal GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveMonoidal GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveMonoidal GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveMonoidal GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveMonoidal a) => NumHask.Algebra.Additive.AdditiveMonoidal (r a)
instance NumHask.Algebra.Additive.Additive GHC.Types.Double
instance NumHask.Algebra.Additive.Additive GHC.Types.Float
instance NumHask.Algebra.Additive.Additive GHC.Types.Int
instance NumHask.Algebra.Additive.Additive GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.Additive GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Additive.Additive (r a)
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Integer.Type.Integer
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Additive.AdditiveGroup (r a)


-- | Highjacking <a>Representable</a>s to provide a basis to provide
--   element-by-element operations
module NumHask.Algebra.Basis

-- | AdditiveBasis element by element addition
class (Representable m, Additive a) => AdditiveBasis m a where (.+.) = liftR2 (+)
(.+.) :: AdditiveBasis m a => m a -> m a -> m a

-- | AdditiveGroupBasis element by element subtraction
class (Representable m, AdditiveGroup a) => AdditiveGroupBasis m a where (.-.) = liftR2 (-)
(.-.) :: AdditiveGroupBasis m a => m a -> m a -> m a

-- | MultiplicativeBasis element by element multiplication
class (Representable m, Multiplicative a) => MultiplicativeBasis m a where (.*.) = liftR2 (*)
(.*.) :: MultiplicativeBasis m a => m a -> m a -> m a

-- | MultiplicativeGroupBasis element by element division
class (Representable m, MultiplicativeGroup a) => MultiplicativeGroupBasis m a where (./.) = liftR2 (/)
(./.) :: MultiplicativeGroupBasis m a => m a -> m a -> m a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Basis.AdditiveBasis r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Basis.AdditiveGroupBasis r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Basis.MultiplicativeBasis r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Basis.MultiplicativeGroupBasis r a


-- | Distribution, avoiding name clashes with <a>Distributive</a>
module NumHask.Algebra.Distribution

-- | Distribution
--   
--   <pre>
--   a * (b + c) == a * b + a * c
--   </pre>
--   
--   <pre>
--   (a + b) * c == a * c + b * c
--   </pre>
class (Additive a, MultiplicativeMagma a) => Distribution a
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Double
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Float
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Int
instance NumHask.Algebra.Distribution.Distribution GHC.Integer.Type.Integer
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Distribution.Distribution a) => NumHask.Algebra.Distribution.Distribution (r a)


-- | Rings An interesting feature of the NumHask structure is the
--   importance of the commutative Ring (<a>CRing</a>), which is a class
--   often needed higher up the class tree.
module NumHask.Algebra.Ring

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

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

-- | CRing is a Commutative Ring. It arises often due to * being defined as
--   only multiplicative commutative.
class (Multiplicative a, Ring a) => CRing a
instance NumHask.Algebra.Ring.Semiring GHC.Types.Double
instance NumHask.Algebra.Ring.Semiring GHC.Types.Float
instance NumHask.Algebra.Ring.Semiring GHC.Types.Int
instance NumHask.Algebra.Ring.Semiring GHC.Integer.Type.Integer
instance NumHask.Algebra.Ring.Semiring GHC.Types.Bool
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Ring.Semiring a) => NumHask.Algebra.Ring.Semiring (r a)
instance NumHask.Algebra.Ring.Ring GHC.Types.Double
instance NumHask.Algebra.Ring.Ring GHC.Types.Float
instance NumHask.Algebra.Ring.Ring GHC.Types.Int
instance NumHask.Algebra.Ring.Ring GHC.Integer.Type.Integer
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Ring.Ring (r a)
instance NumHask.Algebra.Ring.CRing GHC.Types.Double
instance NumHask.Algebra.Ring.CRing GHC.Types.Float
instance NumHask.Algebra.Ring.CRing GHC.Types.Int
instance NumHask.Algebra.Ring.CRing GHC.Integer.Type.Integer
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Ring.CRing a) => NumHask.Algebra.Ring.CRing (r a)


-- | Field
module NumHask.Algebra.Field

-- | Field
class (AdditiveGroup a, MultiplicativeGroup a, Distribution a, Ring a) => Field a
instance NumHask.Algebra.Field.Field GHC.Types.Double
instance NumHask.Algebra.Field.Field GHC.Types.Float
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Field.Field a) => NumHask.Algebra.Field.Field (r a)


-- | Exponentail <a>Ring</a> and <a>Field</a>
module NumHask.Algebra.Exponential

-- | ExpRing
class Ring a => ExpRing a
logBase :: ExpRing a => a -> a -> 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
instance NumHask.Algebra.Exponential.ExpRing GHC.Types.Double
instance NumHask.Algebra.Exponential.ExpRing GHC.Types.Float
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Exponential.ExpRing a) => NumHask.Algebra.Exponential.ExpRing (r a)
instance NumHask.Algebra.Exponential.ExpField GHC.Types.Double
instance NumHask.Algebra.Exponential.ExpField GHC.Types.Float
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Exponential.ExpField a) => NumHask.Algebra.Exponential.ExpField (r a)


-- | Integral domains
module NumHask.Algebra.Integral

-- | Integral
--   
--   <pre>
--   b == zero || b * (a `div` b) + (a `mod` b) == a
--   </pre>
class (Ring a) => Integral a where div a1 a2 = fst (divMod a1 a2) mod a1 a2 = snd (divMod a1 a2)

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

-- | toInteger and fromInteger as per the base <tt>Num</tt> instance is
--   problematic for numbers with a <tt>Basis</tt>
class (Integral a) => ToInteger a
toInteger :: ToInteger a => a -> Integer

-- | fromInteger
class (Ring a) => FromInteger a where fromInteger = slowFromInteger
fromInteger :: FromInteger a => Integer -> a

-- | This splitting away of fromInteger from the <a>Ring</a> instance tends
--   to increase constraint boier-plate
fromIntegral :: (ToInteger a, FromInteger b) => a -> b
instance NumHask.Algebra.Integral.Integral GHC.Types.Int
instance NumHask.Algebra.Integral.Integral GHC.Integer.Type.Integer
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Integral.Integral a) => NumHask.Algebra.Integral.Integral (r a)
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Double
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Float
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Int
instance NumHask.Algebra.Integral.FromInteger GHC.Integer.Type.Integer
instance NumHask.Algebra.Integral.ToInteger GHC.Types.Int
instance NumHask.Algebra.Integral.ToInteger GHC.Integer.Type.Integer


-- | Metric structure
module NumHask.Algebra.Metric

-- | providing the concepts of infinity and NaN, thus moving away from
--   error throwing
class (Field a) => BoundedField a where maxBound = one / zero minBound = negate (one / zero) nan = zero / zero
maxBound :: BoundedField a => a
minBound :: BoundedField a => a
nan :: BoundedField a => a
isNaN :: BoundedField a => a -> Bool

-- | prints as <tt>Infinity</tt>
infinity :: BoundedField a => a

-- | prints as `-Infinity`
neginfinity :: BoundedField a => a

-- | distance between numbers
class Metric a b
distance :: Metric a b => a -> a -> b

-- | Normed is a current wart on the NumHask api, causing all sorts of
--   runaway constraint boiler-plate.
class Normed a b
size :: Normed a b => a -> b

-- | abs and signnum are also warts on the standard <tt>Num</tt> class, and
--   are separated here to provide a cleaner structure.
class (AdditiveUnital a, AdditiveGroup a, Multiplicative a) => Signed a
sign :: Signed a => a -> a
abs :: Signed a => a -> a

-- | This should probably be split off into some sort of alternative
--   Equality logic, but to what end?
class (AdditiveGroup a) => Epsilon a
nearZero :: Epsilon a => a -> Bool
aboutEqual :: Epsilon a => a -> a -> Bool

-- | utf ???
(≈) :: (Epsilon a) => a -> a -> Bool
infixl 4 ≈

-- | quotient fields also explode constraints if they are polymorphed to
--   emit general integrals
class (Ring a) => QuotientField a
round :: QuotientField a => a -> Integer
ceiling :: QuotientField a => a -> Integer
floor :: QuotientField a => a -> Integer
(^^) :: QuotientField a => a -> Integer -> a
instance NumHask.Algebra.Metric.BoundedField GHC.Types.Float
instance NumHask.Algebra.Metric.BoundedField GHC.Types.Double
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Metric.BoundedField a) => NumHask.Algebra.Metric.BoundedField (r a)
instance NumHask.Algebra.Metric.Signed GHC.Types.Double
instance NumHask.Algebra.Metric.Signed GHC.Types.Float
instance NumHask.Algebra.Metric.Signed GHC.Types.Int
instance NumHask.Algebra.Metric.Signed GHC.Integer.Type.Integer
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Metric.Signed a) => NumHask.Algebra.Metric.Signed (r a)
instance NumHask.Algebra.Metric.Normed GHC.Types.Double GHC.Types.Double
instance NumHask.Algebra.Metric.Normed GHC.Types.Float GHC.Types.Float
instance NumHask.Algebra.Metric.Normed GHC.Types.Int GHC.Types.Int
instance NumHask.Algebra.Metric.Normed GHC.Integer.Type.Integer GHC.Integer.Type.Integer
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Exponential.ExpField a, NumHask.Algebra.Exponential.ExpRing a) => NumHask.Algebra.Metric.Normed (r a) a
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Double
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Float
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Int
instance NumHask.Algebra.Metric.Epsilon GHC.Integer.Type.Integer
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Metric.Epsilon a) => NumHask.Algebra.Metric.Epsilon (r a)
instance NumHask.Algebra.Metric.Metric GHC.Types.Double GHC.Types.Double
instance NumHask.Algebra.Metric.Metric GHC.Types.Float GHC.Types.Float
instance NumHask.Algebra.Metric.Metric GHC.Types.Int GHC.Types.Int
instance NumHask.Algebra.Metric.Metric GHC.Integer.Type.Integer GHC.Integer.Type.Integer
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Exponential.ExpField a) => NumHask.Algebra.Metric.Metric (r a) a
instance NumHask.Algebra.Metric.QuotientField GHC.Types.Float
instance NumHask.Algebra.Metric.QuotientField GHC.Types.Double


-- | Algebra
module NumHask.Algebra.Module

-- | AdditiveModule
class (Representable m, Additive a) => AdditiveModule m a where m .+ a = fmap (a +) m a +. m = fmap (a +) m
(.+) :: AdditiveModule m a => m a -> a -> m a
(+.) :: AdditiveModule m a => a -> m a -> m a

-- | AdditiveGroupModule
class (Representable m, AdditiveGroup a) => AdditiveGroupModule m a where m .- a = fmap (\ x -> x - a) m a -. m = fmap (\ x -> a - x) m
(.-) :: AdditiveGroupModule m a => m a -> a -> m a
(-.) :: AdditiveGroupModule m a => a -> m a -> m a

-- | MultiplicativeModule
class (Representable m, Multiplicative a) => MultiplicativeModule m a where m .* a = fmap (a *) m a *. m = fmap (a *) m
(.*) :: MultiplicativeModule m a => m a -> a -> m a
(*.) :: MultiplicativeModule m a => a -> m a -> m a

-- | MultiplicativeGroupModule
class (Representable m, MultiplicativeGroup a) => MultiplicativeGroupModule m a where m ./ a = fmap (/ a) m a /. m = fmap (\ x -> a / x) m
(./) :: MultiplicativeGroupModule m a => m a -> a -> m a
(/.) :: MultiplicativeGroupModule m a => a -> m a -> m a

-- | Banach
class (Representable m, ExpField a, Normed (m a) a) => Banach m a where normalize a = a ./ size a
normalize :: Banach m a => m a -> m a

-- | Hilbert
class (AdditiveGroup (m a)) => Hilbert m a
(<.>) :: Hilbert m a => m a -> m a -> a

-- | tensorial tomfoolery

-- | TensorAlgebra
class TensorProduct a
(><) :: TensorProduct a => a -> a -> (a >< a)
timesleft :: TensorProduct a => a -> (a >< a) -> a
timesright :: TensorProduct a => (a >< a) -> a -> a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Module.AdditiveModule r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Module.AdditiveGroupModule r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Module.MultiplicativeModule r a
instance (Data.Functor.Rep.Representable r, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Module.MultiplicativeGroupModule r a
instance (NumHask.Algebra.Exponential.ExpField a, Data.Foldable.Foldable r, Data.Functor.Rep.Representable r) => NumHask.Algebra.Module.Banach r a
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Ring.CRing a) => NumHask.Algebra.Module.Hilbert r a
instance (Data.Foldable.Foldable r, Data.Functor.Rep.Representable r, NumHask.Algebra.Ring.CRing a) => NumHask.Algebra.Module.TensorProduct (r a)


-- | N-dimensional arrays. Two classes are supplied:
--   
--   <ul>
--   <li><a>Tensor</a> where shape information is held at type level,
--   and</li>
--   <li><a>SomeTensor</a> where shape is held at the value level.</li>
--   </ul>
--   
--   In both cases, the underlying data is contained as a flat vector for
--   efficiency purposes.
module NumHask.Tensor

-- | an n-dimensional array where shape is specified at the type level The
--   main purpose of this, beyond safe typing, is to supply the
--   Representable instance with an initial object. A single Boxed
--   <a>Vector</a> is used underneath for efficient slicing, but this may
--   change or become polymorphic in the future.
newtype Tensor r a
Tensor :: Vector a -> Tensor r a
[flattenTensor] :: Tensor r a -> Vector a

-- | an n-dimensional array where shape is specified at the value level as
--   an '[Int]' Use this to avoid type-level hasochism by demoting a
--   <a>Tensor</a> with <a>someTensor</a>
data SomeTensor a
SomeTensor :: [Int] -> (Vector a) -> SomeTensor a

-- | convert a <a>Tensor</a> to a <a>SomeTensor</a>, losing the type level
--   shape
someTensor :: (SingI r) => Tensor (r :: [Nat]) a -> SomeTensor a

-- | convert a <a>SomeTensor</a> to a <a>Tensor</a> with no checks on
--   shape.
unsafeToTensor :: SomeTensor a -> Tensor (r :: [Nat]) a

-- | convert a <a>SomeTensor</a> to a <a>Tensor</a>, check for shape
--   equality.
toTensor :: forall a r. (SingI r) => SomeTensor a -> Maybe (Tensor (r :: [Nat]) a)

-- | convert the top layer of a SomeTensor to a [SomeTensor]
flatten1 :: SomeTensor a -> [SomeTensor a]
instance Data.Foldable.Foldable NumHask.Tensor.SomeTensor
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Tensor.SomeTensor a)
instance GHC.Base.Functor NumHask.Tensor.SomeTensor
instance GHC.Classes.Eq NumHask.Tensor.ShapeT
instance GHC.Show.Show NumHask.Tensor.ShapeT
instance forall k (r :: k). Data.Foldable.Foldable (NumHask.Tensor.Tensor r)
instance forall k (r :: k) a. GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Tensor.Tensor r a)
instance forall k (r :: k). GHC.Base.Functor (NumHask.Tensor.Tensor r)
instance Data.Singletons.SingI r => NumHask.HasShape.HasShape (NumHask.Tensor.Tensor r a)
instance NumHask.HasShape.HasShape (NumHask.Tensor.SomeTensor a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Tensor.SomeTensor a)
instance (GHC.Show.Show a, Data.Singletons.SingI r) => GHC.Show.Show (NumHask.Tensor.Tensor r a)
instance Data.Singletons.SingI r => Data.Distributive.Distributive (NumHask.Tensor.Tensor r)
instance Data.Singletons.SingI r => Data.Functor.Rep.Representable (NumHask.Tensor.Tensor r)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveUnital a) => GHC.Exts.IsList (NumHask.Tensor.Tensor r a)
instance Test.QuickCheck.Arbitrary.Arbitrary NumHask.Tensor.ShapeT
instance (Data.Singletons.SingI r, Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Tensor.Tensor r a)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Tensor.SomeTensor a)


-- | Two different classes are supplied:
--   
--   <ul>
--   <li><a>Vector</a> where shape information is held at the type level,
--   and</li>
--   <li><a>SomeVector</a> where shape is held at the value level.</li>
--   </ul>
module NumHask.Vector

-- | a one-dimensional array where shape is specified at the type level The
--   main purpose of this, beyond safe typing, is to supply the
--   Representable instance with an initial object. A Boxed <a>Vector</a>
--   is used underneath for efficient slicing, but this may change or
--   become polymorphic in the future.
newtype Vector (n :: Nat) a
Vector :: Vector a -> Vector a
[toVec] :: Vector a -> Vector a

-- | a one-dimensional array where shape is specified at the value level
--   Use this to avoid type-level hasochism by demoting a <a>Vector</a>
--   with <a>someVector</a>
data SomeVector a
SomeVector :: Int -> (Vector a) -> SomeVector a

-- | used to get sensible arbitrary instances of SomeVector
newtype ShapeV
ShapeV :: Int -> ShapeV
[unshapeV] :: ShapeV -> Int

-- | the shape value demoted from type-level
shapeV :: forall a r. (KnownNat r) => Vector (r :: Nat) a -> Int

-- | convert from a <a>Vector</a> to a <a>SomeVector</a>
someVector :: (KnownNat r) => Vector (r :: Nat) a -> SomeVector a

-- | convert from a <a>SomeVector</a> to a <a>Vector</a> with no shape
--   check
unsafeToVector :: SomeVector a -> Vector (r :: Nat) a

-- | convert from a <a>SomeVector</a> to a <a>Vector</a>, checking shape
toVector :: forall a r. (KnownNat r) => SomeVector a -> Maybe (Vector (r :: Nat) a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (NumHask.Vector.SomeVector a)
instance Data.Foldable.Foldable NumHask.Vector.SomeVector
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Vector.SomeVector a)
instance GHC.Base.Functor NumHask.Vector.SomeVector
instance GHC.Classes.Ord a => GHC.Classes.Ord (NumHask.Vector.Vector n a)
instance Data.Foldable.Foldable (NumHask.Vector.Vector n)
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Vector.Vector n a)
instance GHC.Base.Functor (NumHask.Vector.Vector n)
instance NumHask.HasShape.HasShape (NumHask.Vector.SomeVector a)
instance GHC.TypeLits.KnownNat r => NumHask.HasShape.HasShape (NumHask.Vector.Vector r a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Vector.SomeVector a)
instance (GHC.Show.Show a, GHC.TypeLits.KnownNat n) => GHC.Show.Show (NumHask.Vector.Vector n a)
instance (GHC.TypeLits.KnownNat n, NumHask.Algebra.Additive.AdditiveUnital a) => GHC.Exts.IsList (NumHask.Vector.Vector n a)
instance GHC.Exts.IsList (NumHask.Vector.SomeVector a)
instance Test.QuickCheck.Arbitrary.Arbitrary NumHask.Vector.ShapeV
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Vector.SomeVector a)
instance (GHC.TypeLits.KnownNat n, Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Vector.Vector n a)
instance GHC.TypeLits.KnownNat n => Data.Distributive.Distributive (NumHask.Vector.Vector n)
instance GHC.TypeLits.KnownNat n => Data.Functor.Rep.Representable (NumHask.Vector.Vector n)


-- | Two-dimensional arrays. Two classes are supplied
--   
--   <ul>
--   <li><a>Matrix</a> where shape information is held at type level,
--   and</li>
--   <li><a>SomeMatrix</a> where shape is held at the value level.</li>
--   </ul>
--   
--   In both cases, the underlying data is contained as a flat vector for
--   efficiency purposes.
module NumHask.Matrix

-- | a two-dimensional array where shape is specified at the type level The
--   main purpose of this, beyond safe typing, is to supply the
--   Representable instance with an initial object. A single Boxed
--   <a>Vector</a> is used underneath for efficient slicing, but this may
--   change or become polymorphic in the future.
newtype Matrix m n a
Matrix :: Vector a -> Matrix m n a
[flattenMatrix] :: Matrix m n a -> Vector a

-- | a two-dimensional array where shape is specified at the value level as
--   a '(Int,Int)' Use this to avoid type-level hasochism by demoting a
--   <a>Matrix</a> with <a>someMatrix</a>
data SomeMatrix a
SomeMatrix :: (Int, Int) -> (Vector a) -> SomeMatrix a

-- | just used to get sensible arbitrary instances of SomeMatrix
newtype ShapeM
ShapeM :: (Int, Int) -> ShapeM
[unshapeM] :: ShapeM -> (Int, Int)

-- | convert from a <a>Matrix</a> to a <a>SomeMatrix</a>
someMatrix :: (KnownNat m, KnownNat n) => Matrix (m :: Nat) (n :: Nat) a -> SomeMatrix a

-- | convert from a <a>SomeMatrix</a> to a <a>Matrix</a> with no shape
--   check
unsafeToMatrix :: SomeMatrix a -> Matrix (m :: Nat) (n :: Nat) a

-- | convert from a <a>SomeMatrix</a> to a <a>Matrix</a>, checking shape
toMatrix :: forall a m n. (KnownNat m, KnownNat n) => SomeMatrix a -> Maybe (Matrix (m :: Nat) (n :: Nat) a)

-- | conversion from a double Vector representation
unsafeFromVV :: forall a m n. Vector m (Vector n a) -> Matrix m n a

-- | convert a <a>Vector</a> to a column <a>Matrix</a>
toCol :: forall a n. Vector n a -> Matrix 1 n a

-- | convert a <a>Vector</a> to a row <a>Matrix</a>
toRow :: forall a m. Vector m a -> Matrix m 1 a

-- | convert a row <a>Matrix</a> to a <a>Vector</a>
fromCol :: forall a n. Matrix 1 n a -> Vector n a

-- | convert a column <a>Matrix</a> to a <a>Vector</a>
fromRow :: forall a m. Matrix m 1 a -> Vector m a

-- | extract a column from a <a>Matrix</a> as a <a>Vector</a>
col :: forall a m n. (KnownNat m, KnownNat n) => Int -> Matrix m n a -> Vector m a

-- | extract a row from a <a>Matrix</a> as a <a>Vector</a>
row :: forall a m n. (KnownNat m, KnownNat n) => Int -> Matrix m n a -> Vector n a

-- | matrix multiplication for a <a>Matrix</a>
mmult :: forall m n k a. (CRing a, KnownNat m, KnownNat n, KnownNat k) => Matrix m k a -> Matrix k n a -> Matrix m n a
instance Data.Foldable.Foldable NumHask.Matrix.SomeMatrix
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Matrix.SomeMatrix a)
instance GHC.Base.Functor NumHask.Matrix.SomeMatrix
instance forall k (m :: k) k1 (n :: k1). Data.Foldable.Foldable (NumHask.Matrix.Matrix m n)
instance forall k (m :: k) k1 (n :: k1) a. GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Matrix.Matrix m n a)
instance forall k (m :: k) k1 (n :: k1). GHC.Base.Functor (NumHask.Matrix.Matrix m n)
instance NumHask.HasShape.HasShape (NumHask.Matrix.SomeMatrix a)
instance (GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n) => NumHask.HasShape.HasShape (NumHask.Matrix.Matrix m n a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Matrix.SomeMatrix a)
instance (GHC.Show.Show a, GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n) => GHC.Show.Show (NumHask.Matrix.Matrix m n a)
instance (GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n, NumHask.Algebra.Additive.AdditiveUnital a) => GHC.Exts.IsList (NumHask.Matrix.Matrix m n a)
instance GHC.Exts.IsList (NumHask.Matrix.SomeMatrix a)
instance Test.QuickCheck.Arbitrary.Arbitrary NumHask.Matrix.ShapeM
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Matrix.SomeMatrix a)
instance (GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n, Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Matrix.Matrix m n a)
instance (GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n) => Data.Distributive.Distributive (NumHask.Matrix.Matrix m n)
instance (GHC.TypeLits.KnownNat m, GHC.TypeLits.KnownNat n) => Data.Functor.Rep.Representable (NumHask.Matrix.Matrix m n)


-- | A prelude for NumHask
module NumHask.Prelude


-- | NumHask usage examples
module NumHask.Examples


-- | Just the numeric tower bits of NumHask
module NumHask.Algebra


-- | Orphan instances for conversion between Num and NumHask classes.
module NumHask.Num
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveMagma a
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveUnital a
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveAssociative a
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveCommutative a
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveInvertible a
instance GHC.Num.Num a => NumHask.Algebra.Additive.Additive a
instance GHC.Num.Num a => NumHask.Algebra.Additive.AdditiveGroup a
instance GHC.Num.Num a => NumHask.Algebra.Multiplicative.MultiplicativeMagma a
instance GHC.Num.Num a => NumHask.Algebra.Multiplicative.MultiplicativeUnital a
instance GHC.Num.Num a => NumHask.Algebra.Multiplicative.MultiplicativeCommutative a
instance GHC.Num.Num a => NumHask.Algebra.Multiplicative.MultiplicativeAssociative a
instance GHC.Real.Fractional a => NumHask.Algebra.Multiplicative.MultiplicativeInvertible a
instance GHC.Num.Num a => NumHask.Algebra.Multiplicative.Multiplicative a
instance GHC.Real.Fractional a => NumHask.Algebra.Multiplicative.MultiplicativeGroup a
instance GHC.Num.Num a => NumHask.Algebra.Distribution.Distribution a
instance GHC.Num.Num a => NumHask.Algebra.Ring.Semiring a
instance GHC.Num.Num a => NumHask.Algebra.Ring.Ring a
instance GHC.Num.Num a => NumHask.Algebra.Ring.CRing a
instance GHC.Real.Fractional a => NumHask.Algebra.Field.Field a
instance GHC.Num.Num a => NumHask.Algebra.Metric.Normed a a
instance (NumHask.Algebra.Additive.Additive a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.FromInteger a) => GHC.Num.Num a
instance (Data.Functor.Rep.Representable r, GHC.Num.Num a) => GHC.Num.Num (r a)