Safe Haskell	Safe
Language	Haskell2010

SDL.Vect

Contents

Point
Vectors

Description

SDL's vector representation.

By default, re-exports the Linear and Linear.Affine modules from the linear package. With the no-linear Cabal flag, instead exports a duplicate implementation of the V2, V3, V4 and Point types from SDL.Internal.Vect, which provides as many instances as possible for those types while avoiding any additional dependencies.

Synopsis

Point

newtype Point (f :: * -> *) a :: (* -> *) -> * -> * #

A handy wrapper to help distinguish points from vectors at the type level

Constructors

P (f a)

Instances

Unbox (f a) => Vector Vector (Point f a)
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Point f a) -> m (Vector (Point f a)) # basicUnsafeThaw :: PrimMonad m => Vector (Point f a) -> m (Mutable Vector (PrimState m) (Point f a)) # basicLength :: Vector (Point f a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Point f a) -> Vector (Point f a) # basicUnsafeIndexM :: Monad m => Vector (Point f a) -> Int -> m (Point f a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Point f a) -> Vector (Point f a) -> m () # elemseq :: Vector (Point f a) -> Point f a -> b -> b #
Unbox (f a) => MVector MVector (Point f a)
Methods basicLength :: MVector s (Point f a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Point f a) -> MVector s (Point f a) # basicOverlaps :: MVector s (Point f a) -> MVector s (Point f a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Point f a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Point f a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Point f a -> m (MVector (PrimState m) (Point f a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Point f a) -> Int -> m (Point f a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Point f a) -> Int -> Point f a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Point f a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Point f a) -> Point f a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Point f a) -> MVector (PrimState m) (Point f a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Point f a) -> MVector (PrimState m) (Point f a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Point f a) -> Int -> m (MVector (PrimState m) (Point f a)) #
Monad f => Monad (Point f)
Methods (>>=) :: Point f a -> (a -> Point f b) -> Point f b # (>>) :: Point f a -> Point f b -> Point f b # return :: a -> Point f a # fail :: String -> Point f a #
Functor f => Functor (Point f)
Methods fmap :: (a -> b) -> Point f a -> Point f b # (<$) :: a -> Point f b -> Point f a #
Applicative f => Applicative (Point f)
Methods pure :: a -> Point f a # (<>) :: Point f (a -> b) -> Point f a -> Point f b # liftA2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c # (>) :: Point f a -> Point f b -> Point f b # (<*) :: Point f a -> Point f b -> Point f a #
Foldable f => Foldable (Point f)
Methods fold :: Monoid m => Point f m -> m # foldMap :: Monoid m => (a -> m) -> Point f a -> m # foldr :: (a -> b -> b) -> b -> Point f a -> b # foldr' :: (a -> b -> b) -> b -> Point f a -> b # foldl :: (b -> a -> b) -> b -> Point f a -> b # foldl' :: (b -> a -> b) -> b -> Point f a -> b # foldr1 :: (a -> a -> a) -> Point f a -> a # foldl1 :: (a -> a -> a) -> Point f a -> a # toList :: Point f a -> [a] # null :: Point f a -> Bool # length :: Point f a -> Int # elem :: Eq a => a -> Point f a -> Bool # maximum :: Ord a => Point f a -> a # minimum :: Ord a => Point f a -> a # sum :: Num a => Point f a -> a # product :: Num a => Point f a -> a #
Traversable f => Traversable (Point f)
Methods traverse :: Applicative f => (a -> f b) -> Point f a -> f (Point f b) # sequenceA :: Applicative f => Point f (f a) -> f (Point f a) # mapM :: Monad m => (a -> m b) -> Point f a -> m (Point f b) # sequence :: Monad m => Point f (m a) -> m (Point f a) #
Eq1 f => Eq1 (Point f)
Methods liftEq :: (a -> b -> Bool) -> Point f a -> Point f b -> Bool #
Ord1 f => Ord1 (Point f)
Methods liftCompare :: (a -> b -> Ordering) -> Point f a -> Point f b -> Ordering #
Read1 f => Read1 (Point f)
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Point f a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Point f a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Point f a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Point f a] #
Show1 f => Show1 (Point f)
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Point f a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Point f a] -> ShowS #
Representable f => Representable (Point f)
Associated Types type Rep (Point f :: * -> ) :: Methods tabulate :: (Rep (Point f) -> a) -> Point f a index :: Point f a -> Rep (Point f) -> a
Additive f => Affine (Point f)
Associated Types type Diff (Point f :: * -> ) :: -> * # Methods (.-.) :: Num a => Point f a -> Point f a -> Diff (Point f) a # (.+^) :: Num a => Point f a -> Diff (Point f) a -> Point f a # (.-^) :: Num a => Point f a -> Diff (Point f) a -> Point f a #
R4 f => R4 (Point f)
Methods _w :: Functor f => (a -> f a) -> Point f a -> f (Point f a) # _xyzw :: Functor f => (V4 a -> f (V4 a)) -> Point f a -> f (Point f a) #
R3 f => R3 (Point f)
Methods _z :: Functor f => (a -> f a) -> Point f a -> f (Point f a) # _xyz :: Functor f => (V3 a -> f (V3 a)) -> Point f a -> f (Point f a) #
R2 f => R2 (Point f)
Methods _y :: Functor f => (a -> f a) -> Point f a -> f (Point f a) # _xy :: Functor f => (V2 a -> f (V2 a)) -> Point f a -> f (Point f a) #
R1 f => R1 (Point f)
Methods _x :: Functor f => (a -> f a) -> Point f a -> f (Point f a) #
Finite f => Finite (Point f)
Associated Types type Size (Point f :: * -> *) :: Nat # Methods toV :: Point f a -> V Nat (Size (Point f)) a # fromV :: V Nat (Size (Point f)) a -> Point f a #
Metric f => Metric (Point f)
Methods dot :: Num a => Point f a -> Point f a -> a # quadrance :: Num a => Point f a -> a # qd :: Num a => Point f a -> Point f a -> a # distance :: Floating a => Point f a -> Point f a -> a # norm :: Floating a => Point f a -> a # signorm :: Floating a => Point f a -> Point f a #
Additive f => Additive (Point f)
Methods zero :: Num a => Point f a # (^+^) :: Num a => Point f a -> Point f a -> Point f a # (^-^) :: Num a => Point f a -> Point f a -> Point f a # lerp :: Num a => a -> Point f a -> Point f a -> Point f a # liftU2 :: (a -> a -> a) -> Point f a -> Point f a -> Point f a # liftI2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c #
Serial1 f => Serial1 (Point f)
Methods serializeWith :: MonadPut m => (a -> m ()) -> Point f a -> m () deserializeWith :: MonadGet m => m a -> m (Point f a)
Distributive f => Distributive (Point f)
Methods distribute :: Functor f => f (Point f a) -> Point f (f a) collect :: Functor f => (a -> Point f b) -> f a -> Point f (f b) distributeM :: Monad m => m (Point f a) -> Point f (m a) collectM :: Monad m => (a -> Point f b) -> m a -> Point f (m b)
Bind f => Bind (Point f)
Methods (>>-) :: Point f a -> (a -> Point f b) -> Point f b join :: Point f (Point f a) -> Point f a
Apply f => Apply (Point f)
Methods (<.>) :: Point f (a -> b) -> Point f a -> Point f b (.>) :: Point f a -> Point f b -> Point f b (<.) :: Point f a -> Point f b -> Point f a liftF2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c
Generic1 * (Point f)
Associated Types type Rep1 (Point f) (f :: Point f -> ) :: k -> # Methods from1 :: f a -> Rep1 (Point f) f a # to1 :: Rep1 (Point f) f a -> f a #
Eq (f a) => Eq (Point f a)
Methods (==) :: Point f a -> Point f a -> Bool # (/=) :: Point f a -> Point f a -> Bool #
Fractional (f a) => Fractional (Point f a)
Methods (/) :: Point f a -> Point f a -> Point f a # recip :: Point f a -> Point f a # fromRational :: Rational -> Point f a #
(Data (f a), Typeable * a, Typeable (* -> *) f) => Data (Point f a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Point f a -> c (Point f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Point f a) # toConstr :: Point f a -> Constr # dataTypeOf :: Point f a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Point f a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Point f a)) # gmapT :: (forall b. Data b => b -> b) -> Point f a -> Point f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Point f a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Point f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Point f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Point f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) #
Num (f a) => Num (Point f a)
Methods (+) :: Point f a -> Point f a -> Point f a # (-) :: Point f a -> Point f a -> Point f a # (*) :: Point f a -> Point f a -> Point f a # negate :: Point f a -> Point f a # abs :: Point f a -> Point f a # signum :: Point f a -> Point f a # fromInteger :: Integer -> Point f a #
Ord (f a) => Ord (Point f a)
Methods compare :: Point f a -> Point f a -> Ordering # (<) :: Point f a -> Point f a -> Bool # (<=) :: Point f a -> Point f a -> Bool # (>) :: Point f a -> Point f a -> Bool # (>=) :: Point f a -> Point f a -> Bool # max :: Point f a -> Point f a -> Point f a # min :: Point f a -> Point f a -> Point f a #
Read (f a) => Read (Point f a)
Methods readsPrec :: Int -> ReadS (Point f a) # readList :: ReadS [Point f a] # readPrec :: ReadPrec (Point f a) # readListPrec :: ReadPrec [Point f a] #
Show (f a) => Show (Point f a)
Methods showsPrec :: Int -> Point f a -> ShowS # show :: Point f a -> String # showList :: [Point f a] -> ShowS #
Ix (f a) => Ix (Point f a)
Methods range :: (Point f a, Point f a) -> [Point f a] # index :: (Point f a, Point f a) -> Point f a -> Int # unsafeIndex :: (Point f a, Point f a) -> Point f a -> Int inRange :: (Point f a, Point f a) -> Point f a -> Bool # rangeSize :: (Point f a, Point f a) -> Int # unsafeRangeSize :: (Point f a, Point f a) -> Int
Generic (Point f a)
Associated Types type Rep (Point f a) :: * -> * # Methods from :: Point f a -> Rep (Point f a) x # to :: Rep (Point f a) x -> Point f a #
Storable (f a) => Storable (Point f a)
Methods sizeOf :: Point f a -> Int # alignment :: Point f a -> Int # peekElemOff :: Ptr (Point f a) -> Int -> IO (Point f a) # pokeElemOff :: Ptr (Point f a) -> Int -> Point f a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Point f a) # pokeByteOff :: Ptr b -> Int -> Point f a -> IO () # peek :: Ptr (Point f a) -> IO (Point f a) # poke :: Ptr (Point f a) -> Point f a -> IO () #
Binary (f a) => Binary (Point f a)
Methods put :: Point f a -> Put # get :: Get (Point f a) # putList :: [Point f a] -> Put #
NFData (f a) => NFData (Point f a)
Methods rnf :: Point f a -> () #
Epsilon (f a) => Epsilon (Point f a)
Methods nearZero :: Point f a -> Bool #
Unbox (f a) => Unbox (Point f a)

Wrapped (Point f a)
Associated Types type Unwrapped (Point f a) :: * Methods _Wrapped' :: Iso' (Point f a) (Unwrapped (Point f a))
Serialize (f a) => Serialize (Point f a)
Methods put :: Putter (Point f a) get :: Get (Point f a)
Serial (f a) => Serial (Point f a)
Methods serialize :: MonadPut m => Point f a -> m () deserialize :: MonadGet m => m (Point f a)
Ixed (f a) => Ixed (Point f a)
Methods ix :: Index (Point f a) -> Traversal' (Point f a) (IxValue (Point f a))
Hashable (f a) => Hashable (Point f a)
Methods hashWithSalt :: Int -> Point f a -> Int hash :: Point f a -> Int
(~) * t (Point g b) => Rewrapped (Point f a) t

Traversable f => Each (Point f a) (Point f b) a b
Methods each :: Traversal (Point f a) (Point f b) a b
data MVector s (Point f a)
data MVector s (Point f a) = MV_P (MVector s (f a))
type Diff (Point f)
type Diff (Point f) = f
type Size (Point f)
type Size (Point f) = Size f
type Rep (Point f)
type Rep (Point f) = Rep f
type Rep1 * (Point f)
type Rep1 * (Point f) = D1 * (MetaData "Point" "Linear.Affine" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" True) (C1 * (MetaCons "P" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * f)))
type Rep (Point f a)
type Rep (Point f a) = D1 * (MetaData "Point" "Linear.Affine" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" True) (C1 * (MetaCons "P" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (f a))))
data Vector (Point f a)
data Vector (Point f a) = V_P (Vector (f a))
type Unwrapped (Point f a)
type Unwrapped (Point f a) = f a
type IxValue (Point f a)
type IxValue (Point f a) = IxValue (f a)
type Index (Point f a)
type Index (Point f a) = Index (f a)

Vectors

data V2 a :: * -> * #

A 2-dimensional vector

>>> pure 1 :: V2 Int
V2 1 1

>>> V2 1 2 + V2 3 4
V2 4 6

>>> V2 1 2 * V2 3 4
V2 3 8

>>> sum (V2 1 2)
3

Constructors

V2 !a !a

Instances

Monad V2
Methods (>>=) :: V2 a -> (a -> V2 b) -> V2 b # (>>) :: V2 a -> V2 b -> V2 b # return :: a -> V2 a # fail :: String -> V2 a #
Functor V2
Methods fmap :: (a -> b) -> V2 a -> V2 b # (<$) :: a -> V2 b -> V2 a #
MonadFix V2
Methods mfix :: (a -> V2 a) -> V2 a #
Applicative V2
Methods pure :: a -> V2 a # (<>) :: V2 (a -> b) -> V2 a -> V2 b # liftA2 :: (a -> b -> c) -> V2 a -> V2 b -> V2 c # (>) :: V2 a -> V2 b -> V2 b # (<*) :: V2 a -> V2 b -> V2 a #
Foldable V2
Methods fold :: Monoid m => V2 m -> m # foldMap :: Monoid m => (a -> m) -> V2 a -> m # foldr :: (a -> b -> b) -> b -> V2 a -> b # foldr' :: (a -> b -> b) -> b -> V2 a -> b # foldl :: (b -> a -> b) -> b -> V2 a -> b # foldl' :: (b -> a -> b) -> b -> V2 a -> b # foldr1 :: (a -> a -> a) -> V2 a -> a # foldl1 :: (a -> a -> a) -> V2 a -> a # toList :: V2 a -> [a] # null :: V2 a -> Bool # length :: V2 a -> Int # elem :: Eq a => a -> V2 a -> Bool # maximum :: Ord a => V2 a -> a # minimum :: Ord a => V2 a -> a # sum :: Num a => V2 a -> a # product :: Num a => V2 a -> a #
Traversable V2
Methods traverse :: Applicative f => (a -> f b) -> V2 a -> f (V2 b) # sequenceA :: Applicative f => V2 (f a) -> f (V2 a) # mapM :: Monad m => (a -> m b) -> V2 a -> m (V2 b) # sequence :: Monad m => V2 (m a) -> m (V2 a) #
Eq1 V2
Methods liftEq :: (a -> b -> Bool) -> V2 a -> V2 b -> Bool #
Ord1 V2
Methods liftCompare :: (a -> b -> Ordering) -> V2 a -> V2 b -> Ordering #
Read1 V2
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (V2 a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [V2 a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (V2 a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [V2 a] #
Show1 V2
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> V2 a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [V2 a] -> ShowS #
MonadZip V2
Methods mzip :: V2 a -> V2 b -> V2 (a, b) # mzipWith :: (a -> b -> c) -> V2 a -> V2 b -> V2 c # munzip :: V2 (a, b) -> (V2 a, V2 b) #
Representable V2
Associated Types type Rep (V2 :: * -> ) :: Methods tabulate :: (Rep V2 -> a) -> V2 a index :: V2 a -> Rep V2 -> a
Affine V2
Associated Types type Diff (V2 :: * -> ) :: -> * # Methods (.-.) :: Num a => V2 a -> V2 a -> Diff V2 a # (.+^) :: Num a => V2 a -> Diff V2 a -> V2 a # (.-^) :: Num a => V2 a -> Diff V2 a -> V2 a #
R2 V2
Methods _y :: Functor f => (a -> f a) -> V2 a -> f (V2 a) # _xy :: Functor f => (V2 a -> f (V2 a)) -> V2 a -> f (V2 a) #
R1 V2
Methods _x :: Functor f => (a -> f a) -> V2 a -> f (V2 a) #
Finite V2
Associated Types type Size (V2 :: * -> *) :: Nat # Methods toV :: V2 a -> V Nat (Size V2) a # fromV :: V Nat (Size V2) a -> V2 a #
Metric V2
Methods dot :: Num a => V2 a -> V2 a -> a # quadrance :: Num a => V2 a -> a # qd :: Num a => V2 a -> V2 a -> a # distance :: Floating a => V2 a -> V2 a -> a # norm :: Floating a => V2 a -> a # signorm :: Floating a => V2 a -> V2 a #
Additive V2
Methods zero :: Num a => V2 a # (^+^) :: Num a => V2 a -> V2 a -> V2 a # (^-^) :: Num a => V2 a -> V2 a -> V2 a # lerp :: Num a => a -> V2 a -> V2 a -> V2 a # liftU2 :: (a -> a -> a) -> V2 a -> V2 a -> V2 a # liftI2 :: (a -> b -> c) -> V2 a -> V2 b -> V2 c #
Serial1 V2
Methods serializeWith :: MonadPut m => (a -> m ()) -> V2 a -> m () deserializeWith :: MonadGet m => m a -> m (V2 a)
Distributive V2
Methods distribute :: Functor f => f (V2 a) -> V2 (f a) collect :: Functor f => (a -> V2 b) -> f a -> V2 (f b) distributeM :: Monad m => m (V2 a) -> V2 (m a) collectM :: Monad m => (a -> V2 b) -> m a -> V2 (m b)
Bind V2
Methods (>>-) :: V2 a -> (a -> V2 b) -> V2 b join :: V2 (V2 a) -> V2 a
Apply V2
Methods (<.>) :: V2 (a -> b) -> V2 a -> V2 b (.>) :: V2 a -> V2 b -> V2 b (<.) :: V2 a -> V2 b -> V2 a liftF2 :: (a -> b -> c) -> V2 a -> V2 b -> V2 c
Traversable1 V2
Methods traverse1 :: Apply f => (a -> f b) -> V2 a -> f (V2 b) sequence1 :: Apply f => V2 (f b) -> f (V2 b)
Foldable1 V2
Methods fold1 :: Semigroup m => V2 m -> m foldMap1 :: Semigroup m => (a -> m) -> V2 a -> m toNonEmpty :: V2 a -> NonEmpty a
Unbox a => Vector Vector (V2 a)
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V2 a) -> m (Vector (V2 a)) # basicUnsafeThaw :: PrimMonad m => Vector (V2 a) -> m (Mutable Vector (PrimState m) (V2 a)) # basicLength :: Vector (V2 a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (V2 a) -> Vector (V2 a) # basicUnsafeIndexM :: Monad m => Vector (V2 a) -> Int -> m (V2 a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V2 a) -> Vector (V2 a) -> m () # elemseq :: Vector (V2 a) -> V2 a -> b -> b #
Unbox a => MVector MVector (V2 a)
Methods basicLength :: MVector s (V2 a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (V2 a) -> MVector s (V2 a) # basicOverlaps :: MVector s (V2 a) -> MVector s (V2 a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V2 a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (V2 a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> V2 a -> m (MVector (PrimState m) (V2 a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V2 a) -> Int -> m (V2 a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V2 a) -> Int -> V2 a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (V2 a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (V2 a) -> V2 a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V2 a) -> MVector (PrimState m) (V2 a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V2 a) -> MVector (PrimState m) (V2 a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V2 a) -> Int -> m (MVector (PrimState m) (V2 a)) #
Bounded a => Bounded (V2 a)
Methods minBound :: V2 a # maxBound :: V2 a #
Eq a => Eq (V2 a)
Methods (==) :: V2 a -> V2 a -> Bool # (/=) :: V2 a -> V2 a -> Bool #
Floating a => Floating (V2 a)
Methods pi :: V2 a # exp :: V2 a -> V2 a # log :: V2 a -> V2 a # sqrt :: V2 a -> V2 a # (**) :: V2 a -> V2 a -> V2 a # logBase :: V2 a -> V2 a -> V2 a # sin :: V2 a -> V2 a # cos :: V2 a -> V2 a # tan :: V2 a -> V2 a # asin :: V2 a -> V2 a # acos :: V2 a -> V2 a # atan :: V2 a -> V2 a # sinh :: V2 a -> V2 a # cosh :: V2 a -> V2 a # tanh :: V2 a -> V2 a # asinh :: V2 a -> V2 a # acosh :: V2 a -> V2 a # atanh :: V2 a -> V2 a # log1p :: V2 a -> V2 a # expm1 :: V2 a -> V2 a # log1pexp :: V2 a -> V2 a # log1mexp :: V2 a -> V2 a #
Fractional a => Fractional (V2 a)
Methods (/) :: V2 a -> V2 a -> V2 a # recip :: V2 a -> V2 a # fromRational :: Rational -> V2 a #
Data a => Data (V2 a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V2 a -> c (V2 a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V2 a) # toConstr :: V2 a -> Constr # dataTypeOf :: V2 a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (V2 a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V2 a)) # gmapT :: (forall b. Data b => b -> b) -> V2 a -> V2 a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V2 a -> r # gmapQ :: (forall d. Data d => d -> u) -> V2 a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V2 a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V2 a -> m (V2 a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V2 a -> m (V2 a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V2 a -> m (V2 a) #
Num a => Num (V2 a)
Methods (+) :: V2 a -> V2 a -> V2 a # (-) :: V2 a -> V2 a -> V2 a # (*) :: V2 a -> V2 a -> V2 a # negate :: V2 a -> V2 a # abs :: V2 a -> V2 a # signum :: V2 a -> V2 a # fromInteger :: Integer -> V2 a #
Ord a => Ord (V2 a)
Methods compare :: V2 a -> V2 a -> Ordering # (<) :: V2 a -> V2 a -> Bool # (<=) :: V2 a -> V2 a -> Bool # (>) :: V2 a -> V2 a -> Bool # (>=) :: V2 a -> V2 a -> Bool # max :: V2 a -> V2 a -> V2 a # min :: V2 a -> V2 a -> V2 a #
Read a => Read (V2 a)
Methods readsPrec :: Int -> ReadS (V2 a) # readList :: ReadS [V2 a] # readPrec :: ReadPrec (V2 a) # readListPrec :: ReadPrec [V2 a] #
Show a => Show (V2 a)
Methods showsPrec :: Int -> V2 a -> ShowS # show :: V2 a -> String # showList :: [V2 a] -> ShowS #
Ix a => Ix (V2 a)
Methods range :: (V2 a, V2 a) -> [V2 a] # index :: (V2 a, V2 a) -> V2 a -> Int # unsafeIndex :: (V2 a, V2 a) -> V2 a -> Int inRange :: (V2 a, V2 a) -> V2 a -> Bool # rangeSize :: (V2 a, V2 a) -> Int # unsafeRangeSize :: (V2 a, V2 a) -> Int
Generic (V2 a)
Associated Types type Rep (V2 a) :: * -> * # Methods from :: V2 a -> Rep (V2 a) x # to :: Rep (V2 a) x -> V2 a #
Storable a => Storable (V2 a)
Methods sizeOf :: V2 a -> Int # alignment :: V2 a -> Int # peekElemOff :: Ptr (V2 a) -> Int -> IO (V2 a) # pokeElemOff :: Ptr (V2 a) -> Int -> V2 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (V2 a) # pokeByteOff :: Ptr b -> Int -> V2 a -> IO () # peek :: Ptr (V2 a) -> IO (V2 a) # poke :: Ptr (V2 a) -> V2 a -> IO () #
Binary a => Binary (V2 a)
Methods put :: V2 a -> Put # get :: Get (V2 a) # putList :: [V2 a] -> Put #
NFData a => NFData (V2 a)
Methods rnf :: V2 a -> () #
Epsilon a => Epsilon (V2 a)
Methods nearZero :: V2 a -> Bool #
Unbox a => Unbox (V2 a)

Serialize a => Serialize (V2 a)
Methods put :: Putter (V2 a) get :: Get (V2 a)
Serial a => Serial (V2 a)
Methods serialize :: MonadPut m => V2 a -> m () deserialize :: MonadGet m => m (V2 a)
Ixed (V2 a)
Methods ix :: Index (V2 a) -> Traversal' (V2 a) (IxValue (V2 a))
Hashable a => Hashable (V2 a)
Methods hashWithSalt :: Int -> V2 a -> Int hash :: V2 a -> Int
Generic1 * V2
Associated Types type Rep1 V2 (f :: V2 -> ) :: k -> # Methods from1 :: f a -> Rep1 V2 f a # to1 :: Rep1 V2 f a -> f a #
TraversableWithIndex (E V2) V2
Methods itraverse :: Applicative f => (E V2 -> a -> f b) -> V2 a -> f (V2 b) itraversed :: (Indexable (E V2) p, Applicative f) => p a (f b) -> V2 a -> f (V2 b)
FunctorWithIndex (E V2) V2
Methods imap :: (E V2 -> a -> b) -> V2 a -> V2 b imapped :: (Indexable (E V2) p, Settable f) => p a (f b) -> V2 a -> f (V2 b)
FoldableWithIndex (E V2) V2
Methods ifoldMap :: Monoid m => (E V2 -> a -> m) -> V2 a -> m ifolded :: (Indexable (E V2) p, Contravariant f, Applicative f) => p a (f a) -> V2 a -> f (V2 a) ifoldr :: (E V2 -> a -> b -> b) -> b -> V2 a -> b ifoldl :: (E V2 -> b -> a -> b) -> b -> V2 a -> b ifoldr' :: (E V2 -> a -> b -> b) -> b -> V2 a -> b ifoldl' :: (E V2 -> b -> a -> b) -> b -> V2 a -> b
Each (V2 a) (V2 b) a b
Methods each :: Traversal (V2 a) (V2 b) a b
type Diff V2
type Diff V2 = V2
type Size V2
type Size V2 = 2
type Rep V2
type Rep V2 = E V2
data MVector s (V2 a)
data MVector s (V2 a) = MV_V2 !Int !(MVector s a)
type Rep (V2 a)
type Rep (V2 a) = D1 * (MetaData "V2" "Linear.V2" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V2" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a))))
data Vector (V2 a)
data Vector (V2 a) = V_V2 !Int !(Vector a)
type IxValue (V2 a)
type IxValue (V2 a) = a
type Index (V2 a)
type Index (V2 a) = E V2
type Rep1 * V2
type Rep1 * V2 = D1 * (MetaData "V2" "Linear.V2" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V2" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

data V3 a :: * -> * #

A 3-dimensional vector

Constructors

V3 !a !a !a

Instances

Monad V3
Methods (>>=) :: V3 a -> (a -> V3 b) -> V3 b # (>>) :: V3 a -> V3 b -> V3 b # return :: a -> V3 a # fail :: String -> V3 a #
Functor V3
Methods fmap :: (a -> b) -> V3 a -> V3 b # (<$) :: a -> V3 b -> V3 a #
MonadFix V3
Methods mfix :: (a -> V3 a) -> V3 a #
Applicative V3
Methods pure :: a -> V3 a # (<>) :: V3 (a -> b) -> V3 a -> V3 b # liftA2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c # (>) :: V3 a -> V3 b -> V3 b # (<*) :: V3 a -> V3 b -> V3 a #
Foldable V3
Methods fold :: Monoid m => V3 m -> m # foldMap :: Monoid m => (a -> m) -> V3 a -> m # foldr :: (a -> b -> b) -> b -> V3 a -> b # foldr' :: (a -> b -> b) -> b -> V3 a -> b # foldl :: (b -> a -> b) -> b -> V3 a -> b # foldl' :: (b -> a -> b) -> b -> V3 a -> b # foldr1 :: (a -> a -> a) -> V3 a -> a # foldl1 :: (a -> a -> a) -> V3 a -> a # toList :: V3 a -> [a] # null :: V3 a -> Bool # length :: V3 a -> Int # elem :: Eq a => a -> V3 a -> Bool # maximum :: Ord a => V3 a -> a # minimum :: Ord a => V3 a -> a # sum :: Num a => V3 a -> a # product :: Num a => V3 a -> a #
Traversable V3
Methods traverse :: Applicative f => (a -> f b) -> V3 a -> f (V3 b) # sequenceA :: Applicative f => V3 (f a) -> f (V3 a) # mapM :: Monad m => (a -> m b) -> V3 a -> m (V3 b) # sequence :: Monad m => V3 (m a) -> m (V3 a) #
Eq1 V3
Methods liftEq :: (a -> b -> Bool) -> V3 a -> V3 b -> Bool #
Ord1 V3
Methods liftCompare :: (a -> b -> Ordering) -> V3 a -> V3 b -> Ordering #
Read1 V3
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (V3 a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [V3 a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (V3 a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [V3 a] #
Show1 V3
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> V3 a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [V3 a] -> ShowS #
MonadZip V3
Methods mzip :: V3 a -> V3 b -> V3 (a, b) # mzipWith :: (a -> b -> c) -> V3 a -> V3 b -> V3 c # munzip :: V3 (a, b) -> (V3 a, V3 b) #
Representable V3
Associated Types type Rep (V3 :: * -> ) :: Methods tabulate :: (Rep V3 -> a) -> V3 a index :: V3 a -> Rep V3 -> a
Affine V3
Associated Types type Diff (V3 :: * -> ) :: -> * # Methods (.-.) :: Num a => V3 a -> V3 a -> Diff V3 a # (.+^) :: Num a => V3 a -> Diff V3 a -> V3 a # (.-^) :: Num a => V3 a -> Diff V3 a -> V3 a #
R3 V3
Methods _z :: Functor f => (a -> f a) -> V3 a -> f (V3 a) # _xyz :: Functor f => (V3 a -> f (V3 a)) -> V3 a -> f (V3 a) #
R2 V3
Methods _y :: Functor f => (a -> f a) -> V3 a -> f (V3 a) # _xy :: Functor f => (V2 a -> f (V2 a)) -> V3 a -> f (V3 a) #
R1 V3
Methods _x :: Functor f => (a -> f a) -> V3 a -> f (V3 a) #
Finite V3
Associated Types type Size (V3 :: * -> *) :: Nat # Methods toV :: V3 a -> V Nat (Size V3) a # fromV :: V Nat (Size V3) a -> V3 a #
Metric V3
Methods dot :: Num a => V3 a -> V3 a -> a # quadrance :: Num a => V3 a -> a # qd :: Num a => V3 a -> V3 a -> a # distance :: Floating a => V3 a -> V3 a -> a # norm :: Floating a => V3 a -> a # signorm :: Floating a => V3 a -> V3 a #
Additive V3
Methods zero :: Num a => V3 a # (^+^) :: Num a => V3 a -> V3 a -> V3 a # (^-^) :: Num a => V3 a -> V3 a -> V3 a # lerp :: Num a => a -> V3 a -> V3 a -> V3 a # liftU2 :: (a -> a -> a) -> V3 a -> V3 a -> V3 a # liftI2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c #
Serial1 V3
Methods serializeWith :: MonadPut m => (a -> m ()) -> V3 a -> m () deserializeWith :: MonadGet m => m a -> m (V3 a)
Distributive V3
Methods distribute :: Functor f => f (V3 a) -> V3 (f a) collect :: Functor f => (a -> V3 b) -> f a -> V3 (f b) distributeM :: Monad m => m (V3 a) -> V3 (m a) collectM :: Monad m => (a -> V3 b) -> m a -> V3 (m b)
Bind V3
Methods (>>-) :: V3 a -> (a -> V3 b) -> V3 b join :: V3 (V3 a) -> V3 a
Apply V3
Methods (<.>) :: V3 (a -> b) -> V3 a -> V3 b (.>) :: V3 a -> V3 b -> V3 b (<.) :: V3 a -> V3 b -> V3 a liftF2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c
Traversable1 V3
Methods traverse1 :: Apply f => (a -> f b) -> V3 a -> f (V3 b) sequence1 :: Apply f => V3 (f b) -> f (V3 b)
Foldable1 V3
Methods fold1 :: Semigroup m => V3 m -> m foldMap1 :: Semigroup m => (a -> m) -> V3 a -> m toNonEmpty :: V3 a -> NonEmpty a
Unbox a => Vector Vector (V3 a)
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V3 a) -> m (Vector (V3 a)) # basicUnsafeThaw :: PrimMonad m => Vector (V3 a) -> m (Mutable Vector (PrimState m) (V3 a)) # basicLength :: Vector (V3 a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (V3 a) -> Vector (V3 a) # basicUnsafeIndexM :: Monad m => Vector (V3 a) -> Int -> m (V3 a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V3 a) -> Vector (V3 a) -> m () # elemseq :: Vector (V3 a) -> V3 a -> b -> b #
Unbox a => MVector MVector (V3 a)
Methods basicLength :: MVector s (V3 a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (V3 a) -> MVector s (V3 a) # basicOverlaps :: MVector s (V3 a) -> MVector s (V3 a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V3 a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (V3 a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> V3 a -> m (MVector (PrimState m) (V3 a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> m (V3 a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> V3 a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (V3 a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (V3 a) -> V3 a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V3 a) -> MVector (PrimState m) (V3 a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V3 a) -> MVector (PrimState m) (V3 a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V3 a) -> Int -> m (MVector (PrimState m) (V3 a)) #
Bounded a => Bounded (V3 a)
Methods minBound :: V3 a # maxBound :: V3 a #
Eq a => Eq (V3 a)
Methods (==) :: V3 a -> V3 a -> Bool # (/=) :: V3 a -> V3 a -> Bool #
Floating a => Floating (V3 a)
Methods pi :: V3 a # exp :: V3 a -> V3 a # log :: V3 a -> V3 a # sqrt :: V3 a -> V3 a # (**) :: V3 a -> V3 a -> V3 a # logBase :: V3 a -> V3 a -> V3 a # sin :: V3 a -> V3 a # cos :: V3 a -> V3 a # tan :: V3 a -> V3 a # asin :: V3 a -> V3 a # acos :: V3 a -> V3 a # atan :: V3 a -> V3 a # sinh :: V3 a -> V3 a # cosh :: V3 a -> V3 a # tanh :: V3 a -> V3 a # asinh :: V3 a -> V3 a # acosh :: V3 a -> V3 a # atanh :: V3 a -> V3 a # log1p :: V3 a -> V3 a # expm1 :: V3 a -> V3 a # log1pexp :: V3 a -> V3 a # log1mexp :: V3 a -> V3 a #
Fractional a => Fractional (V3 a)
Methods (/) :: V3 a -> V3 a -> V3 a # recip :: V3 a -> V3 a # fromRational :: Rational -> V3 a #
Data a => Data (V3 a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V3 a -> c (V3 a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V3 a) # toConstr :: V3 a -> Constr # dataTypeOf :: V3 a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (V3 a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V3 a)) # gmapT :: (forall b. Data b => b -> b) -> V3 a -> V3 a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V3 a -> r # gmapQ :: (forall d. Data d => d -> u) -> V3 a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V3 a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V3 a -> m (V3 a) #
Num a => Num (V3 a)
Methods (+) :: V3 a -> V3 a -> V3 a # (-) :: V3 a -> V3 a -> V3 a # (*) :: V3 a -> V3 a -> V3 a # negate :: V3 a -> V3 a # abs :: V3 a -> V3 a # signum :: V3 a -> V3 a # fromInteger :: Integer -> V3 a #
Ord a => Ord (V3 a)
Methods compare :: V3 a -> V3 a -> Ordering # (<) :: V3 a -> V3 a -> Bool # (<=) :: V3 a -> V3 a -> Bool # (>) :: V3 a -> V3 a -> Bool # (>=) :: V3 a -> V3 a -> Bool # max :: V3 a -> V3 a -> V3 a # min :: V3 a -> V3 a -> V3 a #
Read a => Read (V3 a)
Methods readsPrec :: Int -> ReadS (V3 a) # readList :: ReadS [V3 a] # readPrec :: ReadPrec (V3 a) # readListPrec :: ReadPrec [V3 a] #
Show a => Show (V3 a)
Methods showsPrec :: Int -> V3 a -> ShowS # show :: V3 a -> String # showList :: [V3 a] -> ShowS #
Ix a => Ix (V3 a)
Methods range :: (V3 a, V3 a) -> [V3 a] # index :: (V3 a, V3 a) -> V3 a -> Int # unsafeIndex :: (V3 a, V3 a) -> V3 a -> Int inRange :: (V3 a, V3 a) -> V3 a -> Bool # rangeSize :: (V3 a, V3 a) -> Int # unsafeRangeSize :: (V3 a, V3 a) -> Int
Generic (V3 a)
Associated Types type Rep (V3 a) :: * -> * # Methods from :: V3 a -> Rep (V3 a) x # to :: Rep (V3 a) x -> V3 a #
Storable a => Storable (V3 a)
Methods sizeOf :: V3 a -> Int # alignment :: V3 a -> Int # peekElemOff :: Ptr (V3 a) -> Int -> IO (V3 a) # pokeElemOff :: Ptr (V3 a) -> Int -> V3 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (V3 a) # pokeByteOff :: Ptr b -> Int -> V3 a -> IO () # peek :: Ptr (V3 a) -> IO (V3 a) # poke :: Ptr (V3 a) -> V3 a -> IO () #
Binary a => Binary (V3 a)
Methods put :: V3 a -> Put # get :: Get (V3 a) # putList :: [V3 a] -> Put #
NFData a => NFData (V3 a)
Methods rnf :: V3 a -> () #
Epsilon a => Epsilon (V3 a)
Methods nearZero :: V3 a -> Bool #
Unbox a => Unbox (V3 a)

Serialize a => Serialize (V3 a)
Methods put :: Putter (V3 a) get :: Get (V3 a)
Serial a => Serial (V3 a)
Methods serialize :: MonadPut m => V3 a -> m () deserialize :: MonadGet m => m (V3 a)
Ixed (V3 a)
Methods ix :: Index (V3 a) -> Traversal' (V3 a) (IxValue (V3 a))
Hashable a => Hashable (V3 a)
Methods hashWithSalt :: Int -> V3 a -> Int hash :: V3 a -> Int
Generic1 * V3
Associated Types type Rep1 V3 (f :: V3 -> ) :: k -> # Methods from1 :: f a -> Rep1 V3 f a # to1 :: Rep1 V3 f a -> f a #
TraversableWithIndex (E V3) V3
Methods itraverse :: Applicative f => (E V3 -> a -> f b) -> V3 a -> f (V3 b) itraversed :: (Indexable (E V3) p, Applicative f) => p a (f b) -> V3 a -> f (V3 b)
FunctorWithIndex (E V3) V3
Methods imap :: (E V3 -> a -> b) -> V3 a -> V3 b imapped :: (Indexable (E V3) p, Settable f) => p a (f b) -> V3 a -> f (V3 b)
FoldableWithIndex (E V3) V3
Methods ifoldMap :: Monoid m => (E V3 -> a -> m) -> V3 a -> m ifolded :: (Indexable (E V3) p, Contravariant f, Applicative f) => p a (f a) -> V3 a -> f (V3 a) ifoldr :: (E V3 -> a -> b -> b) -> b -> V3 a -> b ifoldl :: (E V3 -> b -> a -> b) -> b -> V3 a -> b ifoldr' :: (E V3 -> a -> b -> b) -> b -> V3 a -> b ifoldl' :: (E V3 -> b -> a -> b) -> b -> V3 a -> b
Each (V3 a) (V3 b) a b
Methods each :: Traversal (V3 a) (V3 b) a b
type Diff V3
type Diff V3 = V3
type Size V3
type Size V3 = 3
type Rep V3
type Rep V3 = E V3
data MVector s (V3 a)
data MVector s (V3 a) = MV_V3 !Int !(MVector s a)
type Rep (V3 a)
type Rep (V3 a) = D1 * (MetaData "V3" "Linear.V3" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V3" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)))))
data Vector (V3 a)
data Vector (V3 a) = V_V3 !Int !(Vector a)
type IxValue (V3 a)
type IxValue (V3 a) = a
type Index (V3 a)
type Index (V3 a) = E V3
type Rep1 * V3
type Rep1 * V3 = D1 * (MetaData "V3" "Linear.V3" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V3" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1))))

data V4 a :: * -> * #

A 4-dimensional vector.

Constructors

V4 !a !a !a !a

Instances

Monad V4
Methods (>>=) :: V4 a -> (a -> V4 b) -> V4 b # (>>) :: V4 a -> V4 b -> V4 b # return :: a -> V4 a # fail :: String -> V4 a #
Functor V4
Methods fmap :: (a -> b) -> V4 a -> V4 b # (<$) :: a -> V4 b -> V4 a #
MonadFix V4
Methods mfix :: (a -> V4 a) -> V4 a #
Applicative V4
Methods pure :: a -> V4 a # (<>) :: V4 (a -> b) -> V4 a -> V4 b # liftA2 :: (a -> b -> c) -> V4 a -> V4 b -> V4 c # (>) :: V4 a -> V4 b -> V4 b # (<*) :: V4 a -> V4 b -> V4 a #
Foldable V4
Methods fold :: Monoid m => V4 m -> m # foldMap :: Monoid m => (a -> m) -> V4 a -> m # foldr :: (a -> b -> b) -> b -> V4 a -> b # foldr' :: (a -> b -> b) -> b -> V4 a -> b # foldl :: (b -> a -> b) -> b -> V4 a -> b # foldl' :: (b -> a -> b) -> b -> V4 a -> b # foldr1 :: (a -> a -> a) -> V4 a -> a # foldl1 :: (a -> a -> a) -> V4 a -> a # toList :: V4 a -> [a] # null :: V4 a -> Bool # length :: V4 a -> Int # elem :: Eq a => a -> V4 a -> Bool # maximum :: Ord a => V4 a -> a # minimum :: Ord a => V4 a -> a # sum :: Num a => V4 a -> a # product :: Num a => V4 a -> a #
Traversable V4
Methods traverse :: Applicative f => (a -> f b) -> V4 a -> f (V4 b) # sequenceA :: Applicative f => V4 (f a) -> f (V4 a) # mapM :: Monad m => (a -> m b) -> V4 a -> m (V4 b) # sequence :: Monad m => V4 (m a) -> m (V4 a) #
Eq1 V4
Methods liftEq :: (a -> b -> Bool) -> V4 a -> V4 b -> Bool #
Ord1 V4
Methods liftCompare :: (a -> b -> Ordering) -> V4 a -> V4 b -> Ordering #
Read1 V4
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (V4 a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [V4 a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (V4 a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [V4 a] #
Show1 V4
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> V4 a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [V4 a] -> ShowS #
MonadZip V4
Methods mzip :: V4 a -> V4 b -> V4 (a, b) # mzipWith :: (a -> b -> c) -> V4 a -> V4 b -> V4 c # munzip :: V4 (a, b) -> (V4 a, V4 b) #
Representable V4
Associated Types type Rep (V4 :: * -> ) :: Methods tabulate :: (Rep V4 -> a) -> V4 a index :: V4 a -> Rep V4 -> a
Affine V4
Associated Types type Diff (V4 :: * -> ) :: -> * # Methods (.-.) :: Num a => V4 a -> V4 a -> Diff V4 a # (.+^) :: Num a => V4 a -> Diff V4 a -> V4 a # (.-^) :: Num a => V4 a -> Diff V4 a -> V4 a #
R4 V4
Methods _w :: Functor f => (a -> f a) -> V4 a -> f (V4 a) # _xyzw :: Functor f => (V4 a -> f (V4 a)) -> V4 a -> f (V4 a) #
R3 V4
Methods _z :: Functor f => (a -> f a) -> V4 a -> f (V4 a) # _xyz :: Functor f => (V3 a -> f (V3 a)) -> V4 a -> f (V4 a) #
R2 V4
Methods _y :: Functor f => (a -> f a) -> V4 a -> f (V4 a) # _xy :: Functor f => (V2 a -> f (V2 a)) -> V4 a -> f (V4 a) #
R1 V4
Methods _x :: Functor f => (a -> f a) -> V4 a -> f (V4 a) #
Finite V4
Associated Types type Size (V4 :: * -> *) :: Nat # Methods toV :: V4 a -> V Nat (Size V4) a # fromV :: V Nat (Size V4) a -> V4 a #
Metric V4
Methods dot :: Num a => V4 a -> V4 a -> a # quadrance :: Num a => V4 a -> a # qd :: Num a => V4 a -> V4 a -> a # distance :: Floating a => V4 a -> V4 a -> a # norm :: Floating a => V4 a -> a # signorm :: Floating a => V4 a -> V4 a #
Additive V4
Methods zero :: Num a => V4 a # (^+^) :: Num a => V4 a -> V4 a -> V4 a # (^-^) :: Num a => V4 a -> V4 a -> V4 a # lerp :: Num a => a -> V4 a -> V4 a -> V4 a # liftU2 :: (a -> a -> a) -> V4 a -> V4 a -> V4 a # liftI2 :: (a -> b -> c) -> V4 a -> V4 b -> V4 c #
Serial1 V4
Methods serializeWith :: MonadPut m => (a -> m ()) -> V4 a -> m () deserializeWith :: MonadGet m => m a -> m (V4 a)
Distributive V4
Methods distribute :: Functor f => f (V4 a) -> V4 (f a) collect :: Functor f => (a -> V4 b) -> f a -> V4 (f b) distributeM :: Monad m => m (V4 a) -> V4 (m a) collectM :: Monad m => (a -> V4 b) -> m a -> V4 (m b)
Bind V4
Methods (>>-) :: V4 a -> (a -> V4 b) -> V4 b join :: V4 (V4 a) -> V4 a
Apply V4
Methods (<.>) :: V4 (a -> b) -> V4 a -> V4 b (.>) :: V4 a -> V4 b -> V4 b (<.) :: V4 a -> V4 b -> V4 a liftF2 :: (a -> b -> c) -> V4 a -> V4 b -> V4 c
Traversable1 V4
Methods traverse1 :: Apply f => (a -> f b) -> V4 a -> f (V4 b) sequence1 :: Apply f => V4 (f b) -> f (V4 b)
Foldable1 V4
Methods fold1 :: Semigroup m => V4 m -> m foldMap1 :: Semigroup m => (a -> m) -> V4 a -> m toNonEmpty :: V4 a -> NonEmpty a
Unbox a => Vector Vector (V4 a)
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V4 a) -> m (Vector (V4 a)) # basicUnsafeThaw :: PrimMonad m => Vector (V4 a) -> m (Mutable Vector (PrimState m) (V4 a)) # basicLength :: Vector (V4 a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (V4 a) -> Vector (V4 a) # basicUnsafeIndexM :: Monad m => Vector (V4 a) -> Int -> m (V4 a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V4 a) -> Vector (V4 a) -> m () # elemseq :: Vector (V4 a) -> V4 a -> b -> b #
Unbox a => MVector MVector (V4 a)
Methods basicLength :: MVector s (V4 a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (V4 a) -> MVector s (V4 a) # basicOverlaps :: MVector s (V4 a) -> MVector s (V4 a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V4 a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (V4 a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> V4 a -> m (MVector (PrimState m) (V4 a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V4 a) -> Int -> m (V4 a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V4 a) -> Int -> V4 a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (V4 a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (V4 a) -> V4 a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V4 a) -> MVector (PrimState m) (V4 a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V4 a) -> MVector (PrimState m) (V4 a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V4 a) -> Int -> m (MVector (PrimState m) (V4 a)) #
Bounded a => Bounded (V4 a)
Methods minBound :: V4 a # maxBound :: V4 a #
Eq a => Eq (V4 a)
Methods (==) :: V4 a -> V4 a -> Bool # (/=) :: V4 a -> V4 a -> Bool #
Floating a => Floating (V4 a)
Methods pi :: V4 a # exp :: V4 a -> V4 a # log :: V4 a -> V4 a # sqrt :: V4 a -> V4 a # (**) :: V4 a -> V4 a -> V4 a # logBase :: V4 a -> V4 a -> V4 a # sin :: V4 a -> V4 a # cos :: V4 a -> V4 a # tan :: V4 a -> V4 a # asin :: V4 a -> V4 a # acos :: V4 a -> V4 a # atan :: V4 a -> V4 a # sinh :: V4 a -> V4 a # cosh :: V4 a -> V4 a # tanh :: V4 a -> V4 a # asinh :: V4 a -> V4 a # acosh :: V4 a -> V4 a # atanh :: V4 a -> V4 a # log1p :: V4 a -> V4 a # expm1 :: V4 a -> V4 a # log1pexp :: V4 a -> V4 a # log1mexp :: V4 a -> V4 a #
Fractional a => Fractional (V4 a)
Methods (/) :: V4 a -> V4 a -> V4 a # recip :: V4 a -> V4 a # fromRational :: Rational -> V4 a #
Data a => Data (V4 a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V4 a -> c (V4 a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V4 a) # toConstr :: V4 a -> Constr # dataTypeOf :: V4 a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (V4 a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V4 a)) # gmapT :: (forall b. Data b => b -> b) -> V4 a -> V4 a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V4 a -> r # gmapQ :: (forall d. Data d => d -> u) -> V4 a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V4 a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V4 a -> m (V4 a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V4 a -> m (V4 a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V4 a -> m (V4 a) #
Num a => Num (V4 a)
Methods (+) :: V4 a -> V4 a -> V4 a # (-) :: V4 a -> V4 a -> V4 a # (*) :: V4 a -> V4 a -> V4 a # negate :: V4 a -> V4 a # abs :: V4 a -> V4 a # signum :: V4 a -> V4 a # fromInteger :: Integer -> V4 a #
Ord a => Ord (V4 a)
Methods compare :: V4 a -> V4 a -> Ordering # (<) :: V4 a -> V4 a -> Bool # (<=) :: V4 a -> V4 a -> Bool # (>) :: V4 a -> V4 a -> Bool # (>=) :: V4 a -> V4 a -> Bool # max :: V4 a -> V4 a -> V4 a # min :: V4 a -> V4 a -> V4 a #
Read a => Read (V4 a)
Methods readsPrec :: Int -> ReadS (V4 a) # readList :: ReadS [V4 a] # readPrec :: ReadPrec (V4 a) # readListPrec :: ReadPrec [V4 a] #
Show a => Show (V4 a)
Methods showsPrec :: Int -> V4 a -> ShowS # show :: V4 a -> String # showList :: [V4 a] -> ShowS #
Ix a => Ix (V4 a)
Methods range :: (V4 a, V4 a) -> [V4 a] # index :: (V4 a, V4 a) -> V4 a -> Int # unsafeIndex :: (V4 a, V4 a) -> V4 a -> Int inRange :: (V4 a, V4 a) -> V4 a -> Bool # rangeSize :: (V4 a, V4 a) -> Int # unsafeRangeSize :: (V4 a, V4 a) -> Int
Generic (V4 a)
Associated Types type Rep (V4 a) :: * -> * # Methods from :: V4 a -> Rep (V4 a) x # to :: Rep (V4 a) x -> V4 a #
Storable a => Storable (V4 a)
Methods sizeOf :: V4 a -> Int # alignment :: V4 a -> Int # peekElemOff :: Ptr (V4 a) -> Int -> IO (V4 a) # pokeElemOff :: Ptr (V4 a) -> Int -> V4 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (V4 a) # pokeByteOff :: Ptr b -> Int -> V4 a -> IO () # peek :: Ptr (V4 a) -> IO (V4 a) # poke :: Ptr (V4 a) -> V4 a -> IO () #
Binary a => Binary (V4 a)
Methods put :: V4 a -> Put # get :: Get (V4 a) # putList :: [V4 a] -> Put #
NFData a => NFData (V4 a)
Methods rnf :: V4 a -> () #
Epsilon a => Epsilon (V4 a)
Methods nearZero :: V4 a -> Bool #
Unbox a => Unbox (V4 a)

Serialize a => Serialize (V4 a)
Methods put :: Putter (V4 a) get :: Get (V4 a)
Serial a => Serial (V4 a)
Methods serialize :: MonadPut m => V4 a -> m () deserialize :: MonadGet m => m (V4 a)
Ixed (V4 a)
Methods ix :: Index (V4 a) -> Traversal' (V4 a) (IxValue (V4 a))
Hashable a => Hashable (V4 a)
Methods hashWithSalt :: Int -> V4 a -> Int hash :: V4 a -> Int
Generic1 * V4
Associated Types type Rep1 V4 (f :: V4 -> ) :: k -> # Methods from1 :: f a -> Rep1 V4 f a # to1 :: Rep1 V4 f a -> f a #
TraversableWithIndex (E V4) V4
Methods itraverse :: Applicative f => (E V4 -> a -> f b) -> V4 a -> f (V4 b) itraversed :: (Indexable (E V4) p, Applicative f) => p a (f b) -> V4 a -> f (V4 b)
FunctorWithIndex (E V4) V4
Methods imap :: (E V4 -> a -> b) -> V4 a -> V4 b imapped :: (Indexable (E V4) p, Settable f) => p a (f b) -> V4 a -> f (V4 b)
FoldableWithIndex (E V4) V4
Methods ifoldMap :: Monoid m => (E V4 -> a -> m) -> V4 a -> m ifolded :: (Indexable (E V4) p, Contravariant f, Applicative f) => p a (f a) -> V4 a -> f (V4 a) ifoldr :: (E V4 -> a -> b -> b) -> b -> V4 a -> b ifoldl :: (E V4 -> b -> a -> b) -> b -> V4 a -> b ifoldr' :: (E V4 -> a -> b -> b) -> b -> V4 a -> b ifoldl' :: (E V4 -> b -> a -> b) -> b -> V4 a -> b
Each (V4 a) (V4 b) a b
Methods each :: Traversal (V4 a) (V4 b) a b
type Diff V4
type Diff V4 = V4
type Size V4
type Size V4 = 4
type Rep V4
type Rep V4 = E V4
data MVector s (V4 a)
data MVector s (V4 a) = MV_V4 !Int !(MVector s a)
type Rep (V4 a)
type Rep (V4 a) = D1 * (MetaData "V4" "Linear.V4" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V4" PrefixI False) ((::) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a))) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)))))
data Vector (V4 a)
data Vector (V4 a) = V_V4 !Int !(Vector a)
type IxValue (V4 a)
type IxValue (V4 a) = a
type Index (V4 a)
type Index (V4 a) = E V4
type Rep1 * V4
type Rep1 * V4 = D1 * (MetaData "V4" "Linear.V4" "linear-1.20.7-KXFlkgq5dy48PEyJxREgiQ" False) (C1 * (MetaCons "V4" PrefixI False) ((::) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1))))