Data.Geometry.Vector

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

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

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