Data.Geometry.Vector

\(d\)-dimensional vectors.

Documentation

module Data.Geometry.Vector.VectorFamily

outer :: (Functor f, Functor g, Num a) => f a -> g a -> f (g a)

Outer (tensor) product of two vectors

unit :: (Additive t, Num a) => ASetter' (t a) a -> t a

Create a unit vector.

>>> unit _x :: V2 Int
V2 1 0

scaled :: (Traversable t, Num a) => t a -> t (t a)

Produce a diagonal (scale) matrix from a vector.

>>> scaled (V2 2 3)
V2 (V2 2 0) (V2 0 3)

basisFor :: (Traversable t, Num a) => t b -> [t a]

Produce a default basis for a vector space from which the argument is drawn.

basis :: (Additive t, Traversable t, Num a) => [t a]

Produce a default basis for a vector space. If the dimensionality of the vector space is not statically known, see basisFor.

(^/) :: (Functor f, Fractional a) => f a -> a -> f a infixl 7

Compute division by a scalar on the right.

(^*) :: (Functor f, Num a) => f a -> a -> f a infixl 7

Compute the right scalar product

>>> V2 3 4 ^* 2
V2 6 8

(*^) :: (Functor f, Num a) => a -> f a -> f a infixl 7

Compute the left scalar product

>>> 2 *^ V2 3 4
V2 6 8

sumV :: (Foldable f, Additive v, Num a) => f (v a) -> v a

Sum over multiple vectors

>>> sumV [V2 1 1, V2 3 4]
V2 4 5

negated :: (Functor f, Num a) => f a -> f a

Compute the negation of a vector

>>> negated (V2 2 4)
V2 (-2) (-4)

class Functor f => Additive (f :: Type -> Type) where

A vector is an additive group with additional structure.

Minimal complete definition

Nothing

Methods

zero :: Num a => f a

The zero vector

(^+^) :: Num a => f a -> f a -> f a infixl 6

Compute the sum of two vectors

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

(^-^) :: Num a => f a -> f a -> f a infixl 6

Compute the difference between two vectors

>>> V2 4 5 ^-^ V2 3 1
V2 1 4

lerp :: Num a => a -> f a -> f a -> f a

Linearly interpolate between two vectors.

liftU2 :: (a -> a -> a) -> f a -> f a -> f a

Apply a function to merge the 'non-zero' components of two vectors, unioning the rest of the values.

• For a dense vector this is equivalent to liftA2.
• For a sparse vector this is equivalent to unionWith.

liftI2 :: (a -> b -> c) -> f a -> f b -> f c

Apply a function to the components of two vectors.

• For a dense vector this is equivalent to liftA2.
• For a sparse vector this is equivalent to intersectionWith.

Instances

Additive []

Defined in Linear.Vector

Methods

zero :: Num a => [a]

(^+^) :: Num a => [a] -> [a] -> [a]

(^-^) :: Num a => [a] -> [a] -> [a]

lerp :: Num a => a -> [a] -> [a] -> [a]

liftU2 :: (a -> a -> a) -> [a] -> [a] -> [a]

liftI2 :: (a -> b -> c) -> [a] -> [b] -> [c]

Additive Maybe

Defined in Linear.Vector

Methods

zero :: Num a => Maybe a

(^+^) :: Num a => Maybe a -> Maybe a -> Maybe a

(^-^) :: Num a => Maybe a -> Maybe a -> Maybe a

lerp :: Num a => a -> Maybe a -> Maybe a -> Maybe a

liftU2 :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a

liftI2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

Additive Complex

Defined in Linear.Vector

Methods

zero :: Num a => Complex a

(^+^) :: Num a => Complex a -> Complex a -> Complex a

(^-^) :: Num a => Complex a -> Complex a -> Complex a

lerp :: Num a => a -> Complex a -> Complex a -> Complex a

liftU2 :: (a -> a -> a) -> Complex a -> Complex a -> Complex a

liftI2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

Additive ZipList

Defined in Linear.Vector

Methods

zero :: Num a => ZipList a

(^+^) :: Num a => ZipList a -> ZipList a -> ZipList a

(^-^) :: Num a => ZipList a -> ZipList a -> ZipList a

lerp :: Num a => a -> ZipList a -> ZipList a -> ZipList a

liftU2 :: (a -> a -> a) -> ZipList a -> ZipList a -> ZipList a

liftI2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

Additive Identity

Defined in Linear.Vector

Methods

zero :: Num a => Identity a

(^+^) :: Num a => Identity a -> Identity a -> Identity a

(^-^) :: Num a => Identity a -> Identity a -> Identity a

lerp :: Num a => a -> Identity a -> Identity a -> Identity a

liftU2 :: (a -> a -> a) -> Identity a -> Identity a -> Identity a

liftI2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

Additive IntMap

Defined in Linear.Vector

Methods

zero :: Num a => IntMap a

(^+^) :: Num a => IntMap a -> IntMap a -> IntMap a

(^-^) :: Num a => IntMap a -> IntMap a -> IntMap a

lerp :: Num a => a -> IntMap a -> IntMap a -> IntMap a

liftU2 :: (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a

liftI2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c

Additive Vector

Defined in Linear.Vector

Methods

zero :: Num a => Vector a

(^+^) :: Num a => Vector a -> Vector a -> Vector a

(^-^) :: Num a => Vector a -> Vector a -> Vector a

lerp :: Num a => a -> Vector a -> Vector a -> Vector a

liftU2 :: (a -> a -> a) -> Vector a -> Vector a -> Vector a

liftI2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

Additive Plucker

Defined in Linear.Plucker

Methods

zero :: Num a => Plucker a

(^+^) :: Num a => Plucker a -> Plucker a -> Plucker a

(^-^) :: Num a => Plucker a -> Plucker a -> Plucker a

lerp :: Num a => a -> Plucker a -> Plucker a -> Plucker a

liftU2 :: (a -> a -> a) -> Plucker a -> Plucker a -> Plucker a

liftI2 :: (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c

Additive Quaternion

Defined in Linear.Quaternion

Methods

zero :: Num a => Quaternion a

(^+^) :: Num a => Quaternion a -> Quaternion a -> Quaternion a

(^-^) :: Num a => Quaternion a -> Quaternion a -> Quaternion a

lerp :: Num a => a -> Quaternion a -> Quaternion a -> Quaternion a

liftU2 :: (a -> a -> a) -> Quaternion a -> Quaternion a -> Quaternion a

liftI2 :: (a -> b -> c) -> Quaternion a -> Quaternion b -> Quaternion c

Additive V0

Defined in Linear.V0

Methods

zero :: Num a => V0 a

(^+^) :: Num a => V0 a -> V0 a -> V0 a

(^-^) :: Num a => V0 a -> V0 a -> V0 a

lerp :: Num a => a -> V0 a -> V0 a -> V0 a

liftU2 :: (a -> a -> a) -> V0 a -> V0 a -> V0 a

liftI2 :: (a -> b -> c) -> V0 a -> V0 b -> V0 c

Additive V4

Defined in Linear.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

Additive V3

Defined in Linear.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

Additive V2

Defined in Linear.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

Additive V1

Defined in Linear.V1

Methods

zero :: Num a => V1 a

(^+^) :: Num a => V1 a -> V1 a -> V1 a

(^-^) :: Num a => V1 a -> V1 a -> V1 a

lerp :: Num a => a -> V1 a -> V1 a -> V1 a

liftU2 :: (a -> a -> a) -> V1 a -> V1 a -> V1 a

liftI2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c

(Eq k, Hashable k) => Additive (HashMap k)

Defined in Linear.Vector

Methods

zero :: Num a => HashMap k a

(^+^) :: Num a => HashMap k a -> HashMap k a -> HashMap k a

(^-^) :: Num a => HashMap k a -> HashMap k a -> HashMap k a

lerp :: Num a => a -> HashMap k a -> HashMap k a -> HashMap k a

liftU2 :: (a -> a -> a) -> HashMap k a -> HashMap k a -> HashMap k a

liftI2 :: (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c

Ord k => Additive (Map k)

Defined in Linear.Vector

Methods

zero :: Num a => Map k a

(^+^) :: Num a => Map k a -> Map k a -> Map k a

(^-^) :: Num a => Map k a -> Map k a -> Map k a

lerp :: Num a => a -> Map k a -> Map k a -> Map k a

liftU2 :: (a -> a -> a) -> Map k a -> Map k a -> Map k a

liftI2 :: (a -> b -> c) -> Map k a -> Map k b -> Map k c

Additive f => Additive (Point f)

Defined in Linear.Affine

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

Arity d => Additive (Vector d)

Defined in Data.Geometry.Vector.VectorFixed

Methods

zero :: Num a => Vector d a

(^+^) :: Num a => Vector d a -> Vector d a -> Vector d a

(^-^) :: Num a => Vector d a -> Vector d a -> Vector d a

lerp :: Num a => a -> Vector d a -> Vector d a -> Vector d a

liftU2 :: (a -> a -> a) -> Vector d a -> Vector d a -> Vector d a

liftI2 :: (a -> b -> c) -> Vector d a -> Vector d b -> Vector d c

ImplicitArity d => Additive (VectorFamily d)

Defined in Data.Geometry.Vector.VectorFamilyPeano

Methods

zero :: Num a => VectorFamily d a

(^+^) :: Num a => VectorFamily d a -> VectorFamily d a -> VectorFamily d a

(^-^) :: Num a => VectorFamily d a -> VectorFamily d a -> VectorFamily d a

lerp :: Num a => a -> VectorFamily d a -> VectorFamily d a -> VectorFamily d a

liftU2 :: (a -> a -> a) -> VectorFamily d a -> VectorFamily d a -> VectorFamily d a

liftI2 :: (a -> b -> c) -> VectorFamily d a -> VectorFamily d b -> VectorFamily d c

Arity d => Additive (Vector d)

Defined in Data.Geometry.Vector.VectorFamily

Methods

zero :: Num a => Vector d a

(^+^) :: Num a => Vector d a -> Vector d a -> Vector d a

(^-^) :: Num a => Vector d a -> Vector d a -> Vector d a

lerp :: Num a => a -> Vector d a -> Vector d a -> Vector d a

liftU2 :: (a -> a -> a) -> Vector d a -> Vector d a -> Vector d a

liftI2 :: (a -> b -> c) -> Vector d a -> Vector d b -> Vector d c

Dim n => Additive (V n)

Defined in Linear.V

Methods

zero :: Num a => V n a

(^+^) :: Num a => V n a -> V n a -> V n a

(^-^) :: Num a => V n a -> V n a -> V n a

lerp :: Num a => a -> V n a -> V n a -> V n a

liftU2 :: (a -> a -> a) -> V n a -> V n a -> V n a

liftI2 :: (a -> b -> c) -> V n a -> V n b -> V n c

Additive ((->) b :: Type -> Type)

Defined in Linear.Vector

Methods

zero :: Num a => b -> a

(^+^) :: Num a => (b -> a) -> (b -> a) -> b -> a

(^-^) :: Num a => (b -> a) -> (b -> a) -> b -> a

lerp :: Num a => a -> (b -> a) -> (b -> a) -> b -> a

liftU2 :: (a -> a -> a) -> (b -> a) -> (b -> a) -> b -> a

liftI2 :: (a -> b0 -> c) -> (b -> a) -> (b -> b0) -> b -> c

(Additive f, Additive g) => Additive (Product f g)

Defined in Linear.Vector

Methods

zero :: Num a => Product f g a

(^+^) :: Num a => Product f g a -> Product f g a -> Product f g a

(^-^) :: Num a => Product f g a -> Product f g a -> Product f g a

lerp :: Num a => a -> Product f g a -> Product f g a -> Product f g a

liftU2 :: (a -> a -> a) -> Product f g a -> Product f g a -> Product f g a

liftI2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

(Additive f, Additive g) => Additive (Compose f g)

Defined in Linear.Vector

Methods

zero :: Num a => Compose f g a

(^+^) :: Num a => Compose f g a -> Compose f g a -> Compose f g a

(^-^) :: Num a => Compose f g a -> Compose f g a -> Compose f g a

lerp :: Num a => a -> Compose f g a -> Compose f g a -> Compose f g a

liftU2 :: (a -> a -> a) -> Compose f g a -> Compose f g a -> Compose f g a

liftI2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

data C (n :: Nat)

A proxy which can be used for the coordinates.

Constructors

C

Instances

Eq (C n)

Defined in Data.Geometry.Vector.VectorFixed

Methods

(==) :: C n -> C n -> Bool

(/=) :: C n -> C n -> Bool

Ord (C n)

Defined in Data.Geometry.Vector.VectorFixed

Methods

compare :: C n -> C n -> Ordering

(<) :: C n -> C n -> Bool

(<=) :: C n -> C n -> Bool

(>) :: C n -> C n -> Bool

(>=) :: C n -> C n -> Bool

max :: C n -> C n -> C n

min :: C n -> C n -> C n

Read (C n)

Defined in Data.Geometry.Vector.VectorFixed

Methods

readsPrec :: Int -> ReadS (C n)

readList :: ReadS [C n]

readPrec :: ReadPrec (C n)

readListPrec :: ReadPrec [C n]

Show (C n)

Defined in Data.Geometry.Vector.VectorFixed

Methods

showsPrec :: Int -> C n -> ShowS

show :: C n -> String

showList :: [C n] -> ShowS

class Additive (Diff p) => Affine (p :: Type -> Type) where

An affine space is roughly a vector space in which we have forgotten or at least pretend to have forgotten the origin.

a .+^ (b .-. a)  =  b@
(a .+^ u) .+^ v  =  a .+^ (u ^+^ v)@
(a .-. b) ^+^ v  =  (a .+^ v) .-. q@

Minimal complete definition

(.-.), (.+^)

Associated Types

type Diff (p :: Type -> Type) :: Type -> Type

Methods

(.-.) :: Num a => p a -> p a -> Diff p a infixl 6

Get the difference between two points as a vector offset.

(.+^) :: Num a => p a -> Diff p a -> p a infixl 6

Add a vector offset to a point.

(.-^) :: Num a => p a -> Diff p a -> p a infixl 6

Subtract a vector offset from a point.

Instances

Affine []

Defined in Linear.Affine

Associated Types

type Diff [] :: Type -> Type

Methods

(.-.) :: Num a => [a] -> [a] -> Diff [] a

(.+^) :: Num a => [a] -> Diff [] a -> [a]

(.-^) :: Num a => [a] -> Diff [] a -> [a]

Affine Maybe

Defined in Linear.Affine

Associated Types

type Diff Maybe :: Type -> Type

Methods

(.-.) :: Num a => Maybe a -> Maybe a -> Diff Maybe a

(.+^) :: Num a => Maybe a -> Diff Maybe a -> Maybe a

(.-^) :: Num a => Maybe a -> Diff Maybe a -> Maybe a

Affine Complex

Defined in Linear.Affine

Associated Types

type Diff Complex :: Type -> Type

Methods

(.-.) :: Num a => Complex a -> Complex a -> Diff Complex a

(.+^) :: Num a => Complex a -> Diff Complex a -> Complex a

(.-^) :: Num a => Complex a -> Diff Complex a -> Complex a

Affine ZipList

Defined in Linear.Affine

Associated Types

type Diff ZipList :: Type -> Type

Methods

(.-.) :: Num a => ZipList a -> ZipList a -> Diff ZipList a

(.+^) :: Num a => ZipList a -> Diff ZipList a -> ZipList a

(.-^) :: Num a => ZipList a -> Diff ZipList a -> ZipList a

Affine Identity

Defined in Linear.Affine

Associated Types

type Diff Identity :: Type -> Type

Methods

(.-.) :: Num a => Identity a -> Identity a -> Diff Identity a

(.+^) :: Num a => Identity a -> Diff Identity a -> Identity a

(.-^) :: Num a => Identity a -> Diff Identity a -> Identity a

Affine IntMap

Defined in Linear.Affine

Associated Types

type Diff IntMap :: Type -> Type

Methods

(.-.) :: Num a => IntMap a -> IntMap a -> Diff IntMap a

(.+^) :: Num a => IntMap a -> Diff IntMap a -> IntMap a

(.-^) :: Num a => IntMap a -> Diff IntMap a -> IntMap a

Affine Vector

Defined in Linear.Affine

Associated Types

type Diff Vector :: Type -> Type

Methods

(.-.) :: Num a => Vector a -> Vector a -> Diff Vector a

(.+^) :: Num a => Vector a -> Diff Vector a -> Vector a

(.-^) :: Num a => Vector a -> Diff Vector a -> Vector a

Affine Plucker

Defined in Linear.Affine

Associated Types

type Diff Plucker :: Type -> Type

Methods

(.-.) :: Num a => Plucker a -> Plucker a -> Diff Plucker a

(.+^) :: Num a => Plucker a -> Diff Plucker a -> Plucker a

(.-^) :: Num a => Plucker a -> Diff Plucker a -> Plucker a

Affine Quaternion

Defined in Linear.Affine

Associated Types

type Diff Quaternion :: Type -> Type

Methods

(.-.) :: Num a => Quaternion a -> Quaternion a -> Diff Quaternion a

(.+^) :: Num a => Quaternion a -> Diff Quaternion a -> Quaternion a

(.-^) :: Num a => Quaternion a -> Diff Quaternion a -> Quaternion a

Affine V0

Defined in Linear.Affine

Associated Types

type Diff V0 :: Type -> Type

Methods

(.-.) :: Num a => V0 a -> V0 a -> Diff V0 a

(.+^) :: Num a => V0 a -> Diff V0 a -> V0 a

(.-^) :: Num a => V0 a -> Diff V0 a -> V0 a

Affine V4

Defined in Linear.Affine

Associated Types

type Diff V4 :: Type -> Type

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

Affine V3

Defined in Linear.Affine

Associated Types

type Diff V3 :: Type -> Type

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

Affine V2

Defined in Linear.Affine

Associated Types

type Diff V2 :: Type -> Type

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

Affine V1

Defined in Linear.Affine

Associated Types

type Diff V1 :: Type -> Type

Methods

(.-.) :: Num a => V1 a -> V1 a -> Diff V1 a

(.+^) :: Num a => V1 a -> Diff V1 a -> V1 a

(.-^) :: Num a => V1 a -> Diff V1 a -> V1 a

(Eq k, Hashable k) => Affine (HashMap k)

Defined in Linear.Affine

Associated Types

type Diff (HashMap k) :: Type -> Type

Methods

(.-.) :: Num a => HashMap k a -> HashMap k a -> Diff (HashMap k) a

(.+^) :: Num a => HashMap k a -> Diff (HashMap k) a -> HashMap k a

(.-^) :: Num a => HashMap k a -> Diff (HashMap k) a -> HashMap k a

Ord k => Affine (Map k)

Defined in Linear.Affine

Associated Types

type Diff (Map k) :: Type -> Type

Methods

(.-.) :: Num a => Map k a -> Map k a -> Diff (Map k) a

(.+^) :: Num a => Map k a -> Diff (Map k) a -> Map k a

(.-^) :: Num a => Map k a -> Diff (Map k) a -> Map k a

Additive f => Affine (Point f)

Defined in Linear.Affine

Associated Types

type Diff (Point f) :: Type -> Type

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

Arity d => Affine (Vector d)

Defined in Data.Geometry.Vector.VectorFixed

Associated Types

type Diff (Vector d) :: Type -> Type

Methods

(.-.) :: Num a => Vector d a -> Vector d a -> Diff (Vector d) a

(.+^) :: Num a => Vector d a -> Diff (Vector d) a -> Vector d a

(.-^) :: Num a => Vector d a -> Diff (Vector d) a -> Vector d a

ImplicitArity d => Affine (VectorFamily d)

Defined in Data.Geometry.Vector.VectorFamilyPeano

Associated Types

type Diff (VectorFamily d) :: Type -> Type

Methods

(.-.) :: Num a => VectorFamily d a -> VectorFamily d a -> Diff (VectorFamily d) a

(.+^) :: Num a => VectorFamily d a -> Diff (VectorFamily d) a -> VectorFamily d a

(.-^) :: Num a => VectorFamily d a -> Diff (VectorFamily d) a -> VectorFamily d a

Arity d => Affine (Vector d)

Defined in Data.Geometry.Vector.VectorFamily

Associated Types

type Diff (Vector d) :: Type -> Type

Methods

(.-.) :: Num a => Vector d a -> Vector d a -> Diff (Vector d) a

(.+^) :: Num a => Vector d a -> Diff (Vector d) a -> Vector d a

(.-^) :: Num a => Vector d a -> Diff (Vector d) a -> Vector d a

Arity d => Affine (Point d)

Defined in Data.Geometry.Point.Internal

Associated Types

type Diff (Point d) :: Type -> Type

Methods

(.-.) :: Num a => Point d a -> Point d a -> Diff (Point d) a

(.+^) :: Num a => Point d a -> Diff (Point d) a -> Point d a

(.-^) :: Num a => Point d a -> Diff (Point d) a -> Point d a

Dim n => Affine (V n)

Defined in Linear.Affine

Associated Types

type Diff (V n) :: Type -> Type

Methods

(.-.) :: Num a => V n a -> V n a -> Diff (V n) a

(.+^) :: Num a => V n a -> Diff (V n) a -> V n a

(.-^) :: Num a => V n a -> Diff (V n) a -> V n a

Affine ((->) b :: Type -> Type)

Defined in Linear.Affine

Associated Types

type Diff ((->) b) :: Type -> Type

Methods

(.-.) :: Num a => (b -> a) -> (b -> a) -> Diff ((->) b) a

(.+^) :: Num a => (b -> a) -> Diff ((->) b) a -> b -> a

(.-^) :: Num a => (b -> a) -> Diff ((->) b) a -> b -> a

(Affine f, Affine g) => Affine (Product f g)

Defined in Linear.Affine

Associated Types

type Diff (Product f g) :: Type -> Type

Methods

(.-.) :: Num a => Product f g a -> Product f g a -> Diff (Product f g) a

(.+^) :: Num a => Product f g a -> Diff (Product f g) a -> Product f g a

(.-^) :: Num a => Product f g a -> Diff (Product f g) a -> Product f g a

quadrance :: (Metric f, Num a) => f a -> a

Compute the squared norm. The name quadrance arises from Norman J. Wildberger's rational trigonometry.

qdA :: (Affine p, Foldable (Diff p), Num a) => p a -> p a -> a

Compute the quadrance of the difference (the square of the distance)

distanceA :: (Floating a, Foldable (Diff p), Affine p) => p a -> p a -> a

Distance between two points in an affine space

dot :: (Metric f, Num a) => f a -> f a -> a

Compute the inner product of two vectors or (equivalently) convert a vector f a into a covector f a -> a.

>>> V2 1 2 `dot` V2 3 4
11

norm :: (Metric f, Floating a) => f a -> a

Compute the norm of a vector in a metric space

signorm :: (Metric f, Floating a) => f a -> f a

Convert a non-zero vector to unit vector.

isScalarMultipleOf :: (Eq r, Fractional r, Arity d) => Vector d r -> Vector d r -> Bool

'isScalarmultipleof u v' test if v is a scalar multiple of u.

>>> Vector2 1 1 `isScalarMultipleOf` Vector2 10 10
True
>>> Vector3 1 1 2 `isScalarMultipleOf` Vector3 10 10 20
True
>>> Vector2 1 1 `isScalarMultipleOf` Vector2 10 1
False
>>> Vector2 1 1 `isScalarMultipleOf` Vector2 (-1) (-1)
True
>>> Vector2 1 1 `isScalarMultipleOf` Vector2 11.1 11.1
True
>>> Vector2 1 1 `isScalarMultipleOf` Vector2 11.1 11.2
False
>>> Vector2 2 1 `isScalarMultipleOf` Vector2 11.1 11.2
False
>>> Vector2 2 1 `isScalarMultipleOf` Vector2 4 2
True
>>> Vector2 2 1 `isScalarMultipleOf` Vector2 4 0
False
>>> Vector3 2 1 0 `isScalarMultipleOf` Vector3 4 0 5
False
>>> Vector3 0 0 0 `isScalarMultipleOf` Vector3 4 0 5
True

scalarMultiple :: (Eq r, Fractional r, Arity d) => Vector d r -> Vector d r -> Maybe r

scalarMultiple u v computes the scalar labmda s.t. v = lambda * u (if it exists)

sameDirection :: (Eq r, Num r, Arity d) => Vector d r -> Vector d r -> Bool

Given two colinar vectors, u and v, test if they point in the same direction, i.e. iff scalarMultiple' u v == Just lambda, with lambda > 0

pre: u and v are colinear, u and v are non-zero

replicate :: Vector v a => a -> v a

Replicate value n times.

Examples:

>>> import Data.Vector.Fixed.Boxed (Vec2)
>>> replicate 1 :: Vec2 Int
fromList [1,1]

>>> replicate 2 :: (Double,Double,Double)
(2.0,2.0,2.0)

>>> import Data.Vector.Fixed.Boxed (Vec4)
>>> replicate "foo" :: Vec4 String
fromList ["foo","foo","foo","foo"]

xComponent :: (1 <= d, Arity d) => Lens' (Vector d r) r

Shorthand to access the first component

>>> Vector3 1 2 3 ^. xComponent
1
>>> Vector2 1 2 & xComponent .~ 10
Vector2 10 2

yComponent :: (2 <= d, Arity d) => Lens' (Vector d r) r

Shorthand to access the second component

>>> Vector3 1 2 3 ^. yComponent
2
>>> Vector2 1 2 & yComponent .~ 10
Vector2 1 10

zComponent :: (3 <= d, Arity d) => Lens' (Vector d r) r

Shorthand to access the third component

>>> Vector3 1 2 3 ^. zComponent
3
>>> Vector3 1 2 3 & zComponent .~ 10
Vector3 1 2 10

Orphan instances

Arity d => Arbitrary1 (Vector d)

Methods

liftArbitrary :: Gen a -> Gen (Vector d a)

liftShrink :: (a -> [a]) -> Vector d a -> [Vector d a]

(Random r, Arity d) => Random (Vector d r)

Methods

randomR :: RandomGen g => (Vector d r, Vector d r) -> g -> (Vector d r, g)

random :: RandomGen g => g -> (Vector d r, g)

randomRs :: RandomGen g => (Vector d r, Vector d r) -> g -> [Vector d r]

randoms :: RandomGen g => g -> [Vector d r]

(Arbitrary r, Arity d) => Arbitrary (Vector d r)

Methods

arbitrary :: Gen (Vector d r)

shrink :: Vector d r -> [Vector d r]