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


-- | See readme.md
--   
--   See readme.md for description.
@package numhask-array
@version 0.1.1.0

module NumHask.Array.Constraints
dimShuffle :: Eq a_alfJ => [a_alfJ] -> [Nat] -> [a_alfJ]

-- | Reduces axis i in shape s. Does not maintain singlton dimension.

-- | Reduces axis i in shape s. Maintains singlton dimension
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.DimShuffleSym1
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.DimShuffleSym0
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679094967Scrutinee_6989586621679091497Sym0
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679094967Scrutinee_6989586621679091497Sym1
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679094967Scrutinee_6989586621679091497Sym2
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679094967Scrutinee_6989586621679091497Sym3


-- | numbers with a shape
module NumHask.Shape

-- | Not everything that has a shape is representable.
--   
--   todo: Structure is a useful alternative concept/naming convention
class HasShape f where {
    type family Shape f;
}
shape :: HasShape f => f a -> Shape f

-- | A <a>Functor</a> <tt>f</tt> is <a>Representable</a> if <a>tabulate</a>
--   and <a>index</a> witness an isomorphism to <tt>(-&gt;) x</tt>.
--   
--   Every <a>Distributive</a> <a>Functor</a> is actually
--   <a>Representable</a>.
--   
--   Every <a>Representable</a> <a>Functor</a> from Hask to Hask is a right
--   adjoint.
--   
--   <pre>
--   <a>tabulate</a> . <a>index</a>  ≡ id
--   <a>index</a> . <a>tabulate</a>  ≡ id
--   <a>tabulate</a> . <a>return</a> ≡ <a>return</a>
--   </pre>
class Distributive f => Representable (f :: * -> *) where {
    type family Rep (f :: * -> *) :: *;
}

-- | <pre>
--   <a>fmap</a> f . <a>tabulate</a> ≡ <a>tabulate</a> . <a>fmap</a> f
--   </pre>
--   
--   If no definition is provided, this will default to <a>gtabulate</a>.
tabulate :: Representable f => (Rep f -> a) -> f a

-- | If no definition is provided, this will default to <a>gindex</a>.
index :: Representable f => f a -> Rep f -> a

module NumHask.Array

-- | an array polymorphic in container and shape
--   
--   <pre>
--   &gt;&gt;&gt; a
--   [[[1, 2, 3, 4],
--     [5, 6, 7, 8],
--     [9, 10, 11, 12]],
--    [[13, 14, 15, 16],
--     [17, 18, 19, 20],
--     [21, 22, 23, 24]]]
--   </pre>

-- | instance where dimensions are known at compile time

-- | instance of array where some of the dimensions are known at compile
--   time it wraps an Array with some weird magic

-- | an array with dimensions represented at the value level
newtype AnyArray c a
AnyArray :: ([Int], c a) -> AnyArray c a

-- | convert an array with type-level shape to value-level shape
anyArray :: (Dimensions ds) => Array c ds a -> AnyArray c a

-- | a sweet class of container with attributes necessary to supply the set
--   of operations here
class (Functor f) => Container f
generate :: Container f => Int -> (Int -> a) -> f a
idx :: Container f => f a -> Int -> a
cslice :: Container f => Int -> Int -> f a -> f a
zipWith :: Container f => (a -> a -> a) -> f a -> f a -> f a
chunkItUp :: Container f => [f a] -> Int -> f a -> [f a]
cfoldl' :: Container f => (b -> a -> b) -> b -> f a -> b
cfoldr :: Container f => (a -> b -> b) -> b -> f a -> b
cconcat :: Container f => [f a] -> f a
xdimList :: XDim ds -> [Int]
dimList :: Dim ds -> [Int]

-- | convert from n-dim shape index to a flat index
--   
--   <pre>
--   &gt;&gt;&gt; ind [2,3,4] [1,1,1]
--   17
--   </pre>
ind :: [Int] -> [Int] -> Int

-- | convert from a flat index to a shape index
--   
--   <pre>
--   &gt;&gt;&gt; unind [2,3,4] 17
--   [1,1,1]
--   </pre>
unind :: [Int] -> Int -> [Int]

-- | from flat list

-- | convert the top layer of a SomeArray to a [SomeArray]
flatten1 :: (Container c) => AnyArray c a -> [AnyArray c a]
type Vector c n = Array c '[n]
type Matrix c m n = Array c '[m, n]

-- | outer product
--   
--   todo: reconcile with numhask version
--   
--   <pre>
--   &gt;&gt;&gt; v NumHask.Array.&gt;&lt; v
--   [[1, 2, 3],
--    [2, 4, 6],
--    [3, 6, 9]]
--   </pre>
(><) :: forall c (r :: [Nat]) (s :: [Nat]) a. (Container c, CRing a, Dimensions r, Dimensions s, Dimensions (r ++ s)) => Array c r a -> Array c s a -> Array c (r ++ s) a

-- | matrix multiplication
--   
--   <pre>
--   &gt;&gt;&gt; let a = [1, 2, 3, 4] :: Array [] '[2, 2] Int
--   
--   &gt;&gt;&gt; let b = [5, 6, 7, 8] :: Array [] '[2, 2] Int
--   
--   &gt;&gt;&gt; a
--   [[1, 2],
--    [3, 4]]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; b
--   [[5, 6],
--    [7, 8]]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; mmult a b
--   [[19, 22],
--    [43, 50]]
--   </pre>
mmult :: forall c m n k a. (Hilbert (Vector c k) a, Dimensions '[m, k], Dimensions '[k, n], Dimensions '[m, n], Container c, Semiring a, Num a, CRing a, KnownNat m, KnownNat n, KnownNat k) => Matrix c m k a -> Matrix c k n a -> Matrix c m n a

-- | extract the row of a matrix
row :: forall c i a m n. (Dimensions '[m, n], Container c, KnownNat m, KnownNat n, KnownNat i, (i :< m) ~  'True) => Proxy i -> Matrix c m n a -> Vector c n a
unsafeRow :: forall c a m n. (Container c, KnownNat m, KnownNat n, Dimensions '[m, n]) => Int -> Matrix c m n a -> Vector c n a

-- | extract the column of a matrix
col :: forall c j a m n. (Dimensions '[m, n], Container c, KnownNat m, KnownNat n, KnownNat j, (j :< n) ~  'True) => Proxy j -> Matrix c m n a -> Vector c m a
unsafeCol :: forall c a m n. (Container c, KnownNat m, KnownNat n, Dimensions '[m, n]) => Int -> Matrix c m n a -> Vector c m a

-- | <pre>
--   &gt;&gt;&gt; unsafeIndex a [0,2,1]
--   10
--   </pre>
unsafeIndex :: (Container c, Dimensions r) => Array c r a -> [Int] -> a

-- | <pre>
--   &gt;&gt;&gt; unsafeSlice [[0,1],[2],[1,2]] a :: Array [] '[2,1,2] Int
--   [[[10, 11]],
--    [[22, 23]]]
--   </pre>
unsafeSlice :: (Container c, IsList (c a), Item (c a) ~ a, Dimensions r, Dimensions r0) => [[Int]] -> Array c r a -> Array c r0 a

-- | Slice xs = Map Length xs

-- | AllLT xs n = All (n &gt;) xs
data AllLTSym0 (a :: TyFun [Nat] (TyFun Nat Bool -> Type))
data AllLTSym1 (l :: [Nat]) (a :: TyFun Nat Bool)

-- | todo: an ambiguous type variable has snucjk in here somewhere
--   
--   <pre>
--   slice (Proxy :: Proxy '[ '[0,1],'[2],'[1,2]]) a
--   </pre>
--   
--   <ul>
--   <li><i>[[10, 11</i> ],</li>
--   <li><i>[22, 23</i> ]]</li>
--   </ul>
slice :: ((~#) * * Item c a1 a1, SingI [[Nat]] a2, Dimensions r0, Dimensions r, IsList c a1, Container c) => proxy a2 -> Array Nat c r a1 -> Array Nat c r0 a1

-- | <pre>
--   &gt;&gt;&gt; foldAlong (Proxy :: Proxy 1) (\_ -&gt; ([0..3] :: Array [] '[4] Int)) a
--   [[0, 1, 2, 3],
--    [0, 1, 2, 3]]
--   </pre>
--   
--   todo: resolution of a primitive and a scalar eg Expected type: Array
--   '[10] Int -&gt; Array '[] Int Actual type: Array '[10] (Array '[] Int)
--   -&gt; Array '[] Int
foldAlong :: forall c s vw uvw uw w a. (Container c, KnownNat s, Dimensions uvw, uw ~ (Fold s uvw), w ~ (Drop 1 vw), vw ~ (TailModule s uvw)) => Proxy s -> (Array c vw a -> Array c w a) -> Array c uvw a -> Array c uw a

-- | todo: No instance for (Container (Array [] '[]) error
--   
--   <pre>
--   mapAlong (Proxy :: Proxy 0) (\x -&gt; NumHask.Array.zipWith (*) x x) a
--   </pre>
--   
--   <ul>
--   <li><i>[[1, 4, 9, 16</i> ,</li>
--   <li><i>25, 36, 49, 64</i> ,</li>
--   <li><i>81, 100, 121, 144</i> ],</li>
--   <li><i>[169, 196, 225, 256</i> ,</li>
--   <li><i>289, 324, 361, 400</i> ,</li>
--   <li><i>441, 484, 529, 576</i> ]]</li>
--   </ul>
mapAlong :: forall c s uvw vw a. (Container c, KnownNat s, Dimensions uvw, vw ~ (HeadModule s uvw)) => Proxy s -> (Array c vw a -> Array c vw a) -> Array c uvw a -> Array c uvw a

-- | <pre>
--   &gt;&gt;&gt; concatenate (Proxy :: Proxy 2) a a
--   [[[1, 2, 3, 4, 1, 2, 3, 4],
--     [5, 6, 7, 8, 5, 6, 7, 8],
--     [9, 10, 11, 12, 9, 10, 11, 12]],
--    [[13, 14, 15, 16, 13, 14, 15, 16],
--     [17, 18, 19, 20, 17, 18, 19, 20],
--     [21, 22, 23, 24, 21, 22, 23, 24]]]
--   </pre>
concatenate :: forall c s r t a. (Container c, SingI s, Dimensions r, Dimensions t, (IsValidConcat s t r) ~  'True) => Proxy s -> Array c r a -> Array c t a -> Array c (Concatenate s t r) a

-- | <pre>
--   &gt;&gt;&gt; NumHask.Array.transpose a
--   [[[1, 2],
--     [3, 4],
--     [5, 6]],
--    [[7, 8],
--     [9, 10],
--     [11, 12]],
--    [[13, 14],
--     [15, 16],
--     [17, 18]],
--    [[19, 20],
--     [21, 22],
--     [23, 24]]]
--   </pre>
transpose :: forall c s t a. (t ~ Transpose s, Container c, Dimensions s, Dimensions t) => Array c s a -> Array c t a

-- | <pre>
--   &gt;&gt;&gt; let a = [1..24] :: Array [] '[2,1,3,4,1] Int
--   
--   &gt;&gt;&gt; a
--   [[[[[1],
--       [2],
--       [3],
--       [4]],
--      [[5],
--       [6],
--       [7],
--       [8]],
--      [[9],
--       [10],
--       [11],
--       [12]]]],
--    [[[[13],
--       [14],
--       [15],
--       [16]],
--      [[17],
--       [18],
--       [19],
--       [20]],
--      [[21],
--       [22],
--       [23],
--       [24]]]]]
--   
--   &gt;&gt;&gt; squeeze a
--   [[[1, 2, 3, 4],
--     [5, 6, 7, 8],
--     [9, 10, 11, 12]],
--    [[13, 14, 15, 16],
--     [17, 18, 19, 20],
--     [21, 22, 23, 24]]]
--   </pre>
squeeze :: forall c s t a. (t ~ Squeeze s) => Array c s a -> Array c t a
instance Data.Foldable.Foldable c => Data.Foldable.Foldable (NumHask.Array.Array c ds)
instance GHC.Base.Functor c => GHC.Base.Functor (NumHask.Array.Array c ds)
instance (GHC.Exts.IsList (c a), GHC.Exts.Item (c a) ~ a, NumHask.Algebra.Additive.AdditiveUnital (NumHask.Array.Matrix c m n a), GHC.TypeNats.KnownNat m, GHC.TypeNats.KnownNat n, Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a, GHC.Num.Num a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Array.Matrix c m n a)
instance (GHC.Exts.IsList (c a), GHC.Exts.Item (c a) ~ a, GHC.TypeNats.KnownNat n, NumHask.Algebra.Additive.AdditiveUnital (NumHask.Array.Vector c n a), Test.QuickCheck.Arbitrary.Arbitrary a, NumHask.Algebra.Additive.AdditiveUnital a, GHC.Num.Num a) => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Array.Vector c n a)
instance NumHask.Array.Container Data.Vector.Vector
instance NumHask.Array.Container []
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c) => Data.Distributive.Distributive (NumHask.Array.Array c r)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c) => Data.Functor.Rep.Representable (NumHask.Array.Array c r)
instance (GHC.Show.Show a, GHC.Show.Show (GHC.Exts.Item (c a)), NumHask.Array.Container c, GHC.Exts.IsList (c a)) => GHC.Show.Show (NumHask.Array.AnyArray c a)
instance (GHC.Show.Show a, GHC.Show.Show (GHC.Exts.Item (c a)), GHC.Exts.IsList (c a), NumHask.Array.Container c, Numeric.Dimensions.Dim.Dimensions ds) => GHC.Show.Show (NumHask.Array.Array c ds a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveMagma a) => NumHask.Algebra.Additive.AdditiveMagma (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveUnital a) => NumHask.Algebra.Additive.AdditiveUnital (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveAssociative a) => NumHask.Algebra.Additive.AdditiveAssociative (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveCommutative a) => NumHask.Algebra.Additive.AdditiveCommutative (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveInvertible (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Additive.Additive (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Additive.AdditiveGroup (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeMagma a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeAssociative a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeCommutative a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeMagma a, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Distribution.Distribution (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Ring.Semiring a) => NumHask.Algebra.Ring.Semiring (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Ring.Ring (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Ring.CRing a) => NumHask.Algebra.Ring.CRing (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Field.Field a) => NumHask.Algebra.Field.Field (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Field.ExpField (NumHask.Array.Array c r a)
instance (Data.Foldable.Foldable (NumHask.Array.Array c r), Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Field.BoundedField (NumHask.Array.Array c r a)
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Metric.Signed a) => NumHask.Algebra.Metric.Signed (NumHask.Array.Array c r a)
instance (Data.Foldable.Foldable (NumHask.Array.Array c r), Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Metric.Epsilon a) => NumHask.Algebra.Metric.Epsilon (NumHask.Array.Array c r a)
instance (Data.Foldable.Foldable (NumHask.Array.Array c r), Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Metric.Metric (NumHask.Array.Array c r a) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Integral.Integral a) => NumHask.Algebra.Integral.Integral (NumHask.Array.Array c r a)
instance (Data.Foldable.Foldable (NumHask.Array.Array c r), NumHask.Algebra.Ring.CRing a, NumHask.Algebra.Ring.Semiring a, Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c) => NumHask.Algebra.Module.Hilbert (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Basis.AdditiveBasis (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Basis.AdditiveGroupBasis (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Basis.MultiplicativeBasis (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Basis.MultiplicativeGroupBasis (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Module.AdditiveModule (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Module.AdditiveGroupModule (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Module.MultiplicativeModule (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Module.MultiplicativeGroupModule (NumHask.Array.Array c r) a
instance (Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c) => NumHask.Algebra.Singleton.Singleton (NumHask.Array.Array c r)
instance (Data.Foldable.Foldable (NumHask.Array.Array c r), Numeric.Dimensions.Dim.Dimensions r, NumHask.Array.Container c, NumHask.Algebra.Ring.CRing a, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Module.TensorProduct (NumHask.Array.Array c r a)
instance (GHC.Classes.Eq (c t), Numeric.Dimensions.Dim.Dimensions ds) => GHC.Classes.Eq (NumHask.Array.Array c ds t)
instance Numeric.Dimensions.Dim.Dimensions r => NumHask.Shape.HasShape (NumHask.Array.Array c r)
instance NumHask.Shape.HasShape (NumHask.Array.Array c xds)
instance (GHC.Exts.Item (NumHask.Array.Array c r a) ~ GHC.Exts.Item (c a), Numeric.Dimensions.Dim.Dimensions r, NumHask.Algebra.Additive.AdditiveUnital a, GHC.Exts.IsList (c a)) => GHC.Exts.IsList (NumHask.Array.Array c r a)
instance forall k (c :: * -> *) (r :: [k]) a. (GHC.Base.Functor (NumHask.Array.Array c r), Data.Foldable.Foldable (NumHask.Array.Array c r), NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Metric.Normed (NumHask.Array.Array c r a) a


-- | Experimental api following
--   <a>https://pechersky.github.io/haskell-numpy-docs/quickstart.basics.html</a>
module NumHask.Array.Example