module Data.Tensor.Space where

import           Data.Proxy
import           Data.Tensor.Tensor
import           Data.Tensor.Type
import qualified Data.Vector        as V
import           GHC.TypeLits

-- | Return evenly spaced numbers over a specified interval.
--
-- > λ> linspace 1 10 :: Tensor '[10] Float
-- > [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,..,10.0]
linspace :: forall s n. (KnownNat s, Fractional n) => n -> n -> Vector s n
linspace :: n -> n -> Vector s n
linspace = (n -> n -> Integer -> n)
-> (n -> n -> Integer -> n) -> n -> n -> Vector s n
forall (s :: Nat) n.
KnownNat s =>
(n -> n -> Integer -> n)
-> (n -> n -> Integer -> n) -> n -> n -> Vector s n
space (\n
d n
s Integer
i -> n
s n -> n -> n
forall a. Num a => a -> a -> a
+ n
d n -> n -> n
forall a. Num a => a -> a -> a
* Integer -> n
forall a. Num a => Integer -> a
fromInteger Integer
i) (\n
s n
e Integer
c -> (n
e n -> n -> n
forall a. Num a => a -> a -> a
- n
s) n -> n -> n
forall a. Fractional a => a -> a -> a
/ Integer -> n
forall a. Num a => Integer -> a
fromInteger (Integer
c Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1))

-- | Return numbers spaced evenly on a log scale (a geometric progression).
--
-- > λ> geospace 1 10 :: Vector 10 Float
-- > [1.0,1.2915497,1.6681006,2.1544347,2.7825596,3.593814,4.641589,5.994843,..,10.000001]
geospace :: forall s n. (KnownNat s, Floating n, Eq n) => n -> n -> Vector s n
geospace :: n -> n -> Vector s n
geospace n
start n
end
  | n
start n -> n -> Bool
forall a. Eq a => a -> a -> Bool
== n
0 = [Char] -> Vector s n
forall a. HasCallStack => [Char] -> a
error [Char]
"divided by zero"
  | Bool
otherwise  = (n -> n -> Integer -> n)
-> (n -> n -> Integer -> n) -> n -> n -> Vector s n
forall (s :: Nat) n.
KnownNat s =>
(n -> n -> Integer -> n)
-> (n -> n -> Integer -> n) -> n -> n -> Vector s n
space (\n
d n
s Integer
i -> n
s n -> n -> n
forall a. Num a => a -> a -> a
* (n
d n -> n -> n
forall a. Floating a => a -> a -> a
** Integer -> n
forall a. Num a => Integer -> a
fromInteger Integer
i)) (\n
s n
e Integer
c -> (n
e n -> n -> n
forall a. Fractional a => a -> a -> a
/ n
s) n -> n -> n
forall a. Floating a => a -> a -> a
** (n
1 n -> n -> n
forall a. Fractional a => a -> a -> a
/ Integer -> n
forall a. Num a => Integer -> a
fromInteger (Integer
c Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1))) n
start n
end

-- | Return numbers spaced evenly on a log scale.
--
-- In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop
--
-- > λ> logspace 10 2 3 :: Vector 4 Float
-- > [100.0,215.44347,464.15887,1000.0]
logspace :: forall s n. (KnownNat s, Floating n, Eq n) => n -> n -> n -> Vector s n
logspace :: n -> n -> n -> Vector s n
logspace n
base n
s n
e = n -> n -> Vector s n
forall (s :: Nat) n.
(KnownNat s, Floating n, Eq n) =>
n -> n -> Vector s n
geospace (n
base n -> n -> n
forall a. Floating a => a -> a -> a
** n
s) (n
base n -> n -> n
forall a. Floating a => a -> a -> a
** n
e)

space :: forall s n. (KnownNat s) => (n -> n -> Integer -> n) -> (n -> n -> Integer -> n) -> n -> n -> Vector s n
space :: (n -> n -> Integer -> n)
-> (n -> n -> Integer -> n) -> n -> n -> Vector s n
space = Integer
-> (n -> n -> Integer -> n)
-> (n -> n -> Integer -> n)
-> n
-> n
-> Vector s n
forall t t t (s :: [Nat]).
Integer
-> (t -> t -> Integer -> t)
-> (t -> t -> Integer -> t)
-> t
-> t
-> Tensor s t
go (Proxy s -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy s
forall k (t :: k). Proxy t
Proxy :: Proxy s))
  where
    go :: Integer
-> (t -> t -> Integer -> t)
-> (t -> t -> Integer -> t)
-> t
-> t
-> Tensor s t
go Integer
count t -> t -> Integer -> t
g t -> t -> Integer -> t
f t
start t
end
      | Integer
count Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
1 = t -> Tensor s t
forall (f :: * -> *) a. Applicative f => a -> f a
pure t
start
      | Bool
otherwise =
        let d :: t
d  = t -> t -> Integer -> t
f t
start t
end Integer
count
            v :: Vector t
v  = Int -> (Int -> t) -> Vector t
forall a. Int -> (Int -> a) -> Vector a
V.generate (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
count) (t -> t -> Integer -> t
g t
d t
start (Integer -> t) -> (Int -> Integer) -> Int -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a. Integral a => a -> Integer
toInteger)
        in (Shape -> Shape -> t) -> Tensor s t
forall (s :: [Nat]) n. (Shape -> Shape -> n) -> Tensor s n
Tensor ((Shape -> Shape -> t) -> Tensor s t)
-> (Shape -> Shape -> t) -> Tensor s t
forall a b. (a -> b) -> a -> b
$ \Shape
s Shape
i -> Vector t
v Vector t -> Int -> t
forall a. Vector a -> Int -> a
V.! Shape -> Shape -> Int
tiTovi Shape
s Shape
i

-- | Grid
--
-- > λ> a = [1..2] :: Vector 2 Int
-- > λ> a
-- > [1,2]
-- > λ> grid i0 a :: Tensor '[2,2,2] Int
-- > [[[1,1],
-- > [1,1]],
-- > [[2,2],
-- > [2,2]]]
-- > λ> grid i1 a :: Tensor '[2,2,2] Int
-- > [[[1,1],
-- > [2,2]],
-- > [[1,1],
-- > [2,2]]]
-- > λ> grid i2 a :: Tensor '[2,2,2] Int
-- > [[[1,2],
-- > [1,2]],
-- > [[1,2],
-- > [1,2]]]
grid
  :: (CheckDimension i s ~ 'True
    , KnownNat i
    , KnownNat (Dimension s i))
  => Proxy i
  -> Vector (Dimension s i) n
  -> Tensor s n
grid :: Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy i
p v :: Vector (Dimension s i) n
v@(Tensor Shape -> Shape -> n
t) =
  let i :: Int
i = Proxy i -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
toNat Proxy i
p
      a :: Shape
a = Vector (Dimension s i) n -> Shape
forall (s :: [Nat]) n. HasShape s => Tensor s n -> Shape
shape Vector (Dimension s i) n
v
  in (Shape -> Shape -> n) -> Tensor s n
forall (s :: [Nat]) n. (Shape -> Shape -> n) -> Tensor s n
Tensor ((Shape -> Shape -> n) -> Tensor s n)
-> (Shape -> Shape -> n) -> Tensor s n
forall a b. (a -> b) -> a -> b
$ \Shape
_ Shape
ind -> Shape -> Shape -> n
t Shape
a [Shape
ind Shape -> Int -> Int
forall a. [a] -> Int -> a
!! Int
i]

-- | Generate 2 dimension grid coordinates by two vectors.
meshgrid2 :: (s ~ '[a,b], KnownNat a, KnownNat b) => Vector a n -> Vector b n -> [Tensor s n]
meshgrid2 :: Vector a n -> Vector b n -> [Tensor s n]
meshgrid2 Vector a n
a Vector b n
b = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b]

-- | Generate 3 dimension grid coordinates by three vectors.
meshgrid3 :: (s ~ '[a,b,c], KnownNat a, KnownNat b, KnownNat c) => Vector a n -> Vector b n -> Vector c n -> [Tensor s n]
meshgrid3 :: Vector a n -> Vector b n -> Vector c n -> [Tensor s n]
meshgrid3 Vector a n
a Vector b n
b Vector c n
c = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c]

-- | Generate 4 dimension grid coordinates by four vectors.
meshgrid4
  :: (s ~ '[a,b,c,d], KnownNat a, KnownNat b, KnownNat c, KnownNat d)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> [Tensor s n]
meshgrid4 :: Vector a n
-> Vector b n -> Vector c n -> Vector d n -> [Tensor s n]
meshgrid4 Vector a n
a Vector b n
b Vector c n
c Vector d n
d= [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d]

-- | Generate 5 dimension grid coordinates by five vectors.
meshgrid5
  :: (s ~ '[a,b,c,d,e], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> [Tensor s n]
meshgrid5 :: Vector a n
-> Vector b n
-> Vector c n
-> Vector d n
-> Vector e n
-> [Tensor s n]
meshgrid5 Vector a n
a Vector b n
b Vector c n
c Vector d n
d Vector e n
e = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d, Proxy 4 -> Vector (Dimension s 4) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 4
i4 Vector e n
Vector (Dimension s 4) n
e]

-- | Generate 6 dimension grid coordinates by six vectors.
meshgrid6
  :: (s ~ '[a,b,c,d,e,f], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> [Tensor s n]
meshgrid6 :: Vector a n
-> Vector b n
-> Vector c n
-> Vector d n
-> Vector e n
-> Vector f n
-> [Tensor s n]
meshgrid6 Vector a n
a Vector b n
b Vector c n
c Vector d n
d Vector e n
e Vector f n
f = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d, Proxy 4 -> Vector (Dimension s 4) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 4
i4 Vector e n
Vector (Dimension s 4) n
e, Proxy 5 -> Vector (Dimension s 5) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 5
i5 Vector f n
Vector (Dimension s 5) n
f]

-- | Generate 7 dimension grid coordinates by seven vectors.
meshgrid7
  :: (s ~ '[a,b,c,d,e,f,g], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> [Tensor s n]
meshgrid7 :: Vector a n
-> Vector b n
-> Vector c n
-> Vector d n
-> Vector e n
-> Vector f n
-> Vector g n
-> [Tensor s n]
meshgrid7 Vector a n
a Vector b n
b Vector c n
c Vector d n
d Vector e n
e Vector f n
f Vector g n
g = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d, Proxy 4 -> Vector (Dimension s 4) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 4
i4 Vector e n
Vector (Dimension s 4) n
e, Proxy 5 -> Vector (Dimension s 5) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 5
i5 Vector f n
Vector (Dimension s 5) n
f, Proxy 6 -> Vector (Dimension s 6) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 6
i6 Vector g n
Vector (Dimension s 6) n
g]

-- | Generate 8 dimension grid coordinates by eight vectors.
meshgrid8
  :: (s ~ '[a,b,c,d,e,f,g,h], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g, KnownNat h)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> Vector h n -> [Tensor s n]
meshgrid8 :: Vector a n
-> Vector b n
-> Vector c n
-> Vector d n
-> Vector e n
-> Vector f n
-> Vector g n
-> Vector h n
-> [Tensor s n]
meshgrid8 Vector a n
a Vector b n
b Vector c n
c Vector d n
d Vector e n
e Vector f n
f Vector g n
g Vector h n
h = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d, Proxy 4 -> Vector (Dimension s 4) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 4
i4 Vector e n
Vector (Dimension s 4) n
e, Proxy 5 -> Vector (Dimension s 5) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 5
i5 Vector f n
Vector (Dimension s 5) n
f, Proxy 6 -> Vector (Dimension s 6) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 6
i6 Vector g n
Vector (Dimension s 6) n
g, Proxy 7 -> Vector (Dimension s 7) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 7
i7 Vector h n
Vector (Dimension s 7) n
h]

-- | Generate 9 dimension grid coordinates by nine vectors.
meshgrid9
  :: (s ~ '[a,b,c,d,e,f,g,h,i], KnownNat a, KnownNat b, KnownNat c, KnownNat d, KnownNat e, KnownNat f, KnownNat g, KnownNat h, KnownNat i)
  => Vector a n -> Vector b n -> Vector c n -> Vector d n -> Vector e n -> Vector f n -> Vector g n -> Vector h n -> Vector i n -> [Tensor s n]
meshgrid9 :: Vector a n
-> Vector b n
-> Vector c n
-> Vector d n
-> Vector e n
-> Vector f n
-> Vector g n
-> Vector h n
-> Vector i n
-> [Tensor s n]
meshgrid9 Vector a n
a Vector b n
b Vector c n
c Vector d n
d Vector e n
e Vector f n
f Vector g n
g Vector h n
h Vector i n
i = [Proxy 0 -> Vector (Dimension s 0) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 0
i0 Vector a n
Vector (Dimension s 0) n
a, Proxy 1 -> Vector (Dimension s 1) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 1
i1 Vector b n
Vector (Dimension s 1) n
b, Proxy 2 -> Vector (Dimension s 2) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 2
i2 Vector c n
Vector (Dimension s 2) n
c, Proxy 3 -> Vector (Dimension s 3) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 3
i3 Vector d n
Vector (Dimension s 3) n
d, Proxy 4 -> Vector (Dimension s 4) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 4
i4 Vector e n
Vector (Dimension s 4) n
e, Proxy 5 -> Vector (Dimension s 5) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 5
i5 Vector f n
Vector (Dimension s 5) n
f, Proxy 6 -> Vector (Dimension s 6) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 6
i6 Vector g n
Vector (Dimension s 6) n
g, Proxy 7 -> Vector (Dimension s 7) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 7
i7 Vector h n
Vector (Dimension s 7) n
h, Proxy 8 -> Vector (Dimension s 8) n -> Tensor s n
forall (i :: Nat) (s :: [Nat]) n.
(CheckDimension i s ~ 'True, KnownNat i,
 KnownNat (Dimension s i)) =>
Proxy i -> Vector (Dimension s i) n -> Tensor s n
grid Proxy 8
i8 Vector i n
Vector (Dimension s 8) n
i]