hgeometry-0.11.0.0: Geometric Algorithms, Data structures, and Data types.

Data.Geometry.Vector

Contents

Description

$$d$$-dimensional vectors.

Synopsis

# Documentation

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 #

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 [] Instance detailsDefined in Linear.Vector Methodszero :: 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] # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Vector Methodszero :: 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 # Instance detailsDefined in Linear.Plucker Methodszero :: 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 # Instance detailsDefined in Linear.Quaternion Methodszero :: 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 # Instance detailsDefined in Linear.V0 Methodszero :: 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 # Instance detailsDefined in Linear.V4 Methodszero :: 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 # Instance detailsDefined in Linear.V3 Methodszero :: 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 # Instance detailsDefined in Linear.V2 Methodszero :: 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 # Instance detailsDefined in Linear.V1 Methodszero :: 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) Instance detailsDefined in Linear.Vector Methodszero :: 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) Instance detailsDefined in Linear.Vector Methodszero :: 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) Instance detailsDefined in Linear.Affine Methodszero :: 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) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed Methodszero :: 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 # Source # Instance detailsDefined in Data.Geometry.Vector.VectorFamilyPeano Methodszero :: 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) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFamily Methodszero :: 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) Instance detailsDefined in Linear.V Methodszero :: 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) Instance detailsDefined in Linear.Vector Methodszero :: 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) Instance detailsDefined in Linear.Vector Methodszero :: 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) Instance detailsDefined in Linear.Vector Methodszero :: 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) Source #

A proxy which can be used for the coordinates.

Constructors

 C
Instances
 Eq (C n) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed Methods(==) :: C n -> C n -> Bool #(/=) :: C n -> C n -> Bool # Ord (C n) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed Methodscompare :: 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) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed MethodsreadsPrec :: Int -> ReadS (C n) #readList :: ReadS [C n] #readPrec :: ReadPrec (C n) # Show (C n) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed MethodsshowsPrec :: 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 [] Instance detailsDefined in Linear.Affine Associated Typestype Diff [] :: Type -> Type # Methods(.-.) :: Num a => [a] -> [a] -> Diff [] a #(.+^) :: Num a => [a] -> Diff [] a -> [a] #(.-^) :: Num a => [a] -> Diff [] a -> [a] # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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 # Instance detailsDefined in Linear.Affine Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFixed Associated Typestype 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 # Source # Instance detailsDefined in Data.Geometry.Vector.VectorFamilyPeano Associated Typestype 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) Source # Instance detailsDefined in Data.Geometry.Vector.VectorFamily Associated Typestype 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) Source # Instance detailsDefined in Data.Geometry.Point.Internal Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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) Instance detailsDefined in Linear.Affine Associated Typestype 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 Source #

'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 Source #

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

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 Source #

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

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

# Orphan instances

 (Random r, Arity d) => Random (Vector d r) Source # Instance details MethodsrandomR :: 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) Source # Instance details Methodsarbitrary :: Gen (Vector d r) #shrink :: Vector d r -> [Vector d r] #