{- | Implementation of mathematical vector.

'Vec' is only a newtype wrapper around 'Data.Vector', which
implements several mathematical operations on itself.

'Vec' offers meaningful abstraction and easy interface
(you can unwrap it to perform more complex tasks).
-}


-- 'TypeFamilies' are needed to instantiate 'Indexable', 'ElementwiseScalarOps', 'SingletonOps', 'VecOps' typeclasses.

{-# LANGUAGE TypeFamilies #-}


module Synapse.Tensors.Vec
    ( -- * 'Vec' datatype and simple getters.


      Vec (Vec, unVec)

    , size

      -- * Constructors


    , empty
    , singleton
    , fromList
    , generate
    , replicate

      -- * Concatenation and splitting


    , cons
    , snoc
    , (++)
    , concat

    , splitAt

      -- * Combining


    , map
    , imap
    , for
    , zipWith
    , zip

    -- * Mathematics


    , zeroes
    , ones

    , squaredMagnitude
    , magnitude
    , clampMagnitude
    , normalized

    , linearCombination
    , dot

    , angleBetween
    , lerp
    ) where


import Synapse.Tensors (DType, Indexable(..), ElementwiseScalarOps(..), SingletonOps(..), VecOps(..))

import Prelude hiding ((++), concat, splitAt, map, replicate, zip, zipWith)
import Data.Foldable (Foldable(..))
import Data.Ord (clamp)

import qualified Data.Vector as V


-- | Mathematical vector (collection of elements).

newtype Vec a = Vec
    { forall a. Vec a -> Vector a
unVec :: V.Vector a  -- ^ Internal representation.

    } deriving (Vec a -> Vec a -> Bool
(Vec a -> Vec a -> Bool) -> (Vec a -> Vec a -> Bool) -> Eq (Vec a)
forall a. Eq a => Vec a -> Vec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Vec a -> Vec a -> Bool
== :: Vec a -> Vec a -> Bool
$c/= :: forall a. Eq a => Vec a -> Vec a -> Bool
/= :: Vec a -> Vec a -> Bool
Eq, ReadPrec [Vec a]
ReadPrec (Vec a)
Int -> ReadS (Vec a)
ReadS [Vec a]
(Int -> ReadS (Vec a))
-> ReadS [Vec a]
-> ReadPrec (Vec a)
-> ReadPrec [Vec a]
-> Read (Vec a)
forall a. Read a => ReadPrec [Vec a]
forall a. Read a => ReadPrec (Vec a)
forall a. Read a => Int -> ReadS (Vec a)
forall a. Read a => ReadS [Vec a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Vec a)
readsPrec :: Int -> ReadS (Vec a)
$creadList :: forall a. Read a => ReadS [Vec a]
readList :: ReadS [Vec a]
$creadPrec :: forall a. Read a => ReadPrec (Vec a)
readPrec :: ReadPrec (Vec a)
$creadListPrec :: forall a. Read a => ReadPrec [Vec a]
readListPrec :: ReadPrec [Vec a]
Read)

-- | Size of a vector - number of elements.

size :: Vec a -> Int
size :: forall a. Vec a -> Int
size = Vector a -> Int
forall a. Vector a -> Int
V.length (Vector a -> Int) -> (Vec a -> Vector a) -> Vec a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec


-- Typeclasses


instance Show a => Show (Vec a) where
    show :: Vec a -> String
show (Vec Vector a
x) = Vector a -> String
forall a. Show a => a -> String
show Vector a
x


type instance DType (Vec a) = a


instance Indexable (Vec a) where
    type Index (Vec a) = Int

    unsafeIndex :: Vec a -> Index (Vec a) -> DType (Vec a)
unsafeIndex (Vec Vector a
x) = Vector a -> Int -> a
forall a. Vector a -> Int -> a
V.unsafeIndex Vector a
x
    ! :: Vec a -> Index (Vec a) -> DType (Vec a)
(!) (Vec Vector a
x) = Vector a -> Int -> a
forall a. Vector a -> Int -> a
(V.!) Vector a
x
    !? :: Vec a -> Index (Vec a) -> Maybe (DType (Vec a))
(!?) (Vec Vector a
x) = Vector a -> Int -> Maybe a
forall a. Vector a -> Int -> Maybe a
(V.!?) Vector a
x


instance Num a => Num (Vec a) where
    + :: Vec a -> Vec a -> Vec a
(+) = (a -> a -> a) -> Vec a -> Vec a -> Vec a
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith a -> a -> a
forall a. Num a => a -> a -> a
(+)
    (-) = (a -> a -> a) -> Vec a -> Vec a -> Vec a
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith (-)
    negate :: Vec a -> Vec a
negate = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a
0 a -> a -> a
forall a. Num a => a -> a -> a
-)
    * :: Vec a -> Vec a -> Vec a
(*) = (a -> a -> a) -> Vec a -> Vec a -> Vec a
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith a -> a -> a
forall a. Num a => a -> a -> a
(*)
    abs :: Vec a -> Vec a
abs = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
    signum :: Vec a -> Vec a
signum = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
    fromInteger :: Integer -> Vec a
fromInteger = a -> Vec a
DType (Vec a) -> Vec a
forall f. SingletonOps f => DType f -> f
singleton (a -> Vec a) -> (Integer -> a) -> Integer -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger

instance Fractional a => Fractional (Vec a) where
    / :: Vec a -> Vec a -> Vec a
(/) = (a -> a -> a) -> Vec a -> Vec a -> Vec a
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith a -> a -> a
forall a. Fractional a => a -> a -> a
(/)
    recip :: Vec a -> Vec a
recip = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a
1a -> a -> a
forall a. Fractional a => a -> a -> a
/)
    fromRational :: Rational -> Vec a
fromRational = a -> Vec a
DType (Vec a) -> Vec a
forall f. SingletonOps f => DType f -> f
singleton (a -> Vec a) -> (Rational -> a) -> Rational -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational

instance Floating a => Floating (Vec a) where
    pi :: Vec a
pi = DType (Vec a) -> Vec a
forall f. SingletonOps f => DType f -> f
singleton a
DType (Vec a)
forall a. Floating a => a
pi
    ** :: Vec a -> Vec a -> Vec a
(**) = (a -> a -> a) -> Vec a -> Vec a -> Vec a
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith a -> a -> a
forall a. Floating a => a -> a -> a
(**)
    sqrt :: Vec a -> Vec a
sqrt = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sqrt
    exp :: Vec a -> Vec a
exp = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
exp
    log :: Vec a -> Vec a
log = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
log
    sin :: Vec a -> Vec a
sin = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sin
    cos :: Vec a -> Vec a
cos = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cos
    asin :: Vec a -> Vec a
asin = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asin
    acos :: Vec a -> Vec a
acos = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acos
    atan :: Vec a -> Vec a
atan = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atan
    sinh :: Vec a -> Vec a
sinh = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
sinh
    cosh :: Vec a -> Vec a
cosh = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
cosh
    asinh :: Vec a -> Vec a
asinh = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
asinh
    acosh :: Vec a -> Vec a
acosh = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
acosh
    atanh :: Vec a -> Vec a
atanh = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Floating a => a -> a
atanh

instance ElementwiseScalarOps (Vec a) where
    +. :: Num (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
(+.) Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DType (Vec a) -> DType (Vec a) -> DType (Vec a)
forall a. Num a => a -> a -> a
+ DType (Vec a)
n) Vec a
x
    -. :: Num (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
(-.) Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> a -> a
forall a. Num a => a -> a -> a
subtract a
DType (Vec a)
n) Vec a
x
    *. :: Num (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
(*.) Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DType (Vec a) -> DType (Vec a) -> DType (Vec a)
forall a. Num a => a -> a -> a
* DType (Vec a)
n) Vec a
x
    /. :: Fractional (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
(/.) Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DType (Vec a) -> DType (Vec a) -> DType (Vec a)
forall a. Fractional a => a -> a -> a
/ DType (Vec a)
n) Vec a
x
    **. :: Floating (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
(**.) Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DType (Vec a) -> DType (Vec a) -> DType (Vec a)
forall a. Floating a => a -> a -> a
** DType (Vec a)
n) Vec a
x

    elementsMin :: Ord (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
elementsMin Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> a -> a
forall a. Ord a => a -> a -> a
min a
DType (Vec a)
n) Vec a
x
    elementsMax :: Ord (DType (Vec a)) => Vec a -> DType (Vec a) -> Vec a
elementsMax Vec a
x DType (Vec a)
n = (a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> a -> a
forall a. Ord a => a -> a -> a
max a
DType (Vec a)
n) Vec a
x

instance SingletonOps (Vec a) where
    singleton :: DType (Vec a) -> Vec a
singleton = a -> Vec a
DType (Vec a) -> Vec a
forall a. a -> Vec a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    isSingleton :: Vec a -> Bool
isSingleton Vec a
vec = Vec a -> Int
forall a. Vec a -> Int
size Vec a
vec Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1
    unSingleton :: Vec a -> DType (Vec a)
unSingleton Vec a
vec
        | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Vec a -> Bool
forall f. SingletonOps f => f -> Bool
isSingleton Vec a
vec = String -> a
forall a. HasCallStack => String -> a
error String
"Vector is not a singleton"
        | Bool
otherwise             = Vec a -> Index (Vec a) -> DType (Vec a)
forall f. Indexable f => f -> Index f -> DType f
unsafeIndex Vec a
vec Int
Index (Vec a)
0

    extendSingleton :: Vec a -> Vec a -> Vec a
extendSingleton Vec a
vec Vec a
reference = Int -> a -> Vec a
forall a. Int -> a -> Vec a
replicate (Vec a -> Int
forall a. Vec a -> Int
size Vec a
reference) (Vec a -> DType (Vec a)
forall f. SingletonOps f => f -> DType f
unSingleton Vec a
vec)

    elementsSum :: Num (DType (Vec a)) => Vec a -> Vec a
elementsSum = a -> Vec a
DType (Vec a) -> Vec a
forall f. SingletonOps f => DType f -> f
singleton (a -> Vec a) -> (Vec a -> a) -> Vec a -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector a -> a
forall a. Num a => Vector a -> a
V.sum (Vector a -> a) -> (Vec a -> Vector a) -> Vec a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    elementsProduct :: Fractional (DType (Vec a)) => Vec a -> Vec a
elementsProduct = a -> Vec a
DType (Vec a) -> Vec a
forall f. SingletonOps f => DType f -> f
singleton (a -> Vec a) -> (Vec a -> a) -> Vec a -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector a -> a
forall a. Num a => Vector a -> a
V.product (Vector a -> a) -> (Vec a -> Vector a) -> Vec a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    mean :: Fractional (DType (Vec a)) => Vec a -> Vec a
mean Vec a
x = Vec a -> Vec a
forall f. (SingletonOps f, Num (DType f)) => f -> f
elementsSum Vec a
x Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Fractional (DType f)) =>
f -> DType f -> f
/. Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vec a -> Int
forall a. Vec a -> Int
size Vec a
x)
    norm :: Floating (DType (Vec a)) => Vec a -> Vec a
norm Vec a
x = Vec a -> Vec a
forall a. Floating a => a -> a
sqrt (Vec a -> Vec a) -> Vec a -> Vec a
forall a b. (a -> b) -> a -> b
$ Vec a -> Vec a
forall f. (SingletonOps f, Num (DType f)) => f -> f
elementsSum (Vec a -> Vec a) -> Vec a -> Vec a
forall a b. (a -> b) -> a -> b
$ Vec a
x Vec a -> Vec a -> Vec a
forall a. Num a => a -> a -> a
* Vec a
x

instance Functor Vec where
    fmap :: forall a b. (a -> b) -> Vec a -> Vec b
fmap a -> b
f = Vector b -> Vec b
forall a. Vector a -> Vec a
Vec (Vector b -> Vec b) -> (Vec a -> Vector b) -> Vec a -> Vec b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Vector a -> Vector b
forall a b. (a -> b) -> Vector a -> Vector b
V.map a -> b
f (Vector a -> Vector b) -> (Vec a -> Vector a) -> Vec a -> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    <$ :: forall a b. a -> Vec b -> Vec a
(<$) = (b -> a) -> Vec b -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> a) -> Vec b -> Vec a)
-> (a -> b -> a) -> a -> Vec b -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> a
forall a b. a -> b -> a
const

instance Applicative Vec where
    pure :: forall a. a -> Vec a
pure = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a) -> (a -> Vector a) -> a -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a
forall a. a -> Vector a
V.singleton
    <*> :: forall a b. Vec (a -> b) -> Vec a -> Vec b
(<*>) = ((a -> b) -> a -> b) -> Vec (a -> b) -> Vec a -> Vec b
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith (\a -> b
f a
x -> a -> b
f a
x)

instance Foldable Vec where
    foldr :: forall a b. (a -> b -> b) -> b -> Vec a -> b
foldr a -> b -> b
f b
x = (a -> b -> b) -> b -> Vector a -> b
forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr a -> b -> b
f b
x (Vector a -> b) -> (Vec a -> Vector a) -> Vec a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    foldl :: forall b a. (b -> a -> b) -> b -> Vec a -> b
foldl b -> a -> b
f b
x = (b -> a -> b) -> b -> Vector a -> b
forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl b -> a -> b
f b
x (Vector a -> b) -> (Vec a -> Vector a) -> Vec a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

    foldr' :: forall a b. (a -> b -> b) -> b -> Vec a -> b
foldr' a -> b -> b
f b
x = (a -> b -> b) -> b -> Vector a -> b
forall a b. (a -> b -> b) -> b -> Vector a -> b
V.foldr' a -> b -> b
f b
x (Vector a -> b) -> (Vec a -> Vector a) -> Vec a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    foldl' :: forall b a. (b -> a -> b) -> b -> Vec a -> b
foldl' b -> a -> b
f b
x = (b -> a -> b) -> b -> Vector a -> b
forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl' b -> a -> b
f b
x (Vector a -> b) -> (Vec a -> Vector a) -> Vec a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

    foldr1 :: forall a. (a -> a -> a) -> Vec a -> a
foldr1 a -> a -> a
f = (a -> a -> a) -> Vector a -> a
forall a. (a -> a -> a) -> Vector a -> a
V.foldr1 a -> a -> a
f (Vector a -> a) -> (Vec a -> Vector a) -> Vec a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec
    foldl1 :: forall a. (a -> a -> a) -> Vec a -> a
foldl1 a -> a -> a
f = (a -> a -> a) -> Vector a -> a
forall a. (a -> a -> a) -> Vector a -> a
V.foldl1 a -> a -> a
f (Vector a -> a) -> (Vec a -> Vector a) -> Vec a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

    toList :: forall a. Vec a -> [a]
toList = Vector a -> [a]
forall a. Vector a -> [a]
V.toList (Vector a -> [a]) -> (Vec a -> Vector a) -> Vec a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

    null :: forall a. Vec a -> Bool
null Vec a
x = Vec a -> Int
forall a. Vec a -> Int
size Vec a
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0

    length :: forall a. Vec a -> Int
length = Vec a -> Int
forall a. Vec a -> Int
size

instance Traversable Vec where
    traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vec a -> f (Vec b)
traverse a -> f b
f (Vec Vector a
x) = Vector b -> Vec b
forall a. Vector a -> Vec a
Vec (Vector b -> Vec b) -> f (Vector b) -> f (Vec b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f b) -> Vector a -> f (Vector b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse a -> f b
f Vector a
x


-- Constructors


-- | Creates empty 'Vec'.

empty :: Vec a
empty :: forall a. Vec a
empty = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec Vector a
forall a. Vector a
V.empty

-- | Creates 'Vec' from list.

fromList :: [a] -> Vec a
fromList :: forall a. [a] -> Vec a
fromList = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a) -> ([a] -> Vector a) -> [a] -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList

-- | Creates 'Vec' of given length using generating function.

generate :: Int -> (Int -> a) -> Vec a
generate :: forall a. Int -> (Int -> a) -> Vec a
generate Int
n = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a)
-> ((Int -> a) -> Vector a) -> (Int -> a) -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> (Int -> a) -> Vector a
forall a. Int -> (Int -> a) -> Vector a
V.generate Int
n

-- | Creates 'Vec' of given length filled with given element.

replicate :: Int -> a -> Vec a
replicate :: forall a. Int -> a -> Vec a
replicate Int
n = Int -> (Int -> a) -> Vec a
forall a. Int -> (Int -> a) -> Vec a
generate Int
n ((Int -> a) -> Vec a) -> (a -> Int -> a) -> a -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int -> a
forall a b. a -> b -> a
const


-- Concatenation and splitting


-- | Prepend 'Vec' with given element.

cons :: a -> Vec a -> Vec a
cons :: forall a. a -> Vec a -> Vec a
cons a
x = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a) -> (Vec a -> Vector a) -> Vec a -> Vec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Vector a -> Vector a
forall a. a -> Vector a -> Vector a
V.cons a
x (Vector a -> Vector a) -> (Vec a -> Vector a) -> Vec a -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

-- | Append 'Vec' with given element.

snoc :: Vec a -> a -> Vec a
snoc :: forall a. Vec a -> a -> Vec a
snoc (Vec Vector a
vec) a
x = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a) -> Vector a -> Vec a
forall a b. (a -> b) -> a -> b
$ Vector a -> a -> Vector a
forall a. Vector a -> a -> Vector a
V.snoc Vector a
vec a
x

-- | Concatenate two 'Vec's.

infixr 5 ++
(++) :: Vec a -> Vec a -> Vec a
++ :: forall a. Vec a -> Vec a -> Vec a
(++) (Vec Vector a
x) (Vec Vector a
y) = Vector a -> Vec a
forall a. Vector a -> Vec a
Vec (Vector a -> Vec a) -> Vector a -> Vec a
forall a b. (a -> b) -> a -> b
$ Vector a
x Vector a -> Vector a -> Vector a
forall a. Vector a -> Vector a -> Vector a
V.++ Vector a
y

-- | Concatenate all 'Vec's.

concat :: [Vec a] -> Vec a
concat :: forall a. [Vec a] -> Vec a
concat = (Vec a -> Vec a -> Vec a) -> [Vec a] -> Vec a
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Vec a -> Vec a -> Vec a
forall a. Vec a -> Vec a -> Vec a
(++)

-- | Splits 'Vec' into two 'Vec's at a given index.

splitAt :: Int -> Vec a -> (Vec a, Vec a)
splitAt :: forall a. Int -> Vec a -> (Vec a, Vec a)
splitAt Int
i (Vec Vector a
v) = let (Vector a
v1, Vector a
v2) = Int -> Vector a -> (Vector a, Vector a)
forall a. Int -> Vector a -> (Vector a, Vector a)
V.splitAt Int
i Vector a
v
                    in (Vector a -> Vec a
forall a. Vector a -> Vec a
Vec Vector a
v1, Vector a -> Vec a
forall a. Vector a -> Vec a
Vec Vector a
v2)


-- Combining


-- | Map a function over a 'Vec'.

map :: (a -> b) -> Vec a -> Vec b
map :: forall a b. (a -> b) -> Vec a -> Vec b
map = (a -> b) -> Vec a -> Vec b
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

-- | Apply a function to every element of a 'Vec' and its index.

imap :: (Int -> a -> b) -> Vec a -> Vec b
imap :: forall a b. (Int -> a -> b) -> Vec a -> Vec b
imap Int -> a -> b
f = Vector b -> Vec b
forall a. Vector a -> Vec a
Vec (Vector b -> Vec b) -> (Vec a -> Vector b) -> Vec a -> Vec b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> a -> b) -> Vector a -> Vector b
forall a b. (Int -> a -> b) -> Vector a -> Vector b
V.imap Int -> a -> b
f (Vector a -> Vector b) -> (Vec a -> Vector a) -> Vec a -> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> Vector a
forall a. Vec a -> Vector a
unVec

-- | 'map' with its arguments flipped.

for :: Vec a -> (a -> b) -> Vec b
for :: forall a b. Vec a -> (a -> b) -> Vec b
for = ((a -> b) -> Vec a -> Vec b) -> Vec a -> (a -> b) -> Vec b
forall a b c. (a -> b -> c) -> b -> a -> c
flip (a -> b) -> Vec a -> Vec b
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

-- | Zips two 'Vec's with the given function.

zipWith :: (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith :: forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith a -> b -> c
f (Vec Vector a
a) (Vec Vector b
b) = Vector c -> Vec c
forall a. Vector a -> Vec a
Vec (Vector c -> Vec c) -> Vector c -> Vec c
forall a b. (a -> b) -> a -> b
$ (a -> b -> c) -> Vector a -> Vector b -> Vector c
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith a -> b -> c
f Vector a
a Vector b
b

-- | Zips two 'Vec's.

zip :: Vec a -> Vec b -> Vec (a, b)
zip :: forall a b. Vec a -> Vec b -> Vec (a, b)
zip = (a -> b -> (a, b)) -> Vec a -> Vec b -> Vec (a, b)
forall a b c. (a -> b -> c) -> Vec a -> Vec b -> Vec c
zipWith (,)


-- Functions that work on mathematical vector (type constraint refers to a number)


-- | Creates 'Vec' of given length filled with zeroes.

zeroes :: Num a => Int -> Vec a
zeroes :: forall a. Num a => Int -> Vec a
zeroes = (Int -> (Int -> a) -> Vec a) -> (Int -> a) -> Int -> Vec a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> (Int -> a) -> Vec a
forall a. Int -> (Int -> a) -> Vec a
generate (a -> Int -> a
forall a b. a -> b -> a
const a
0)

-- | Creates 'Vec' of given length filled with ones.

ones :: Num a => Int -> Vec a
ones :: forall a. Num a => Int -> Vec a
ones = (Int -> (Int -> a) -> Vec a) -> (Int -> a) -> Int -> Vec a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> (Int -> a) -> Vec a
forall a. Int -> (Int -> a) -> Vec a
generate (a -> Int -> a
forall a b. a -> b -> a
const a
1)


-- | Squared magnitude of a 'Vec'.

squaredMagnitude :: Num a => Vec a -> a
squaredMagnitude :: forall a. Num a => Vec a -> a
squaredMagnitude Vec a
x = Vec a -> a
forall a. Num a => Vec a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ((a -> a) -> Vec a -> Vec a
forall a b. (a -> b) -> Vec a -> Vec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> Int -> a
forall a b. (Num a, Integral b) => a -> b -> a
^ (Int
2 :: Int)) Vec a
x)

-- | Magnitude of a 'Vec'.

magnitude :: Floating a => Vec a -> a
magnitude :: forall a. Floating a => Vec a -> a
magnitude = a -> a
forall a. Floating a => a -> a
sqrt (a -> a) -> (Vec a -> a) -> Vec a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec a -> a
forall a. Num a => Vec a -> a
squaredMagnitude

-- | Clamps 'Vec' magnitude.

clampMagnitude :: (Floating a, Ord a) => a -> Vec a -> Vec a
clampMagnitude :: forall a. (Floating a, Ord a) => a -> Vec a -> Vec a
clampMagnitude a
m Vec a
x = Vec a
x Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Num (DType f)) =>
f -> DType f -> f
*. (a -> a -> a
forall a. Ord a => a -> a -> a
min (Vec a -> a
forall a. Floating a => Vec a -> a
magnitude Vec a
x) a
m a -> a -> a
forall a. Fractional a => a -> a -> a
/ Vec a -> a
forall a. Floating a => Vec a -> a
magnitude Vec a
x)

-- | Normalizes 'Vec' by dividing each component by 'Vec' magnitude.

normalized :: Floating a => Vec a -> Vec a
normalized :: forall a. Floating a => Vec a -> Vec a
normalized Vec a
x = Vec a
x Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Fractional (DType f)) =>
f -> DType f -> f
/. Vec a -> a
forall a. Floating a => Vec a -> a
magnitude Vec a
x


-- | Computes linear combination of 'Vec's. Returns empty 'Vec' if empty list was passed to this function.

linearCombination :: Num a => [(a, Vec a)] -> Vec a
linearCombination :: forall a. Num a => [(a, Vec a)] -> Vec a
linearCombination [] = Vec a
forall a. Vec a
empty
linearCombination ((a, Vec a)
x:[(a, Vec a)]
xs) = (Vec a -> (a, Vec a) -> Vec a) -> Vec a -> [(a, Vec a)] -> Vec a
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\Vec a
acc (a
a, Vec a
vec) -> Vec a
acc Vec a -> Vec a -> Vec a
forall a. Num a => a -> a -> a
+ Vec a
vec Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Num (DType f)) =>
f -> DType f -> f
*. a
DType (Vec a)
a) ((a, Vec a) -> Vec a
forall a b. (a, b) -> b
snd (a, Vec a)
x Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Num (DType f)) =>
f -> DType f -> f
*. (a, Vec a) -> a
forall a b. (a, b) -> a
fst (a, Vec a)
x) [(a, Vec a)]
xs


instance Num a => VecOps (Vec a) where
    dot :: Num (DType (Vec a)) => Vec a -> Vec a -> Vec a
dot Vec a
a Vec a
b = Vec a -> Vec a
forall f. (SingletonOps f, Num (DType f)) => f -> f
elementsSum (Vec a -> Vec a) -> Vec a -> Vec a
forall a b. (a -> b) -> a -> b
$ Vec a
a Vec a -> Vec a -> Vec a
forall a. Num a => a -> a -> a
* Vec a
b


-- | Calculates an angle between two 'Vec's.

angleBetween :: Floating a => Vec a -> Vec a -> a
angleBetween :: forall a. Floating a => Vec a -> Vec a -> a
angleBetween Vec a
a Vec a
b = a -> a
forall a. Floating a => a -> a
acos (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ Vec a -> DType (Vec a)
forall f. SingletonOps f => f -> DType f
unSingleton (Vec a
a Vec a -> Vec a -> Vec a
forall f. (VecOps f, Num (DType f)) => f -> f -> f
`dot` Vec a
b) a -> a -> a
forall a. Fractional a => a -> a -> a
/ (Vec a -> a
forall a. Floating a => Vec a -> a
magnitude Vec a
a a -> a -> a
forall a. Num a => a -> a -> a
* Vec a -> a
forall a. Floating a => Vec a -> a
magnitude Vec a
b)

-- | Linearly interpolates between two 'Vec's. Given parameter will be clamped between [0.0, 1.0].

lerp :: (Floating a, Ord a) => a -> Vec a -> Vec a -> Vec a
lerp :: forall a. (Floating a, Ord a) => a -> Vec a -> Vec a -> Vec a
lerp a
k Vec a
a Vec a
b = Vec a
b Vec a -> Vec a -> Vec a
forall a. Num a => a -> a -> a
- (Vec a
b Vec a -> Vec a -> Vec a
forall a. Num a => a -> a -> a
- Vec a
a) Vec a -> DType (Vec a) -> Vec a
forall f.
(ElementwiseScalarOps f, Num (DType f)) =>
f -> DType f -> f
*. (a, a) -> a -> a
forall a. Ord a => (a, a) -> a -> a
clamp (a
0.0, a
1.0) a
k