Safe Haskell	None
Language	Haskell2010

Data.Geometry.Vector

Synopsis

Documentation

module Data.Geometry.Vector.VectorFixed

class Additive (Diff p) => Affine p 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 :: * -> *) :: * -> * #

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 []
Associated Types type Diff ([] :: * -> ) :: -> * # Methods (.-.) :: Num a => [a] -> [a] -> Diff [] a # (.+^) :: Num a => [a] -> Diff [] a -> [a] # (.-^) :: Num a => [a] -> Diff [] a -> [a] #
Affine Maybe
Associated Types type Diff (Maybe :: * -> ) :: -> * # 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 Vector
Associated Types type Diff (Vector :: * -> ) :: -> * # 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 Identity
Associated Types type Diff (Identity :: * -> ) :: -> * # 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 Complex
Associated Types type Diff (Complex :: * -> ) :: -> * # 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
Associated Types type Diff (ZipList :: * -> ) :: -> * # 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 IntMap
Associated Types type Diff (IntMap :: * -> ) :: -> * # 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 Quaternion
Associated Types type Diff (Quaternion :: * -> ) :: -> * # 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 Plucker
Associated Types type Diff (Plucker :: * -> ) :: -> * # 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 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 #
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 #
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 #
Affine V1
Associated Types type Diff (V1 :: * -> ) :: -> * # 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 #
Affine V0
Associated Types type Diff (V0 :: * -> ) :: -> * # 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 ((->) b)
Associated Types type Diff ((->) b :: * -> ) :: -> * # 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 #
Ord k => Affine (Map k)
Associated Types type Diff (Map k :: * -> ) :: -> * # 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 #
(Eq k, Hashable k) => Affine (HashMap k)
Associated Types type Diff (HashMap k :: * -> ) :: -> * # 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 #
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 #
Arity d => Affine (Vector d) #
Associated Types type Diff (Vector d :: * -> ) :: -> * # 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) #
Associated Types type Diff (Point d :: * -> ) :: -> * # 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)
Associated Types type Diff (V * n :: * -> ) :: -> * # 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 #

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 => forall a. 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 => forall a. Floating a => f a -> a #

Compute the norm of a vector in a metric space

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

Test if v is a scalar multiple of u.

>>> v2 1 1 `isScalarMultipleOf` v2 10 10
True
>>> v2 1 1 `isScalarMultipleOf` v2 10 1
False
>>> v2 1 1 `isScalarMultipleOf` v2 11.1 11.1
True
>>> v2 1 1 `isScalarMultipleOf` v2 11.1 11.2
False
>>> v2 2 1 `isScalarMultipleOf` v2 11.1 11.2
False
>>> v2 2 1 `isScalarMultipleOf` v2 4 2
True
>>> v2 2 1 `isScalarMultipleOf` v2 4 0
False

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

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