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

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

-- | 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.Let6989586621679108046Scrutinee_6989586621679105664Sym3
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679108046Scrutinee_6989586621679105664Sym2
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679108046Scrutinee_6989586621679105664Sym1
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.Let6989586621679108046Scrutinee_6989586621679105664Sym0
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.DimShuffleSym1
instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings NumHask.Array.Constraints.DimShuffleSym0
instance GHC.Classes.Eq GHC.Types.Nat
instance GHC.Classes.Ord GHC.Types.Nat


-- | safe-typed n-dimensional arrays
module NumHask.Array

-- | 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.
--   
--   <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>
newtype Array (r :: [Nat]) a
Array :: (Vector a) -> Array a

-- | an n-dimensional array where shape is specified at the value level
data SomeArray a
SomeArray :: [Int] -> (Vector a) -> SomeArray a

-- | extract the row of a matrix
row :: forall i a m n. (KnownNat m, KnownNat n, KnownNat i, (i :< m) ~ True) => Proxy i -> Array '[m, n] a -> Array '[n] a

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

-- | <pre>
--   &gt;&gt;&gt; slice (Proxy :: Proxy '[ '[0,1],'[2],'[1,2]]) a
--   [[[10, 11]],
--    [[22, 23]]]
--   </pre>
slice :: forall s r a. (SingI s, SingI r, And (ZipWith AllLTSym0 s r) ~ True) => Proxy s -> Array r a -> Array (Slice s) a

-- | <pre>
--   &gt;&gt;&gt; unsafeSlice [[0,1],[2],[1,2]] a :: Array '[2,1,2] Int
--   [[[10, 11]],
--    [[22, 23]]]
--   </pre>
unsafeSlice :: (SingI r) => [[Int]] -> Array r a -> Array r0 a
index :: Representable f => forall a. f a -> Rep f -> a

-- | <pre>
--   &gt;&gt;&gt; unsafeIndex a [0,2,1]
--   10
--   </pre>
unsafeIndex :: SingI r => Array r a -> [Int] -> a

-- | <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 s vw uvw uw w a. (SingI s, SingI uvw, uw ~ (Fold s uvw), w ~ (Drop 1 vw), vw ~ (TailModule s uvw)) => Proxy s -> (Array vw a -> Array w a) -> Array uvw a -> Array uw a

-- | <pre>
--   &gt;&gt;&gt; mapAlong (Proxy :: Proxy 0) (\x -&gt; NumHask.Array.zipWith (*) x x) a
--   [[[1, 4, 9, 16],
--     [25, 36, 49, 64],
--     [81, 100, 121, 144]],
--    [[169, 196, 225, 256],
--     [289, 324, 361, 400],
--     [441, 484, 529, 576]]]
--   </pre>
mapAlong :: forall s uvw vw a. (SingI s, SingI uvw, vw ~ (HeadModule s uvw)) => Proxy s -> (Array vw a -> Array vw a) -> Array uvw a -> Array 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 s r t a. (SingI s, SingI r, SingI t, (IsValidConcat s t r) ~ True) => Proxy s -> Array r a -> Array t a -> Array (Concatenate s t r) a
zipWith :: (a -> a -> a) -> Array s a -> Array s a -> Array s 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 s t a. (t ~ Transpose s) => Array s a -> Array 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 s t a. (t ~ Squeeze s) => Array s a -> Array t a

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

-- | matrix multiplication for a '2-Array'
--   
--   <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]]
--   
--   &gt;&gt;&gt; b
--   [[5, 6],
--    [7, 8]]
--   
--   &gt;&gt;&gt; mmult a b
--   [[19, 22],
--    [43, 50]]
--   </pre>
mmult :: forall m n k a. (Semiring a, Num a, CRing a, KnownNat m, KnownNat n, KnownNat k) => Array '[m, k] a -> Array '[k, n] a -> Array '[m, n] a

-- | The <a>fromList</a> function constructs the structure <tt>l</tt> from
--   the given list of <tt>Item l</tt>
fromList :: IsList l => [Item l] -> l
instance Data.Foldable.Foldable NumHask.Array.SomeArray
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Array.SomeArray a)
instance GHC.Base.Functor NumHask.Array.SomeArray
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (NumHask.Array.Array r a)
instance GHC.Generics.Generic1 (NumHask.Array.Array r)
instance GHC.Generics.Generic (NumHask.Array.Array r a)
instance Data.Foldable.Foldable (NumHask.Array.Array r)
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Array.Array r a)
instance GHC.Base.Functor (NumHask.Array.Array r)
instance Data.Singletons.SingI r => NumHask.Shape.HasShape (NumHask.Array.Array r)
instance Data.Singletons.SingI r => Data.Distributive.Distributive (NumHask.Array.Array r)
instance Data.Singletons.SingI r => Data.Functor.Rep.Representable (NumHask.Array.Array r)
instance (Data.Singletons.SingI r, GHC.Num.Num a) => GHC.Exts.IsList (NumHask.Array.Array r a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Array.SomeArray a)
instance (GHC.Show.Show a, Data.Singletons.SingI r) => GHC.Show.Show (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveMagma a) => NumHask.Algebra.Additive.AdditiveMagma (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveUnital a) => NumHask.Algebra.Additive.AdditiveUnital (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveAssociative a) => NumHask.Algebra.Additive.AdditiveAssociative (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveCommutative a) => NumHask.Algebra.Additive.AdditiveCommutative (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveInvertible (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Additive.Additive (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Additive.AdditiveGroup (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeMagma a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeAssociative a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeCommutative a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Multiplicative.MultiplicativeMagma a, NumHask.Algebra.Additive.Additive a) => NumHask.Algebra.Distribution.Distribution (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Ring.Semiring a) => NumHask.Algebra.Ring.Semiring (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Ring.Ring (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Ring.CRing a) => NumHask.Algebra.Ring.CRing (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Field.Field a) => NumHask.Algebra.Field.Field (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Field.ExpField (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Field.BoundedField (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Metric.Signed a) => NumHask.Algebra.Metric.Signed (NumHask.Array.Array r a)
instance NumHask.Algebra.Field.ExpField a => NumHask.Algebra.Metric.Normed (NumHask.Array.Array r a) a
instance (Data.Singletons.SingI r, NumHask.Algebra.Metric.Epsilon a) => NumHask.Algebra.Metric.Epsilon (NumHask.Array.Array r a)
instance (Data.Singletons.SingI r, NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Metric.Metric (NumHask.Array.Array r a) a
instance (Data.Singletons.SingI r, NumHask.Algebra.Integral.Integral a) => NumHask.Algebra.Integral.Integral (NumHask.Array.Array r a)
instance (NumHask.Algebra.Ring.CRing a, GHC.Num.Num a, NumHask.Algebra.Ring.Semiring a, Data.Singletons.SingI r) => NumHask.Algebra.Module.Hilbert (NumHask.Array.Array r) a


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