Safe Haskell	None
Language	Haskell2010

Graphics.Rasterific.Linear

Description

This module is a reduction of the Linear package from Edward Kmett to match just the need of Rasterific.

If the flag embed_linear is disabled, this module is just a reexport from the real linear package.

Synopsis

Documentation

newtype V1 a #

A 1-dimensional vector

Constructors

V1 a

Instances

Functor V1 #
Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Applicative V1 #
Methods pure :: a -> V1 a # (<>) :: V1 (a -> b) -> V1 a -> V1 b # (>) :: V1 a -> V1 b -> V1 b # (<*) :: V1 a -> V1 b -> V1 a #
Foldable V1 #
Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] # null :: V1 a -> Bool # length :: V1 a -> Int # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # minimum :: Ord a => V1 a -> a # sum :: Num a => V1 a -> a # product :: Num a => V1 a -> a #
Traversable V1 #
Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) # sequence :: Monad m => V1 (m a) -> m (V1 a) #
Additive 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 #
R1 V1 #
Methods _x :: Functor f => (a -> f a) -> V1 a -> f (V1 a) #
Eq a => Eq (V1 a) #
Methods (==) :: V1 a -> V1 a -> Bool # (/=) :: V1 a -> V1 a -> Bool #
Num a => Num (V1 a) #
Methods (+) :: V1 a -> V1 a -> V1 a # (-) :: V1 a -> V1 a -> V1 a # (*) :: V1 a -> V1 a -> V1 a # negate :: V1 a -> V1 a # abs :: V1 a -> V1 a # signum :: V1 a -> V1 a # fromInteger :: Integer -> V1 a #
Show a => Show (V1 a) #
Methods showsPrec :: Int -> V1 a -> ShowS # show :: V1 a -> String # showList :: [V1 a] -> ShowS #
Epsilon a => Epsilon (V1 a) #
Methods nearZero :: V1 a -> Bool #

data V2 a #

A 2-dimensional vector

>>> pure 1 :: V2 Int
V2 1 1

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

>>> V2 1 2 * V2 3 4
V2 3 8

>>> sum (V2 1 2)
3

Constructors

V2 !a !a

Instances

Functor V2 #
Methods fmap :: (a -> b) -> V2 a -> V2 b # (<$) :: a -> V2 b -> V2 a #
Applicative V2 #
Methods pure :: a -> V2 a # (<>) :: V2 (a -> b) -> V2 a -> V2 b # (>) :: V2 a -> V2 b -> V2 b # (<*) :: V2 a -> V2 b -> V2 a #
Foldable V2 #
Methods fold :: Monoid m => V2 m -> m # foldMap :: Monoid m => (a -> m) -> V2 a -> m # foldr :: (a -> b -> b) -> b -> V2 a -> b # foldr' :: (a -> b -> b) -> b -> V2 a -> b # foldl :: (b -> a -> b) -> b -> V2 a -> b # foldl' :: (b -> a -> b) -> b -> V2 a -> b # foldr1 :: (a -> a -> a) -> V2 a -> a # foldl1 :: (a -> a -> a) -> V2 a -> a # toList :: V2 a -> [a] # null :: V2 a -> Bool # length :: V2 a -> Int # elem :: Eq a => a -> V2 a -> Bool # maximum :: Ord a => V2 a -> a # minimum :: Ord a => V2 a -> a # sum :: Num a => V2 a -> a # product :: Num a => V2 a -> a #
Traversable V2 #
Methods traverse :: Applicative f => (a -> f b) -> V2 a -> f (V2 b) # sequenceA :: Applicative f => V2 (f a) -> f (V2 a) # mapM :: Monad m => (a -> m b) -> V2 a -> m (V2 b) # sequence :: Monad m => V2 (m a) -> m (V2 a) #
Metric V2 #
Methods dot :: Num a => V2 a -> V2 a -> a # quadrance :: Num a => V2 a -> a # qd :: Num a => V2 a -> V2 a -> a # distance :: Floating a => V2 a -> V2 a -> a # norm :: Floating a => V2 a -> a # signorm :: Floating a => V2 a -> V2 a #
Additive 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 #
R2 V2 #
Methods _y :: Functor f => (a -> f a) -> V2 a -> f (V2 a) #
R1 V2 #
Methods _x :: Functor f => (a -> f a) -> V2 a -> f (V2 a) #
PointFoldable Point #	Just apply the function
Methods foldPoints :: (b -> Point -> b) -> b -> Point -> b #
Transformable Point #	Just apply the function
Methods transform :: (Point -> Point) -> Point -> Point # transformM :: Monad m => (Point -> m Point) -> Point -> m Point #
PlaneBoundable Point #
Methods planeBounds :: Point -> PlaneBound #
Eq a => Eq (V2 a) #
Methods (==) :: V2 a -> V2 a -> Bool # (/=) :: V2 a -> V2 a -> Bool #
Num a => Num (V2 a) #
Methods (+) :: V2 a -> V2 a -> V2 a # (-) :: V2 a -> V2 a -> V2 a # (*) :: V2 a -> V2 a -> V2 a # negate :: V2 a -> V2 a # abs :: V2 a -> V2 a # signum :: V2 a -> V2 a # fromInteger :: Integer -> V2 a #
Show a => Show (V2 a) #
Methods showsPrec :: Int -> V2 a -> ShowS # show :: V2 a -> String # showList :: [V2 a] -> ShowS #
Epsilon a => Epsilon (V2 a) #
Methods nearZero :: V2 a -> Bool #

data V3 a #

A 3-dimensional vector

Constructors

V3 !a !a !a

Instances

Functor V3 #
Methods fmap :: (a -> b) -> V3 a -> V3 b # (<$) :: a -> V3 b -> V3 a #
Applicative V3 #
Methods pure :: a -> V3 a # (<>) :: V3 (a -> b) -> V3 a -> V3 b # (>) :: V3 a -> V3 b -> V3 b # (<*) :: V3 a -> V3 b -> V3 a #
Foldable V3 #
Methods fold :: Monoid m => V3 m -> m # foldMap :: Monoid m => (a -> m) -> V3 a -> m # foldr :: (a -> b -> b) -> b -> V3 a -> b # foldr' :: (a -> b -> b) -> b -> V3 a -> b # foldl :: (b -> a -> b) -> b -> V3 a -> b # foldl' :: (b -> a -> b) -> b -> V3 a -> b # foldr1 :: (a -> a -> a) -> V3 a -> a # foldl1 :: (a -> a -> a) -> V3 a -> a # toList :: V3 a -> [a] # null :: V3 a -> Bool # length :: V3 a -> Int # elem :: Eq a => a -> V3 a -> Bool # maximum :: Ord a => V3 a -> a # minimum :: Ord a => V3 a -> a # sum :: Num a => V3 a -> a # product :: Num a => V3 a -> a #
Traversable V3 #
Methods traverse :: Applicative f => (a -> f b) -> V3 a -> f (V3 b) # sequenceA :: Applicative f => V3 (f a) -> f (V3 a) # mapM :: Monad m => (a -> m b) -> V3 a -> m (V3 b) # sequence :: Monad m => V3 (m a) -> m (V3 a) #
Metric V3 #
Methods dot :: Num a => V3 a -> V3 a -> a # quadrance :: Num a => V3 a -> a # qd :: Num a => V3 a -> V3 a -> a # distance :: Floating a => V3 a -> V3 a -> a # norm :: Floating a => V3 a -> a # signorm :: Floating a => V3 a -> V3 a #
Additive 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 #
R2 V3 #
Methods _y :: Functor f => (a -> f a) -> V3 a -> f (V3 a) #
R1 V3 #
Methods _x :: Functor f => (a -> f a) -> V3 a -> f (V3 a) #
Eq a => Eq (V3 a) #
Methods (==) :: V3 a -> V3 a -> Bool # (/=) :: V3 a -> V3 a -> Bool #
Num a => Num (V3 a) #
Methods (+) :: V3 a -> V3 a -> V3 a # (-) :: V3 a -> V3 a -> V3 a # (*) :: V3 a -> V3 a -> V3 a # negate :: V3 a -> V3 a # abs :: V3 a -> V3 a # signum :: V3 a -> V3 a # fromInteger :: Integer -> V3 a #
Show a => Show (V3 a) #
Methods showsPrec :: Int -> V3 a -> ShowS # show :: V3 a -> String # showList :: [V3 a] -> ShowS #
Epsilon a => Epsilon (V3 a) #
Methods nearZero :: V3 a -> Bool #

data V4 a #

A 4-dimensional vector

Constructors

V4 !a !a !a !a

Instances

Functor V4 #
Methods fmap :: (a -> b) -> V4 a -> V4 b # (<$) :: a -> V4 b -> V4 a #
Applicative V4 #
Methods pure :: a -> V4 a # (<>) :: V4 (a -> b) -> V4 a -> V4 b # (>) :: V4 a -> V4 b -> V4 b # (<*) :: V4 a -> V4 b -> V4 a #
Foldable V4 #
Methods fold :: Monoid m => V4 m -> m # foldMap :: Monoid m => (a -> m) -> V4 a -> m # foldr :: (a -> b -> b) -> b -> V4 a -> b # foldr' :: (a -> b -> b) -> b -> V4 a -> b # foldl :: (b -> a -> b) -> b -> V4 a -> b # foldl' :: (b -> a -> b) -> b -> V4 a -> b # foldr1 :: (a -> a -> a) -> V4 a -> a # foldl1 :: (a -> a -> a) -> V4 a -> a # toList :: V4 a -> [a] # null :: V4 a -> Bool # length :: V4 a -> Int # elem :: Eq a => a -> V4 a -> Bool # maximum :: Ord a => V4 a -> a # minimum :: Ord a => V4 a -> a # sum :: Num a => V4 a -> a # product :: Num a => V4 a -> a #
Traversable V4 #
Methods traverse :: Applicative f => (a -> f b) -> V4 a -> f (V4 b) # sequenceA :: Applicative f => V4 (f a) -> f (V4 a) # mapM :: Monad m => (a -> m b) -> V4 a -> m (V4 b) # sequence :: Monad m => V4 (m a) -> m (V4 a) #
Metric V4 #
Methods dot :: Num a => V4 a -> V4 a -> a # quadrance :: Num a => V4 a -> a # qd :: Num a => V4 a -> V4 a -> a # distance :: Floating a => V4 a -> V4 a -> a # norm :: Floating a => V4 a -> a # signorm :: Floating a => V4 a -> V4 a #
Additive 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 #
R2 V4 #
Methods _y :: Functor f => (a -> f a) -> V4 a -> f (V4 a) #
R1 V4 #
Methods _x :: Functor f => (a -> f a) -> V4 a -> f (V4 a) #
Eq a => Eq (V4 a) #
Methods (==) :: V4 a -> V4 a -> Bool # (/=) :: V4 a -> V4 a -> Bool #
Num a => Num (V4 a) #
Methods (+) :: V4 a -> V4 a -> V4 a # (-) :: V4 a -> V4 a -> V4 a # (*) :: V4 a -> V4 a -> V4 a # negate :: V4 a -> V4 a # abs :: V4 a -> V4 a # signum :: V4 a -> V4 a # fromInteger :: Integer -> V4 a #
Show a => Show (V4 a) #
Methods showsPrec :: Int -> V4 a -> ShowS # show :: V4 a -> String # showList :: [V4 a] -> ShowS #
Epsilon a => Epsilon (V4 a) #
Methods nearZero :: V4 a -> Bool #

class R1 t where #

Methods

_x :: Lens' (t a) a #

Instances

R1 V1 #
Methods _x :: Functor f => (a -> f a) -> V1 a -> f (V1 a) #
R1 V4 #
Methods _x :: Functor f => (a -> f a) -> V4 a -> f (V4 a) #
R1 V3 #
Methods _x :: Functor f => (a -> f a) -> V3 a -> f (V3 a) #
R1 V2 #
Methods _x :: Functor f => (a -> f a) -> V2 a -> f (V2 a) #

class R2 t where #

Methods

_y :: Lens' (t a) a #

Instances

R2 V4 #
Methods _y :: Functor f => (a -> f a) -> V4 a -> f (V4 a) #
R2 V3 #
Methods _y :: Functor f => (a -> f a) -> V3 a -> f (V3 a) #
R2 V2 #
Methods _y :: Functor f => (a -> f a) -> V2 a -> f (V2 a) #

class Functor f => Additive f where #

A vector is an additive group with additional structure.

Minimal complete definition

zero, (^+^), (^-^), lerp

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.

Instances

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

class Num a => Epsilon a where #

Provides a fairly subjective test to see if a quantity is near zero.

>>> nearZero (1e-11 :: Double)
False

>>> nearZero (1e-17 :: Double)
True

>>> nearZero (1e-5 :: Float)
False

>>> nearZero (1e-7 :: Float)
True

Minimal complete definition

nearZero

Methods

nearZero :: a -> Bool #

Determine if a quantity is near zero.

Instances

Epsilon Double #	`abs` a `<=` 1e-12
Methods nearZero :: Double -> Bool #
Epsilon Float #	`abs` a `<=` 1e-6
Methods nearZero :: Float -> Bool #
Epsilon a => Epsilon (V1 a) #
Methods nearZero :: V1 a -> Bool #
Epsilon a => Epsilon (V4 a) #
Methods nearZero :: V4 a -> Bool #
Epsilon a => Epsilon (V3 a) #
Methods nearZero :: V3 a -> Bool #
Epsilon a => Epsilon (V2 a) #
Methods nearZero :: V2 a -> Bool #

class Additive f => Metric f where #

Free and sparse inner product/metric spaces.

Minimal complete definition

dot

Methods

dot :: 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

quadrance :: Num a => f a -> a #

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

qd :: Num a => f a -> f a -> a #

Compute the quadrance of the difference

distance :: Floating a => f a -> f a -> a #

Compute the distance between two vectors in a metric space

norm :: Floating a => f a -> a #

Compute the norm of a vector in a metric space

signorm :: Floating a => f a -> f a #

Convert a non-zero vector to unit vector.

Instances

Metric V4 #
Methods dot :: Num a => V4 a -> V4 a -> a # quadrance :: Num a => V4 a -> a # qd :: Num a => V4 a -> V4 a -> a # distance :: Floating a => V4 a -> V4 a -> a # norm :: Floating a => V4 a -> a # signorm :: Floating a => V4 a -> V4 a #
Metric V3 #
Methods dot :: Num a => V3 a -> V3 a -> a # quadrance :: Num a => V3 a -> a # qd :: Num a => V3 a -> V3 a -> a # distance :: Floating a => V3 a -> V3 a -> a # norm :: Floating a => V3 a -> a # signorm :: Floating a => V3 a -> V3 a #
Metric V2 #
Methods dot :: Num a => V2 a -> V2 a -> a # quadrance :: Num a => V2 a -> a # qd :: Num a => V2 a -> V2 a -> a # distance :: Floating a => V2 a -> V2 a -> a # norm :: Floating a => V2 a -> a # signorm :: Floating a => V2 a -> V2 a #

(^*) :: (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, Floating a) => f a -> a -> f a infixl 7 #

Compute division by a scalar on the right.

normalize :: (Floating a, Metric f, Epsilon a) => f a -> f a #

Normalize a Metric functor to have unit norm. This function does not change the functor if its norm is 0 or 1.