{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleInstances, DeriveTraversable, FunctionalDependencies #-}

-- | Basic 2 dimensional geometry functions.
module Geom2D (
  module Data.VectorSpace,
  module Data.Cross,
  module Geom2D ) where
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Unboxed as V
import Data.VectorSpace
import Data.Cross
import Control.Monad
import Numeric.FastMath

infixr 5 $*

data Point a = Point {
  forall a. Point a -> a
pointX :: !a,
  forall a. Point a -> a
pointY :: !a
  } deriving (Point a -> Point a -> Bool
forall a. Eq a => Point a -> Point a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Point a -> Point a -> Bool
$c/= :: forall a. Eq a => Point a -> Point a -> Bool
== :: Point a -> Point a -> Bool
$c== :: forall a. Eq a => Point a -> Point a -> Bool
Eq, Point a -> Point a -> Bool
Point a -> Point a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Point a)
forall a. Ord a => Point a -> Point a -> Bool
forall a. Ord a => Point a -> Point a -> Ordering
forall a. Ord a => Point a -> Point a -> Point a
min :: Point a -> Point a -> Point a
$cmin :: forall a. Ord a => Point a -> Point a -> Point a
max :: Point a -> Point a -> Point a
$cmax :: forall a. Ord a => Point a -> Point a -> Point a
>= :: Point a -> Point a -> Bool
$c>= :: forall a. Ord a => Point a -> Point a -> Bool
> :: Point a -> Point a -> Bool
$c> :: forall a. Ord a => Point a -> Point a -> Bool
<= :: Point a -> Point a -> Bool
$c<= :: forall a. Ord a => Point a -> Point a -> Bool
< :: Point a -> Point a -> Bool
$c< :: forall a. Ord a => Point a -> Point a -> Bool
compare :: Point a -> Point a -> Ordering
$ccompare :: forall a. Ord a => Point a -> Point a -> Ordering
Ord, forall a b. a -> Point b -> Point a
forall a b. (a -> b) -> Point a -> Point b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Point b -> Point a
$c<$ :: forall a b. a -> Point b -> Point a
fmap :: forall a b. (a -> b) -> Point a -> Point b
$cfmap :: forall a b. (a -> b) -> Point a -> Point b
Functor, forall a. Eq a => a -> Point a -> Bool
forall a. Num a => Point a -> a
forall a. Ord a => Point a -> a
forall m. Monoid m => Point m -> m
forall a. Point a -> Bool
forall a. Point a -> Int
forall a. Point a -> [a]
forall a. (a -> a -> a) -> Point a -> a
forall m a. Monoid m => (a -> m) -> Point a -> m
forall b a. (b -> a -> b) -> b -> Point a -> b
forall a b. (a -> b -> b) -> b -> Point a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Point a -> a
$cproduct :: forall a. Num a => Point a -> a
sum :: forall a. Num a => Point a -> a
$csum :: forall a. Num a => Point a -> a
minimum :: forall a. Ord a => Point a -> a
$cminimum :: forall a. Ord a => Point a -> a
maximum :: forall a. Ord a => Point a -> a
$cmaximum :: forall a. Ord a => Point a -> a
elem :: forall a. Eq a => a -> Point a -> Bool
$celem :: forall a. Eq a => a -> Point a -> Bool
length :: forall a. Point a -> Int
$clength :: forall a. Point a -> Int
null :: forall a. Point a -> Bool
$cnull :: forall a. Point a -> Bool
toList :: forall a. Point a -> [a]
$ctoList :: forall a. Point a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Point a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Point a -> a
foldr1 :: forall a. (a -> a -> a) -> Point a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Point a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Point a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Point a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Point a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Point a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Point a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Point a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Point a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Point a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Point a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Point a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Point a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Point a -> m
fold :: forall m. Monoid m => Point m -> m
$cfold :: forall m. Monoid m => Point m -> m
Foldable, Functor Point
Foldable Point
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Point (m a) -> m (Point a)
forall (f :: * -> *) a. Applicative f => Point (f a) -> f (Point a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Point a -> m (Point b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Point a -> f (Point b)
sequence :: forall (m :: * -> *) a. Monad m => Point (m a) -> m (Point a)
$csequence :: forall (m :: * -> *) a. Monad m => Point (m a) -> m (Point a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Point a -> m (Point b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Point a -> m (Point b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Point (f a) -> f (Point a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Point (f a) -> f (Point a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Point a -> f (Point b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Point a -> f (Point b)
Traversable)

type DPoint = Point Double

instance Show a => Show (Point a) where
  show :: Point a -> String
show (Point a
x a
y) =
    String
"Point " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
x forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
y

-- | A transformation (x, y) -> (ax + by + c, dx + ey + d)
data Transform a = Transform {
  forall a. Transform a -> a
xformA :: !a,
  forall a. Transform a -> a
xformB :: !a,
  forall a. Transform a -> a
xformC :: !a,
  forall a. Transform a -> a
xformD :: !a,
  forall a. Transform a -> a
xformE :: !a,
  forall a. Transform a -> a
xformF :: !a }
  deriving (Transform a -> Transform a -> Bool
forall a. Eq a => Transform a -> Transform a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Transform a -> Transform a -> Bool
$c/= :: forall a. Eq a => Transform a -> Transform a -> Bool
== :: Transform a -> Transform a -> Bool
$c== :: forall a. Eq a => Transform a -> Transform a -> Bool
Eq, Int -> Transform a -> ShowS
forall a. Show a => Int -> Transform a -> ShowS
forall a. Show a => [Transform a] -> ShowS
forall a. Show a => Transform a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Transform a] -> ShowS
$cshowList :: forall a. Show a => [Transform a] -> ShowS
show :: Transform a -> String
$cshow :: forall a. Show a => Transform a -> String
showsPrec :: Int -> Transform a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Transform a -> ShowS
Show, forall a b. a -> Transform b -> Transform a
forall a b. (a -> b) -> Transform a -> Transform b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Transform b -> Transform a
$c<$ :: forall a b. a -> Transform b -> Transform a
fmap :: forall a b. (a -> b) -> Transform a -> Transform b
$cfmap :: forall a b. (a -> b) -> Transform a -> Transform b
Functor, forall a. Eq a => a -> Transform a -> Bool
forall a. Num a => Transform a -> a
forall a. Ord a => Transform a -> a
forall m. Monoid m => Transform m -> m
forall a. Transform a -> Bool
forall a. Transform a -> Int
forall a. Transform a -> [a]
forall a. (a -> a -> a) -> Transform a -> a
forall m a. Monoid m => (a -> m) -> Transform a -> m
forall b a. (b -> a -> b) -> b -> Transform a -> b
forall a b. (a -> b -> b) -> b -> Transform a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Transform a -> a
$cproduct :: forall a. Num a => Transform a -> a
sum :: forall a. Num a => Transform a -> a
$csum :: forall a. Num a => Transform a -> a
minimum :: forall a. Ord a => Transform a -> a
$cminimum :: forall a. Ord a => Transform a -> a
maximum :: forall a. Ord a => Transform a -> a
$cmaximum :: forall a. Ord a => Transform a -> a
elem :: forall a. Eq a => a -> Transform a -> Bool
$celem :: forall a. Eq a => a -> Transform a -> Bool
length :: forall a. Transform a -> Int
$clength :: forall a. Transform a -> Int
null :: forall a. Transform a -> Bool
$cnull :: forall a. Transform a -> Bool
toList :: forall a. Transform a -> [a]
$ctoList :: forall a. Transform a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Transform a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Transform a -> a
foldr1 :: forall a. (a -> a -> a) -> Transform a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Transform a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Transform a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Transform a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Transform a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Transform a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Transform a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Transform a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Transform a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Transform a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Transform a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Transform a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Transform a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Transform a -> m
fold :: forall m. Monoid m => Transform m -> m
$cfold :: forall m. Monoid m => Transform m -> m
Foldable, Functor Transform
Foldable Transform
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Transform (m a) -> m (Transform a)
forall (f :: * -> *) a.
Applicative f =>
Transform (f a) -> f (Transform a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Transform a -> m (Transform b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Transform a -> f (Transform b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Transform (m a) -> m (Transform a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Transform (m a) -> m (Transform a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Transform a -> m (Transform b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Transform a -> m (Transform b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Transform (f a) -> f (Transform a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Transform (f a) -> f (Transform a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Transform a -> f (Transform b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Transform a -> f (Transform b)
Traversable)

data Line a = Line (Point a) (Point a)
            deriving (Int -> Line a -> ShowS
forall a. Show a => Int -> Line a -> ShowS
forall a. Show a => [Line a] -> ShowS
forall a. Show a => Line a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Line a] -> ShowS
$cshowList :: forall a. Show a => [Line a] -> ShowS
show :: Line a -> String
$cshow :: forall a. Show a => Line a -> String
showsPrec :: Int -> Line a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Line a -> ShowS
Show, Line a -> Line a -> Bool
forall a. Eq a => Line a -> Line a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Line a -> Line a -> Bool
$c/= :: forall a. Eq a => Line a -> Line a -> Bool
== :: Line a -> Line a -> Bool
$c== :: forall a. Eq a => Line a -> Line a -> Bool
Eq, forall a b. a -> Line b -> Line a
forall a b. (a -> b) -> Line a -> Line b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Line b -> Line a
$c<$ :: forall a b. a -> Line b -> Line a
fmap :: forall a b. (a -> b) -> Line a -> Line b
$cfmap :: forall a b. (a -> b) -> Line a -> Line b
Functor, forall a. Eq a => a -> Line a -> Bool
forall a. Num a => Line a -> a
forall a. Ord a => Line a -> a
forall m. Monoid m => Line m -> m
forall a. Line a -> Bool
forall a. Line a -> Int
forall a. Line a -> [a]
forall a. (a -> a -> a) -> Line a -> a
forall m a. Monoid m => (a -> m) -> Line a -> m
forall b a. (b -> a -> b) -> b -> Line a -> b
forall a b. (a -> b -> b) -> b -> Line a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Line a -> a
$cproduct :: forall a. Num a => Line a -> a
sum :: forall a. Num a => Line a -> a
$csum :: forall a. Num a => Line a -> a
minimum :: forall a. Ord a => Line a -> a
$cminimum :: forall a. Ord a => Line a -> a
maximum :: forall a. Ord a => Line a -> a
$cmaximum :: forall a. Ord a => Line a -> a
elem :: forall a. Eq a => a -> Line a -> Bool
$celem :: forall a. Eq a => a -> Line a -> Bool
length :: forall a. Line a -> Int
$clength :: forall a. Line a -> Int
null :: forall a. Line a -> Bool
$cnull :: forall a. Line a -> Bool
toList :: forall a. Line a -> [a]
$ctoList :: forall a. Line a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Line a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Line a -> a
foldr1 :: forall a. (a -> a -> a) -> Line a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Line a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Line a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Line a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Line a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Line a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Line a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Line a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Line a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Line a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Line a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Line a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Line a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Line a -> m
fold :: forall m. Monoid m => Line m -> m
$cfold :: forall m. Monoid m => Line m -> m
Foldable, Functor Line
Foldable Line
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Line (m a) -> m (Line a)
forall (f :: * -> *) a. Applicative f => Line (f a) -> f (Line a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Line a -> m (Line b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Line a -> f (Line b)
sequence :: forall (m :: * -> *) a. Monad m => Line (m a) -> m (Line a)
$csequence :: forall (m :: * -> *) a. Monad m => Line (m a) -> m (Line a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Line a -> m (Line b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Line a -> m (Line b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Line (f a) -> f (Line a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Line (f a) -> f (Line a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Line a -> f (Line b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Line a -> f (Line b)
Traversable)

data Polygon a = Polygon [Point a]
               deriving (Int -> Polygon a -> ShowS
forall a. Show a => Int -> Polygon a -> ShowS
forall a. Show a => [Polygon a] -> ShowS
forall a. Show a => Polygon a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Polygon a] -> ShowS
$cshowList :: forall a. Show a => [Polygon a] -> ShowS
show :: Polygon a -> String
$cshow :: forall a. Show a => Polygon a -> String
showsPrec :: Int -> Polygon a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Polygon a -> ShowS
Show, Polygon a -> Polygon a -> Bool
forall a. Eq a => Polygon a -> Polygon a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Polygon a -> Polygon a -> Bool
$c/= :: forall a. Eq a => Polygon a -> Polygon a -> Bool
== :: Polygon a -> Polygon a -> Bool
$c== :: forall a. Eq a => Polygon a -> Polygon a -> Bool
Eq, forall a b. a -> Polygon b -> Polygon a
forall a b. (a -> b) -> Polygon a -> Polygon b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Polygon b -> Polygon a
$c<$ :: forall a b. a -> Polygon b -> Polygon a
fmap :: forall a b. (a -> b) -> Polygon a -> Polygon b
$cfmap :: forall a b. (a -> b) -> Polygon a -> Polygon b
Functor, forall a. Eq a => a -> Polygon a -> Bool
forall a. Num a => Polygon a -> a
forall a. Ord a => Polygon a -> a
forall m. Monoid m => Polygon m -> m
forall a. Polygon a -> Bool
forall a. Polygon a -> Int
forall a. Polygon a -> [a]
forall a. (a -> a -> a) -> Polygon a -> a
forall m a. Monoid m => (a -> m) -> Polygon a -> m
forall b a. (b -> a -> b) -> b -> Polygon a -> b
forall a b. (a -> b -> b) -> b -> Polygon a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Polygon a -> a
$cproduct :: forall a. Num a => Polygon a -> a
sum :: forall a. Num a => Polygon a -> a
$csum :: forall a. Num a => Polygon a -> a
minimum :: forall a. Ord a => Polygon a -> a
$cminimum :: forall a. Ord a => Polygon a -> a
maximum :: forall a. Ord a => Polygon a -> a
$cmaximum :: forall a. Ord a => Polygon a -> a
elem :: forall a. Eq a => a -> Polygon a -> Bool
$celem :: forall a. Eq a => a -> Polygon a -> Bool
length :: forall a. Polygon a -> Int
$clength :: forall a. Polygon a -> Int
null :: forall a. Polygon a -> Bool
$cnull :: forall a. Polygon a -> Bool
toList :: forall a. Polygon a -> [a]
$ctoList :: forall a. Polygon a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Polygon a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Polygon a -> a
foldr1 :: forall a. (a -> a -> a) -> Polygon a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Polygon a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Polygon a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Polygon a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Polygon a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Polygon a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Polygon a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Polygon a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Polygon a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Polygon a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Polygon a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Polygon a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Polygon a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Polygon a -> m
fold :: forall m. Monoid m => Polygon m -> m
$cfold :: forall m. Monoid m => Polygon m -> m
Foldable, Functor Polygon
Foldable Polygon
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Polygon (m a) -> m (Polygon a)
forall (f :: * -> *) a.
Applicative f =>
Polygon (f a) -> f (Polygon a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Polygon a -> m (Polygon b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Polygon a -> f (Polygon b)
sequence :: forall (m :: * -> *) a. Monad m => Polygon (m a) -> m (Polygon a)
$csequence :: forall (m :: * -> *) a. Monad m => Polygon (m a) -> m (Polygon a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Polygon a -> m (Polygon b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Polygon a -> m (Polygon b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Polygon (f a) -> f (Polygon a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Polygon (f a) -> f (Polygon a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Polygon a -> f (Polygon b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Polygon a -> f (Polygon b)
Traversable)

class AffineTransform a b | a -> b where
  transform :: Transform b -> a -> a
  
instance Num a => AffineTransform (Transform a) a where
  {-# INLINE transform #-}
  transform :: Transform a -> Transform a -> Transform a
transform (Transform a
a' a
b' a
c' a
d' a
e' a
f') (Transform a
a a
b a
c a
d a
e a
f) =
    forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform (a
aforall a. Num a => a -> a -> a
*a
a'forall a. Num a => a -> a -> a
+a
b'forall a. Num a => a -> a -> a
*a
d) (a
a'forall a. Num a => a -> a -> a
*a
b forall a. Num a => a -> a -> a
+ a
b'forall a. Num a => a -> a -> a
*a
e) (a
a'forall a. Num a => a -> a -> a
*a
cforall a. Num a => a -> a -> a
+a
b'forall a. Num a => a -> a -> a
*a
f forall a. Num a => a -> a -> a
+a
c')
    (a
d'forall a. Num a => a -> a -> a
*a
aforall a. Num a => a -> a -> a
+a
e'forall a. Num a => a -> a -> a
*a
d) (a
d'forall a. Num a => a -> a -> a
*a
bforall a. Num a => a -> a -> a
+a
e'forall a. Num a => a -> a -> a
*a
e) (a
d'forall a. Num a => a -> a -> a
*a
cforall a. Num a => a -> a -> a
+a
e'forall a. Num a => a -> a -> a
*a
fforall a. Num a => a -> a -> a
+a
f')
    
instance Num a => AffineTransform (Point a) a where
  {-# INLINE transform #-}
  transform :: Transform a -> Point a -> Point a
transform (Transform a
a a
b a
c a
d a
e a
f) (Point a
x a
y) =
    forall a. a -> a -> Point a
Point (a
aforall a. Num a => a -> a -> a
*a
x forall a. Num a => a -> a -> a
+ a
bforall a. Num a => a -> a -> a
*a
y forall a. Num a => a -> a -> a
+ a
c) (a
dforall a. Num a => a -> a -> a
*a
x forall a. Num a => a -> a -> a
+ a
eforall a. Num a => a -> a -> a
*a
y forall a. Num a => a -> a -> a
+ a
f)

instance Num a => AffineTransform (Polygon a) a where
  {-# INLINE transform #-}
  transform :: Transform a -> Polygon a -> Polygon a
transform Transform a
t (Polygon [Point a]
p) = forall a. [Point a] -> Polygon a
Polygon forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall a b. AffineTransform a b => Transform b -> a -> a
transform Transform a
t) [Point a]
p

newtype instance V.MVector s (Point a) = MV_Point (V.MVector s (a, a))
newtype instance V.Vector    (Point a) = V_Point  (V.Vector    (a, a))

instance V.Unbox a => V.Unbox (Point a)
instance V.Unbox a => M.MVector V.MVector (Point a) where
  {-# INLINE basicLength #-}
  {-# INLINE basicUnsafeSlice #-}
  {-# INLINE basicOverlaps #-}
  {-# INLINE basicUnsafeNew #-}
  {-# INLINE basicUnsafeReplicate #-}
  {-# INLINE basicUnsafeRead #-}
  {-# INLINE basicUnsafeWrite #-}
  {-# INLINE basicClear #-}
  {-# INLINE basicSet #-}
  {-# INLINE basicUnsafeCopy #-}
  {-# INLINE basicUnsafeGrow #-}
  basicInitialize :: forall s. MVector s (Point a) -> ST s ()
basicInitialize (MV_Point MVector s (a, a)
v) = forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s (a, a)
v
  basicLength :: forall s. MVector s (Point a) -> Int
basicLength (MV_Point MVector s (a, a)
v) = forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength MVector s (a, a)
v
  basicUnsafeSlice :: forall s. Int -> Int -> MVector s (Point a) -> MVector s (Point a)
basicUnsafeSlice Int
i Int
n (MV_Point MVector s (a, a)
v) = forall s a. MVector s (a, a) -> MVector s (Point a)
MV_Point forall a b. (a -> b) -> a -> b
$ forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i Int
n MVector s (a, a)
v
  basicOverlaps :: forall s. MVector s (Point a) -> MVector s (Point a) -> Bool
basicOverlaps (MV_Point MVector s (a, a)
v1) (MV_Point MVector s (a, a)
v2) = forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s (a, a)
v1 MVector s (a, a)
v2
  basicUnsafeNew :: forall s. Int -> ST s (MVector s (Point a))
basicUnsafeNew Int
n = forall s a. MVector s (a, a) -> MVector s (Point a)
MV_Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew Int
n
  basicUnsafeReplicate :: forall s. Int -> Point a -> ST s (MVector s (Point a))
basicUnsafeReplicate Int
n (Point a
x a
y) = forall s a. MVector s (a, a) -> MVector s (Point a)
MV_Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
M.basicUnsafeReplicate Int
n (a
x,a
y)
  basicUnsafeRead :: forall s. MVector s (Point a) -> Int -> ST s (Point a)
basicUnsafeRead (MV_Point MVector s (a, a)
v) Int
i = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. a -> a -> Point a
Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s (a, a)
v Int
i
  basicUnsafeWrite :: forall s. MVector s (Point a) -> Int -> Point a -> ST s ()
basicUnsafeWrite (MV_Point MVector s (a, a)
v) Int
i (Point a
x a
y) = forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s (a, a)
v Int
i (a
x,a
y)
  basicClear :: forall s. MVector s (Point a) -> ST s ()
basicClear (MV_Point MVector s (a, a)
v) = forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicClear MVector s (a, a)
v
  basicSet :: forall s. MVector s (Point a) -> Point a -> ST s ()
basicSet (MV_Point MVector s (a, a)
v) (Point a
x a
y) = forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet MVector s (a, a)
v (a
x,a
y)
  basicUnsafeCopy :: forall s. MVector s (Point a) -> MVector s (Point a) -> ST s ()
basicUnsafeCopy (MV_Point MVector s (a, a)
v1) (MV_Point MVector s (a, a)
v2) = forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeCopy MVector s (a, a)
v1 MVector s (a, a)
v2
  basicUnsafeGrow :: forall s. MVector s (Point a) -> Int -> ST s (MVector s (Point a))
basicUnsafeGrow (MV_Point MVector s (a, a)
v) Int
n = forall s a. MVector s (a, a) -> MVector s (Point a)
MV_Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
M.basicUnsafeGrow MVector s (a, a)
v Int
n

instance V.Unbox a => G.Vector V.Vector (Point a) where
  {-# INLINE basicUnsafeFreeze #-}
  {-# INLINE basicUnsafeThaw #-}
  {-# INLINE basicLength #-}
  {-# INLINE basicUnsafeSlice #-}
  {-# INLINE basicUnsafeIndexM #-}
  {-# INLINE elemseq #-}
  basicUnsafeFreeze :: forall s. Mutable Vector s (Point a) -> ST s (Vector (Point a))
basicUnsafeFreeze (MV_Point MVector s (a, a)
v) = forall a. Vector (a, a) -> Vector (Point a)
V_Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze MVector s (a, a)
v
  basicUnsafeThaw :: forall s. Vector (Point a) -> ST s (Mutable Vector s (Point a))
basicUnsafeThaw (V_Point Vector (a, a)
v) = forall s a. MVector s (a, a) -> MVector s (Point a)
MV_Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw Vector (a, a)
v
  basicLength :: Vector (Point a) -> Int
basicLength (V_Point Vector (a, a)
v) = forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength Vector (a, a)
v
  basicUnsafeSlice :: Int -> Int -> Vector (Point a) -> Vector (Point a)
basicUnsafeSlice Int
i Int
n (V_Point Vector (a, a)
v) = forall a. Vector (a, a) -> Vector (Point a)
V_Point forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
n Vector (a, a)
v
  basicUnsafeIndexM :: Vector (Point a) -> Int -> Box (Point a)
basicUnsafeIndexM (V_Point Vector (a, a)
v) Int
i
                = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. a -> a -> Point a
Point forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector (a, a)
v Int
i
  basicUnsafeCopy :: forall s. Mutable Vector s (Point a) -> Vector (Point a) -> ST s ()
basicUnsafeCopy (MV_Point MVector s (a, a)
mv) (V_Point Vector (a, a)
v)
                = forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy MVector s (a, a)
mv Vector (a, a)
v
  elemseq :: forall b. Vector (Point a) -> Point a -> b -> b
elemseq Vector (Point a)
_ (Point a
x a
y) b
z = forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. HasCallStack => a
undefined :: V.Vector a) a
x
                       forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. HasCallStack => a
undefined :: V.Vector a) a
y b
z

-- | Operator for applying a transformation.
($*) :: AffineTransform a b => Transform b -> a -> a
Transform b
t $* :: forall a b. AffineTransform a b => Transform b -> a -> a
$* a
p = forall a b. AffineTransform a b => Transform b -> a -> a
transform Transform b
t a
p
{-# INLINE ($*) #-}

-- | Calculate the inverse of a transformation.
inverse :: (Eq a, Fractional a) => Transform a -> Maybe (Transform a)
inverse :: forall a.
(Eq a, Fractional a) =>
Transform a -> Maybe (Transform a)
inverse (Transform a
a a
b a
c a
d a
e a
f) = case a
aforall a. Num a => a -> a -> a
*a
e forall a. Num a => a -> a -> a
- a
bforall a. Num a => a -> a -> a
*a
d of
  a
0 -> forall a. Maybe a
Nothing
  a
det -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform (a
aforall a. Fractional a => a -> a -> a
/a
det) (a
dforall a. Fractional a => a -> a -> a
/a
det) (-(a
aforall a. Num a => a -> a -> a
*a
c forall a. Num a => a -> a -> a
+ a
dforall a. Num a => a -> a -> a
*a
f)forall a. Fractional a => a -> a -> a
/a
det) (a
bforall a. Fractional a => a -> a -> a
/a
det) (a
eforall a. Fractional a => a -> a -> a
/a
det)
         (-(a
bforall a. Num a => a -> a -> a
*a
c forall a. Num a => a -> a -> a
+ a
eforall a. Num a => a -> a -> a
*a
f)forall a. Fractional a => a -> a -> a
/a
det)
{-# SPECIALIZE inverse :: Transform Double -> Maybe (Transform Double) #-}         

-- | Return the parameters (a, b, c) for the normalised equation
-- of the line: @a*x + b*y + c = 0@.
lineEquation :: Floating t => Line t -> ( t, t, t )
lineEquation :: forall t. Floating t => Line t -> (t, t, t)
lineEquation (Line (Point t
x1 t
y1) (Point t
x2 t
y2)) =
  t
a seq :: forall a b. a -> b -> b
`seq` t
b seq :: forall a b. a -> b -> b
`seq` t
c seq :: forall a b. a -> b -> b
`seq` (t
a, t
b, t
c)
  where a :: t
a = t
a' forall a. Fractional a => a -> a -> a
/ t
d
        b :: t
b = t
b' forall a. Fractional a => a -> a -> a
/ t
d
        c :: t
c = -(t
y1forall a. Num a => a -> a -> a
*t
b' forall a. Num a => a -> a -> a
+ t
x1forall a. Num a => a -> a -> a
*t
a') forall a. Fractional a => a -> a -> a
/ t
d
        a' :: t
a' = t
y1 forall a. Num a => a -> a -> a
- t
y2
        b' :: t
b' = t
x2 forall a. Num a => a -> a -> a
- t
x1
        d :: t
d = forall a. Floating a => a -> a
sqrt(t
a'forall a. Num a => a -> a -> a
*t
a' forall a. Num a => a -> a -> a
+ t
b'forall a. Num a => a -> a -> a
*t
b')
{-# SPECIALIZE lineEquation :: Line Double -> (Double, Double, Double) #-}        

-- | Return the signed distance from a point to the line.  If the
-- distance is negative, the point lies to the right of the line
lineDistance :: Floating a => Line a -> Point a -> a
lineDistance :: forall a. Floating a => Line a -> Point a -> a
lineDistance (Line (Point a
x1 a
y1) (Point a
x2 a
y2)) =
  let dy :: a
dy = a
y1 forall a. Num a => a -> a -> a
- a
y2
      dx :: a
dx = a
x2 forall a. Num a => a -> a -> a
- a
x1
      d :: a
d = forall a. Floating a => a -> a
sqrt(a
dxforall a. Num a => a -> a -> a
*a
dx forall a. Num a => a -> a -> a
+ a
dyforall a. Num a => a -> a -> a
*a
dy)
  in a
dy seq :: forall a b. a -> b -> b
`seq` a
dx seq :: forall a b. a -> b -> b
`seq` a
d seq :: forall a b. a -> b -> b
`seq`
     \(Point a
x a
y) -> (a
xforall a. Num a => a -> a -> a
-a
x1)forall a. Num a => a -> a -> a
*a
dyforall a. Fractional a => a -> a -> a
/a
d forall a. Num a => a -> a -> a
+ (a
yforall a. Num a => a -> a -> a
-a
y1)forall a. Num a => a -> a -> a
*a
dxforall a. Fractional a => a -> a -> a
/a
d
{-# INLINE lineDistance #-}    

-- | Return the point on the line closest to the given point.
closestPoint :: Fractional a => Line a -> Point a -> Point a
closestPoint :: forall a. Fractional a => Line a -> Point a -> Point a
closestPoint (Line Point a
p1 Point a
p2) Point a
p3 = forall a. a -> a -> Point a
Point a
px a
py
  where
    (Point a
dx a
dy) = Point a
p2 forall v. AdditiveGroup v => v -> v -> v
^-^ Point a
p1
    u :: a
u = a
dyforall a. Num a => a -> a -> a
*forall a. Point a -> a
pointY Point a
p3 forall a. Num a => a -> a -> a
+ a
dxforall a. Num a => a -> a -> a
*forall a. Point a -> a
pointX Point a
p3
    v :: a
v = forall a. Point a -> a
pointX Point a
p1forall a. Num a => a -> a -> a
*forall a. Point a -> a
pointY Point a
p2 forall a. Num a => a -> a -> a
- forall a. Point a -> a
pointX Point a
p2forall a. Num a => a -> a -> a
*forall a. Point a -> a
pointY Point a
p1
    m :: a
m = a
dxforall a. Num a => a -> a -> a
*a
dx forall a. Num a => a -> a -> a
+ a
dyforall a. Num a => a -> a -> a
*a
dy
    px :: a
px = (a
dxforall a. Num a => a -> a -> a
*a
u forall a. Num a => a -> a -> a
+ a
dyforall a. Num a => a -> a -> a
*a
v) forall a. Fractional a => a -> a -> a
/ a
m
    py :: a
py = (a
dyforall a. Num a => a -> a -> a
*a
u forall a. Num a => a -> a -> a
- a
dxforall a. Num a => a -> a -> a
*a
v) forall a. Fractional a => a -> a -> a
/ a
m
{-# specialize closestPoint :: Line Double -> Point Double -> Point Double #-}  

-- | Calculate the intersection of two lines.  If the determinant is
-- less than tolerance (parallel or coincident lines), return Nothing.
lineIntersect :: (Ord a, Floating a) => Line a -> Line a -> a -> Maybe (Point a)
lineIntersect :: forall a.
(Ord a, Floating a) =>
Line a -> Line a -> a -> Maybe (Point a)
lineIntersect (Line Point a
p1 Point a
p2) (Line Point a
p3 Point a
p4) a
eps
  | forall a. Num a => a -> a
abs a
det forall a. Ord a => a -> a -> Bool
<= a
eps = forall a. Maybe a
Nothing
  | Bool
otherwise = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ (a
aforall v. VectorSpace v => Scalar v -> v -> v
*^Point a
d2 forall v. AdditiveGroup v => v -> v -> v
^-^ a
bforall v. VectorSpace v => Scalar v -> v -> v
*^Point a
d1) forall v s.
(VectorSpace v, s ~ Scalar v, Fractional s) =>
v -> s -> v
^/ a
det
  where
    d1 :: Point a
d1 = Point a
p1 forall v. AdditiveGroup v => v -> v -> v
^-^ Point a
p2
    d2 :: Point a
d2 = Point a
p3 forall v. AdditiveGroup v => v -> v -> v
^-^ Point a
p4
    det :: a
det = forall a. Num a => Point a -> Point a -> a
vectorCross Point a
d1 Point a
d2
    a :: a
a = forall a. Num a => Point a -> Point a -> a
vectorCross Point a
p1 Point a
p2 
    b :: a
b = forall a. Num a => Point a -> Point a -> a
vectorCross Point a
p3 Point a
p4
{-# SPECIALIZE lineIntersect :: Line Double -> Line Double -> Double -> Maybe DPoint #-}    

-- | The lenght of the vector.
vectorMag :: Floating a => Point a -> a
vectorMag :: forall a. Floating a => Point a -> a
vectorMag (Point a
x a
y) = forall a. Floating a => a -> a
sqrt(a
xforall a. Num a => a -> a -> a
*a
x forall a. Num a => a -> a -> a
+ a
yforall a. Num a => a -> a -> a
*a
y)
{-# INLINE vectorMag #-}

-- | The lenght of the vector.
vectorMagSquare :: Floating a => Point a -> a
vectorMagSquare :: forall a. Floating a => Point a -> a
vectorMagSquare (Point a
x a
y) = a
xforall a. Num a => a -> a -> a
*a
x forall a. Num a => a -> a -> a
+ a
yforall a. Num a => a -> a -> a
*a
y
{-# INLINE vectorMagSquare #-}


-- | The angle of the vector, in the range @(-'pi', 'pi']@.
vectorAngle :: RealFloat a => Point a -> a
vectorAngle :: forall a. RealFloat a => Point a -> a
vectorAngle (Point a
0.0 a
0.0) = a
0.0
vectorAngle (Point a
x a
y) = forall a. RealFloat a => a -> a -> a
atan2 a
y a
x
{-# INLINE vectorAngle #-}

-- | The unitvector with the given angle.
dirVector :: Floating a => a -> Point a
dirVector :: forall a. Floating a => a -> Point a
dirVector a
angle = forall a. a -> a -> Point a
Point (forall a. Floating a => a -> a
cos a
angle) (forall a. Floating a => a -> a
sin a
angle)
{-# INLINE dirVector #-}

-- | The unit vector with the same direction.
normVector :: Floating a => Point a -> Point a
normVector :: forall a. Floating a => Point a -> Point a
normVector p :: Point a
p@(Point a
x a
y) = forall a. a -> a -> Point a
Point (a
xforall a. Fractional a => a -> a -> a
/a
l) (a
yforall a. Fractional a => a -> a -> a
/a
l)
  where l :: a
l = forall a. Floating a => Point a -> a
vectorMag Point a
p
{-# INLINE normVector #-}        

instance Num e => AdditiveGroup (Point e) where
  zeroV :: Point e
zeroV = forall a. a -> a -> Point a
Point e
0 e
0
  {-# INLINE (^+^) #-}
  (Point e
x1 e
y1) ^+^ :: Point e -> Point e -> Point e
^+^ (Point e
x2 e
y2) = forall a. a -> a -> Point a
Point (e
x1forall a. Num a => a -> a -> a
+e
x2) (e
y1forall a. Num a => a -> a -> a
+e
y2)
  {-# INLINE negateV #-}
  negateV :: Point e -> Point e
negateV (Point e
a e
b) = forall a. a -> a -> Point a
Point (-e
a) (-e
b)
  {-# INLINE (^-^) #-}
  (Point e
x1 e
y1) ^-^ :: Point e -> Point e -> Point e
^-^ (Point e
x2 e
y2) = forall a. a -> a -> Point a
Point (e
x1forall a. Num a => a -> a -> a
-e
x2) (e
y1forall a. Num a => a -> a -> a
-e
y2)

instance (Num e) => VectorSpace (Point e) where
  type Scalar (Point e) = e
  Scalar (Point e)
s *^ :: Scalar (Point e) -> Point e -> Point e
*^ (Point e
x e
y) = forall a. a -> a -> Point a
Point (Scalar (Point e)
sforall a. Num a => a -> a -> a
*e
x) (Scalar (Point e)
sforall a. Num a => a -> a -> a
*e
y)

instance (AdditiveGroup e, Num e) => InnerSpace (Point e) where
  <.> :: Point e -> Point e -> Scalar (Point e)
(<.>) = forall a. Num a => Point a -> Point a -> a
(^.^)

instance (Floating e) => HasNormal (Point e) where
  normalVec :: Point e -> Point e
normalVec = forall a. Floating a => Point a -> Point a
normVector

-- | Dot product of two vectors.
(^.^) :: Num a => Point a -> Point a -> a
(Point a
x1 a
y1) ^.^ :: forall a. Num a => Point a -> Point a -> a
^.^ (Point a
x2 a
y2) = a
x1forall a. Num a => a -> a -> a
*a
x2 forall a. Num a => a -> a -> a
+ a
y1forall a. Num a => a -> a -> a
*a
y2
{-# INLINE (^.^) #-}

-- | Cross product of two vectors.
vectorCross :: Num a => Point a -> Point a -> a
vectorCross :: forall a. Num a => Point a -> Point a -> a
vectorCross (Point a
x1 a
y1) (Point a
x2 a
y2) = a
x1forall a. Num a => a -> a -> a
*a
y2 forall a. Num a => a -> a -> a
- a
y1forall a. Num a => a -> a -> a
*a
x2
{-# INLINE vectorCross #-}

-- | Distance between two vectors.
vectorDistance :: Floating a => Point a -> Point a -> a
vectorDistance :: forall a. Floating a => Point a -> Point a -> a
vectorDistance Point a
p Point a
q = forall a. Floating a => Point a -> a
vectorMag (Point a
pforall v. AdditiveGroup v => v -> v -> v
^-^Point a
q)
{-# INLINE vectorDistance #-}

-- | Interpolate between two vectors.
interpolateVector :: (Num a) => Point a -> Point a -> a -> Point a
interpolateVector :: forall a. Num a => Point a -> Point a -> a -> Point a
interpolateVector Point a
a Point a
b a
t = a
tforall v. VectorSpace v => Scalar v -> v -> v
*^Point a
b forall v. AdditiveGroup v => v -> v -> v
^+^ (a
1forall a. Num a => a -> a -> a
-a
t)forall v. VectorSpace v => Scalar v -> v -> v
*^Point a
a
{-# INLINE interpolateVector #-}

-- | Create a transform that rotates by the angle of the given vector
-- and multiplies with the magnitude of the vector.
rotateScaleVec :: Num a => Point a -> Transform a
rotateScaleVec :: forall a. Num a => Point a -> Transform a
rotateScaleVec (Point a
x a
y) = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform a
x (-a
y) a
0 a
y a
x a
0
{-# INLINE rotateScaleVec #-}

-- | reflect the vector over the X-axis.
flipVector :: (Num a) => Point a -> Point a
flipVector :: forall e. Num e => Point e -> Point e
flipVector (Point a
x a
y) = forall a. a -> a -> Point a
Point a
x (-a
y)
{-# INLINE flipVector #-}

turnAround :: (Num a) => Point a -> Point a
turnAround :: forall e. Num e => Point e -> Point e
turnAround = forall v. AdditiveGroup v => v -> v
negateV
{-# INLINE turnAround #-}

-- | Create a transform that rotates by the angle of the given vector
-- with the x-axis
rotateVec :: Floating a => Point a -> Transform a
rotateVec :: forall a. Floating a => Point a -> Transform a
rotateVec Point a
v = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform a
x (-a
y) a
0 a
y a
x a
0
  where Point a
x a
y = forall a. Floating a => Point a -> Point a
normVector Point a
v
{-# INLINE rotateVec #-}

-- | Create a transform that rotates by the given angle (radians).
rotate :: Floating s => s -> Transform s
rotate :: forall s. Floating s => s -> Transform s
rotate s
a = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform (forall a. Floating a => a -> a
cos s
a) (forall a. Num a => a -> a
negate forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
sin s
a) s
0
           (forall a. Floating a => a -> a
sin s
a) (forall a. Floating a => a -> a
cos s
a) s
0
{-# INLINE rotate #-}

-- | Rotate vector 90 degrees left.
rotate90L :: Floating s => Transform s
rotate90L :: forall s. Floating s => Transform s
rotate90L = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform s
0 (-s
1) s
0 s
1 s
0 s
0
{-# INLINE rotate90L #-}

-- | Rotate vector 90 degrees right.
rotate90R :: Floating s => Transform s
rotate90R :: forall s. Floating s => Transform s
rotate90R = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform s
0 s
1 s
0 (-s
1) s
0 s
0
{-# INLINE rotate90R #-}

-- | Create a transform that translates by the given vector.
translate :: Num a => Point a -> Transform a
translate :: forall a. Num a => Point a -> Transform a
translate (Point a
x a
y) = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform a
1 a
0 a
x a
0 a
1 a
y
{-# INLINE translate #-}

-- | The identity transformation.
idTrans :: Num a => Transform a
idTrans :: forall a. Num a => Transform a
idTrans = forall a. a -> a -> a -> a -> a -> a -> Transform a
Transform a
1 a
0 a
0 a
0 a
1 a
0
{-# INLINE idTrans #-}