Data.SG.Vector.Basic

Some types that are very basic vectors. Most of the use that can be made of the vectors is in their type-class instances, which support a powerful set of operations. For example:

fmap (*3) v -- Scales vector v by 3
pure 0 -- Creates a vector filled with zeroes
v + w -- Adds two vectors (there is a 'Num' instance, basically)

Plus all the instances for the classes in Data.SG.Vector, which allows you to use getX and so on.

You will probably want to create more friendly type synonyms, such as:

type Vector2 = Pair Double
type Vector3 = Triple Double
type Line2 = LinePair Double
type Line3 = LineTriple Double

Documentation

newtype Pair a

A pair, which acts as a 2D vector.

Constructors

Pair (a, a)

Instances

Functor Pair

Methods

fmap :: (a -> b) -> Pair a -> Pair b

(<$) :: a -> Pair b -> Pair a

Applicative Pair

Methods

pure :: a -> Pair a

(<*>) :: Pair (a -> b) -> Pair a -> Pair b

(*>) :: Pair a -> Pair b -> Pair b

(<*) :: Pair a -> Pair b -> Pair a

Foldable Pair

Methods

fold :: Monoid m => Pair m -> m

foldMap :: Monoid m => (a -> m) -> Pair a -> m

foldr :: (a -> b -> b) -> b -> Pair a -> b

foldr' :: (a -> b -> b) -> b -> Pair a -> b

foldl :: (b -> a -> b) -> b -> Pair a -> b

foldl' :: (b -> a -> b) -> b -> Pair a -> b

foldr1 :: (a -> a -> a) -> Pair a -> a

foldl1 :: (a -> a -> a) -> Pair a -> a

toList :: Pair a -> [a]

null :: Pair a -> Bool

length :: Pair a -> Int

elem :: Eq a => a -> Pair a -> Bool

maximum :: Ord a => Pair a -> a

minimum :: Ord a => Pair a -> a

sum :: Num a => Pair a -> a

product :: Num a => Pair a -> a

Traversable Pair

Methods

traverse :: Applicative f => (a -> f b) -> Pair a -> f (Pair b)

sequenceA :: Applicative f => Pair (f a) -> f (Pair a)

mapM :: Monad m => (a -> m b) -> Pair a -> m (Pair b)

sequence :: Monad m => Pair (m a) -> m (Pair a)

VectorNum Pair

Methods

fmapNum1 :: Num b => (a -> b) -> Pair a -> Pair b

fmapNum2 :: Num c => (a -> b -> c) -> Pair a -> Pair b -> Pair c

fmapNum1inv :: Num a => (a -> a) -> Pair a -> Pair a

simpleVec :: Num a => a -> Pair a

Coord2 Pair

Methods

getX :: Pair a -> a

getY :: Pair a -> a

Coord Pair

Methods

getComponents :: Num a => Pair a -> [a]

fromComponents :: Num a => [a] -> Pair a

magSq :: Num a => Pair a -> a

dotProduct :: Num a => Pair a -> Pair a -> a

IsomorphicVectors Pair Rel2'

Methods

iso :: Num a => Pair a -> Rel2' a

IsomorphicVectors Pair Point2'

Methods

iso :: Num a => Pair a -> Point2' a

IsomorphicVectors Rel2' Pair

Methods

iso :: Num a => Rel2' a -> Pair a

IsomorphicVectors Point2' Pair

Methods

iso :: Num a => Point2' a -> Pair a

Geometry Pair Pair LinePair

Methods

scaleRel :: Num a => a -> Pair a -> Pair a

plusDir :: (Num a, Eq a, Show a) => Pair a -> Pair a -> Pair a

fromPt :: (Num a, Eq a, Show a) => Pair a -> Pair a -> Pair a

getLineVecs :: Num a => LinePair a -> (Pair a, Pair a)

makeLine :: Num a => Pair a -> Pair a -> LinePair a

Eq a => Eq (Pair a)

Methods

(==) :: Pair a -> Pair a -> Bool

(/=) :: Pair a -> Pair a -> Bool

(Show a, Eq a, Num a) => Num (Pair a)

Methods

(+) :: Pair a -> Pair a -> Pair a

(-) :: Pair a -> Pair a -> Pair a

(*) :: Pair a -> Pair a -> Pair a

negate :: Pair a -> Pair a

abs :: Pair a -> Pair a

signum :: Pair a -> Pair a

fromInteger :: Integer -> Pair a

Ord a => Ord (Pair a)

Methods

compare :: Pair a -> Pair a -> Ordering

(<) :: Pair a -> Pair a -> Bool

(<=) :: Pair a -> Pair a -> Bool

(>) :: Pair a -> Pair a -> Bool

(>=) :: Pair a -> Pair a -> Bool

max :: Pair a -> Pair a -> Pair a

min :: Pair a -> Pair a -> Pair a

Read a => Read (Pair a)

Methods

readsPrec :: Int -> ReadS (Pair a)

readList :: ReadS [Pair a]

readPrec :: ReadPrec (Pair a)

readListPrec :: ReadPrec [Pair a]

Show a => Show (Pair a)

Methods

showsPrec :: Int -> Pair a -> ShowS

show :: Pair a -> String

showList :: [Pair a] -> ShowS

newtype Triple a

A triple, which acts as a 3D vector.

Constructors

Triple (a, a, a)

Instances

Functor Triple

Methods

fmap :: (a -> b) -> Triple a -> Triple b

(<$) :: a -> Triple b -> Triple a

Applicative Triple

Methods

pure :: a -> Triple a

(<*>) :: Triple (a -> b) -> Triple a -> Triple b

(*>) :: Triple a -> Triple b -> Triple b

(<*) :: Triple a -> Triple b -> Triple a

Foldable Triple

Methods

fold :: Monoid m => Triple m -> m

foldMap :: Monoid m => (a -> m) -> Triple a -> m

foldr :: (a -> b -> b) -> b -> Triple a -> b

foldr' :: (a -> b -> b) -> b -> Triple a -> b

foldl :: (b -> a -> b) -> b -> Triple a -> b

foldl' :: (b -> a -> b) -> b -> Triple a -> b

foldr1 :: (a -> a -> a) -> Triple a -> a

foldl1 :: (a -> a -> a) -> Triple a -> a

toList :: Triple a -> [a]

null :: Triple a -> Bool

length :: Triple a -> Int

elem :: Eq a => a -> Triple a -> Bool

maximum :: Ord a => Triple a -> a

minimum :: Ord a => Triple a -> a

sum :: Num a => Triple a -> a

product :: Num a => Triple a -> a

Traversable Triple

Methods

traverse :: Applicative f => (a -> f b) -> Triple a -> f (Triple b)

sequenceA :: Applicative f => Triple (f a) -> f (Triple a)

mapM :: Monad m => (a -> m b) -> Triple a -> m (Triple b)

sequence :: Monad m => Triple (m a) -> m (Triple a)

VectorNum Triple

Methods

fmapNum1 :: Num b => (a -> b) -> Triple a -> Triple b

fmapNum2 :: Num c => (a -> b -> c) -> Triple a -> Triple b -> Triple c

fmapNum1inv :: Num a => (a -> a) -> Triple a -> Triple a

simpleVec :: Num a => a -> Triple a

Coord3 Triple

Methods

getZ :: Triple a -> a

Coord2 Triple

Methods

getX :: Triple a -> a

getY :: Triple a -> a

Coord Triple

Methods

getComponents :: Num a => Triple a -> [a]

fromComponents :: Num a => [a] -> Triple a

magSq :: Num a => Triple a -> a

dotProduct :: Num a => Triple a -> Triple a -> a

IsomorphicVectors Triple Rel3'

Methods

iso :: Num a => Triple a -> Rel3' a

IsomorphicVectors Triple Point3'

Methods

iso :: Num a => Triple a -> Point3' a

IsomorphicVectors Rel3' Triple

Methods

iso :: Num a => Rel3' a -> Triple a

IsomorphicVectors Point3' Triple

Methods

iso :: Num a => Point3' a -> Triple a

Geometry Triple Triple LineTriple

Methods

scaleRel :: Num a => a -> Triple a -> Triple a

plusDir :: (Num a, Eq a, Show a) => Triple a -> Triple a -> Triple a

fromPt :: (Num a, Eq a, Show a) => Triple a -> Triple a -> Triple a

getLineVecs :: Num a => LineTriple a -> (Triple a, Triple a)

makeLine :: Num a => Triple a -> Triple a -> LineTriple a

Eq a => Eq (Triple a)

Methods

(==) :: Triple a -> Triple a -> Bool

(/=) :: Triple a -> Triple a -> Bool

(Show a, Eq a, Num a) => Num (Triple a)

Methods

(+) :: Triple a -> Triple a -> Triple a

(-) :: Triple a -> Triple a -> Triple a

(*) :: Triple a -> Triple a -> Triple a

negate :: Triple a -> Triple a

abs :: Triple a -> Triple a

signum :: Triple a -> Triple a

fromInteger :: Integer -> Triple a

Ord a => Ord (Triple a)

Methods

compare :: Triple a -> Triple a -> Ordering

(<) :: Triple a -> Triple a -> Bool

(<=) :: Triple a -> Triple a -> Bool

(>) :: Triple a -> Triple a -> Bool

(>=) :: Triple a -> Triple a -> Bool

max :: Triple a -> Triple a -> Triple a

min :: Triple a -> Triple a -> Triple a

Read a => Read (Triple a)

Methods

readsPrec :: Int -> ReadS (Triple a)

readList :: ReadS [Triple a]

readPrec :: ReadPrec (Triple a)

readListPrec :: ReadPrec [Triple a]

Show a => Show (Triple a)

Methods

showsPrec :: Int -> Triple a -> ShowS

show :: Triple a -> String

showList :: [Triple a] -> ShowS

newtype Quad a

A quad, which acts as a 4D vector.

Constructors

Quad (a, a, a, a)

Instances

Functor Quad

Methods

fmap :: (a -> b) -> Quad a -> Quad b

(<$) :: a -> Quad b -> Quad a

Applicative Quad

Methods

pure :: a -> Quad a

(<*>) :: Quad (a -> b) -> Quad a -> Quad b

(*>) :: Quad a -> Quad b -> Quad b

(<*) :: Quad a -> Quad b -> Quad a

Foldable Quad

Methods

fold :: Monoid m => Quad m -> m

foldMap :: Monoid m => (a -> m) -> Quad a -> m

foldr :: (a -> b -> b) -> b -> Quad a -> b

foldr' :: (a -> b -> b) -> b -> Quad a -> b

foldl :: (b -> a -> b) -> b -> Quad a -> b

foldl' :: (b -> a -> b) -> b -> Quad a -> b

foldr1 :: (a -> a -> a) -> Quad a -> a

foldl1 :: (a -> a -> a) -> Quad a -> a

toList :: Quad a -> [a]

null :: Quad a -> Bool

length :: Quad a -> Int

elem :: Eq a => a -> Quad a -> Bool

maximum :: Ord a => Quad a -> a

minimum :: Ord a => Quad a -> a

sum :: Num a => Quad a -> a

product :: Num a => Quad a -> a

Traversable Quad

Methods

traverse :: Applicative f => (a -> f b) -> Quad a -> f (Quad b)

sequenceA :: Applicative f => Quad (f a) -> f (Quad a)

mapM :: Monad m => (a -> m b) -> Quad a -> m (Quad b)

sequence :: Monad m => Quad (m a) -> m (Quad a)

VectorNum Quad

Methods

fmapNum1 :: Num b => (a -> b) -> Quad a -> Quad b

fmapNum2 :: Num c => (a -> b -> c) -> Quad a -> Quad b -> Quad c

fmapNum1inv :: Num a => (a -> a) -> Quad a -> Quad a

simpleVec :: Num a => a -> Quad a

Coord3 Quad

Methods

getZ :: Quad a -> a

Coord2 Quad

Methods

getX :: Quad a -> a

getY :: Quad a -> a

Coord Quad

Methods

getComponents :: Num a => Quad a -> [a]

fromComponents :: Num a => [a] -> Quad a

magSq :: Num a => Quad a -> a

dotProduct :: Num a => Quad a -> Quad a -> a

Eq a => Eq (Quad a)

Methods

(==) :: Quad a -> Quad a -> Bool

(/=) :: Quad a -> Quad a -> Bool

(Show a, Eq a, Num a) => Num (Quad a)

Methods

(+) :: Quad a -> Quad a -> Quad a

(-) :: Quad a -> Quad a -> Quad a

(*) :: Quad a -> Quad a -> Quad a

negate :: Quad a -> Quad a

abs :: Quad a -> Quad a

signum :: Quad a -> Quad a

fromInteger :: Integer -> Quad a

Ord a => Ord (Quad a)

Methods

compare :: Quad a -> Quad a -> Ordering

(<) :: Quad a -> Quad a -> Bool

(<=) :: Quad a -> Quad a -> Bool

(>) :: Quad a -> Quad a -> Bool

(>=) :: Quad a -> Quad a -> Bool

max :: Quad a -> Quad a -> Quad a

min :: Quad a -> Quad a -> Quad a

Read a => Read (Quad a)

Methods

readsPrec :: Int -> ReadS (Quad a)

readList :: ReadS [Quad a]

readPrec :: ReadPrec (Quad a)

readListPrec :: ReadPrec [Quad a]

Show a => Show (Quad a)

Methods

showsPrec :: Int -> Quad a -> ShowS

show :: Quad a -> String

showList :: [Quad a] -> ShowS

newtype LinePair a

A pair of (position vector, direction vector) to be used as a 2D line.

Constructors

LinePair (Pair a, Pair a)

Instances

Geometry Pair Pair LinePair

Methods

scaleRel :: Num a => a -> Pair a -> Pair a

plusDir :: (Num a, Eq a, Show a) => Pair a -> Pair a -> Pair a

fromPt :: (Num a, Eq a, Show a) => Pair a -> Pair a -> Pair a

getLineVecs :: Num a => LinePair a -> (Pair a, Pair a)

makeLine :: Num a => Pair a -> Pair a -> LinePair a

Eq a => Eq (LinePair a)

Methods

(==) :: LinePair a -> LinePair a -> Bool

(/=) :: LinePair a -> LinePair a -> Bool

Ord a => Ord (LinePair a)

Methods

compare :: LinePair a -> LinePair a -> Ordering

(<) :: LinePair a -> LinePair a -> Bool

(<=) :: LinePair a -> LinePair a -> Bool

(>) :: LinePair a -> LinePair a -> Bool

(>=) :: LinePair a -> LinePair a -> Bool

max :: LinePair a -> LinePair a -> LinePair a

min :: LinePair a -> LinePair a -> LinePair a

Read a => Read (LinePair a)

Methods

readsPrec :: Int -> ReadS (LinePair a)

readList :: ReadS [LinePair a]

readPrec :: ReadPrec (LinePair a)

readListPrec :: ReadPrec [LinePair a]

Show a => Show (LinePair a)

Methods

showsPrec :: Int -> LinePair a -> ShowS

show :: LinePair a -> String

showList :: [LinePair a] -> ShowS

newtype LineTriple a

A pair of (position vector, direction vector) to be used as a 3D line.

Constructors

LineTriple (Triple a, Triple a)

Instances

Geometry Triple Triple LineTriple

Methods

scaleRel :: Num a => a -> Triple a -> Triple a

plusDir :: (Num a, Eq a, Show a) => Triple a -> Triple a -> Triple a

fromPt :: (Num a, Eq a, Show a) => Triple a -> Triple a -> Triple a

getLineVecs :: Num a => LineTriple a -> (Triple a, Triple a)

makeLine :: Num a => Triple a -> Triple a -> LineTriple a

Eq a => Eq (LineTriple a)

Methods

(==) :: LineTriple a -> LineTriple a -> Bool

(/=) :: LineTriple a -> LineTriple a -> Bool

Ord a => Ord (LineTriple a)

Methods

compare :: LineTriple a -> LineTriple a -> Ordering

(<) :: LineTriple a -> LineTriple a -> Bool

(<=) :: LineTriple a -> LineTriple a -> Bool

(>) :: LineTriple a -> LineTriple a -> Bool

(>=) :: LineTriple a -> LineTriple a -> Bool

max :: LineTriple a -> LineTriple a -> LineTriple a

min :: LineTriple a -> LineTriple a -> LineTriple a

Read a => Read (LineTriple a)

Methods

readsPrec :: Int -> ReadS (LineTriple a)

readList :: ReadS [LineTriple a]

readPrec :: ReadPrec (LineTriple a)

readListPrec :: ReadPrec [LineTriple a]

Show a => Show (LineTriple a)

Methods

showsPrec :: Int -> LineTriple a -> ShowS

show :: LineTriple a -> String

showList :: [LineTriple a] -> ShowS