Safe Haskell | None |
---|---|
Language | Haskell2010 |
- newtype Point d r = Point {}
- origin :: (Arity d, Num r) => Point d r
- vector :: Lens' (Point d r) (Vector d r)
- unsafeCoord :: Arity d => Int -> Lens' (Point d r) r
- coord :: forall proxy i d r. (Index' (i - 1) d, Arity d) => proxy i -> Lens' (Point d r) r
- pattern Point2 :: r -> r -> Point 2 r
- pattern Point3 :: r -> r -> r -> Point 3 r
- point2 :: r -> r -> Point 2 r
- _point2 :: Point 2 r -> (r, r)
- point3 :: r -> r -> r -> Point 3 r
- _point3 :: Point 3 r -> (r, r, r)
- type (<=.) i d = (Index' (i - 1) d, Arity d)
- xCoord :: 1 <=. d => Lens' (Point d r) r
- yCoord :: 2 <=. d => Lens' (Point d r) r
- zCoord :: 3 <=. d => Lens' (Point d r) r
- class PointFunctor g where
- data CCW
- ccw :: (Ord r, Num r) => Point 2 r -> Point 2 r -> Point 2 r -> CCW
- sortArround :: (Ord r, Num r) => (Point 2 r :+ p) -> [Point 2 r :+ p] -> [Point 2 r :+ p]
- data Quadrant
- quadrantWith :: (Arity d, Ord r, 1 <=. d, 2 <=. d) => (Point d r :+ q) -> (Point d r :+ p) -> Quadrant
- quadrant :: (Arity d, Ord r, Num r, 1 <=. d, 2 <=. d) => (Point d r :+ p) -> Quadrant
- partitionIntoQuadrants :: (Ord r, Arity d, 1 <=. d, 2 <=. d) => (Point d r :+ q) -> [Point d r :+ p] -> ([Point d r :+ p], [Point d r :+ p], [Point d r :+ p], [Point d r :+ p])
- ccwCmpAround :: (Num r, Ord r) => (Point 2 r :+ qc) -> (Point 2 r :+ p) -> (Point 2 r :+ q) -> Ordering
- cwCmpAround :: (Num r, Ord r) => (Point 2 r :+ qc) -> (Point 2 r :+ p) -> (Point 2 r :+ q) -> Ordering
- insertIntoCyclicOrder :: (Ord r, Num r) => (Point 2 r :+ q) -> (Point 2 r :+ p) -> CList (Point 2 r :+ p) -> CList (Point 2 r :+ p)
- squaredEuclideanDist :: (Num r, Arity d) => Point d r -> Point d r -> r
- euclideanDist :: (Floating r, Arity d) => Point d r -> Point d r -> r
Documentation
>>>
:{
let myVector :: Vector 3 Int myVector = v3 1 2 3 myPoint = Point myVector :}
A d-dimensional Point
A d-dimensional point.
Arity d => Functor (Point d) Source | |
Arity d => Foldable (Point d) Source | |
Arity d => Traversable (Point d) Source | |
Arity d => Affine (Point d) Source | |
PointFunctor (Point d) Source | |
(Eq r, Arity d) => Eq (Point d r) Source | |
(Ord r, Arity d) => Ord (Point d r) Source | |
(Show r, Arity d) => Show (Point d r) Source | |
(Num r, Arity d, AlwaysTrueDestruct d ((+) 1 d)) => IsTransformable (Point d r) Source | |
IsBoxable (Point d r) Source | |
IpeWriteText r => IpeWriteText (Point 2 r) Source | |
Coordinate r => IpeReadText (Point 2 r) Source | |
HasDefaultIpeOut (Point 2 r) Source | |
type Diff (Point d) = Vector d Source | |
type NumType (Point d r) = r Source | |
type Dimension (Point d r) = d Source | |
type DefaultIpeOut (Point 2 r) = IpeSymbol Source |
origin :: (Arity d, Num r) => Point d r Source
Point representing the origin in d dimensions
>>>
origin :: Point 4 Int
Point4 [0,0,0,0]
Accessing points
vector :: Lens' (Point d r) (Vector d r) Source
Lens to access the vector corresponding to this point.
>>>
(point3 1 2 3) ^. vector
Vector3 [1,2,3]>>>
origin & vector .~ v3 1 2 3
Point3 [1,2,3]
unsafeCoord :: Arity d => Int -> Lens' (Point d r) r Source
Get the coordinate in a given dimension. This operation is unsafe in the
sense that no bounds are checked. Consider using coord
instead.
>>>
point3 1 2 3 ^. unsafeCoord 2
2
coord :: forall proxy i d r. (Index' (i - 1) d, Arity d) => proxy i -> Lens' (Point d r) r Source
Get the coordinate in a given dimension
>>>
point3 1 2 3 ^. coord (C :: C 2)
2>>>
point3 1 2 3 & coord (C :: C 1) .~ 10
Point3 [10,2,3]>>>
point3 1 2 3 & coord (C :: C 3) %~ (+1)
Point3 [1,2,4]
Convenience functions to construct 2 and 3 dimensional points
pattern Point2 :: r -> r -> Point 2 r Source
We provide pattern synonyms Point2 and Point3 for 2 and 3 dimensional points. i.e. we can write:
>>>
:{
let f :: Point 2 r -> r f (Point2 x y) = x in f (point2 1 2) :} 1
if we want.
pattern Point3 :: r -> r -> r -> Point 3 r Source
Similarly, we can write:
>>>
:{
let g :: Point 3 r -> r g (Point3 x y z) = z in g myPoint :} 3
point3 :: r -> r -> r -> Point 3 r Source
Construct a 3 dimensional point
>>>
point3 1 2 3
Point3 [1,2,3]
_point3 :: Point 3 r -> (r, r, r) Source
Destruct a 3 dimensional point
>>>
_point3 $ point3 1 2 3
(1,2,3)
xCoord :: 1 <=. d => Lens' (Point d r) r Source
Shorthand to access the first coordinate C 1
>>>
point3 1 2 3 ^. xCoord
1>>>
point2 1 2 & xCoord .~ 10
Point2 [10,2]
yCoord :: 2 <=. d => Lens' (Point d r) r Source
Shorthand to access the second coordinate C 2
>>>
point2 1 2 ^. yCoord
2>>>
point3 1 2 3 & yCoord %~ (+1)
Point3 [1,3,3]
zCoord :: 3 <=. d => Lens' (Point d r) r Source
Shorthand to access the third coordinate C 3
>>>
point3 1 2 3 ^. zCoord
3>>>
point3 1 2 3 & zCoord %~ (+1)
Point3 [1,2,4]
Point Functors
class PointFunctor g where Source
Types that we can transform by mapping a function on each point in the structure
PointFunctor (Point d) Source | |
PointFunctor (Triangle p) Source | |
PointFunctor (Box d p) Source | |
PointFunctor (LineSegment d p) Source | |
PointFunctor (PolyLine d p) Source | |
PointFunctor (Polygon t p) Source |
Functions specific to Two Dimensional points
ccw :: (Ord r, Num r) => Point 2 r -> Point 2 r -> Point 2 r -> CCW Source
Given three points p q and r determine the orientation when going from p to r via q.
sortArround :: (Ord r, Num r) => (Point 2 r :+ p) -> [Point 2 r :+ p] -> [Point 2 r :+ p] Source
Sort the points arround the given point p in counter clockwise order with respect to the rightward horizontal ray starting from p. If two points q and r are colinear with p, the closest one to p is reported first. running time: O(n log n)
Quadrants of two dimensional points. in CCW order
quadrantWith :: (Arity d, Ord r, 1 <=. d, 2 <=. d) => (Point d r :+ q) -> (Point d r :+ p) -> Quadrant Source
Quadrants around point c; quadrants are closed on their "previous" boundary (i..e the boundary with the previous quadrant in the CCW order), open on next boundary. The origin itself is assigned the topRight quadrant
quadrant :: (Arity d, Ord r, Num r, 1 <=. d, 2 <=. d) => (Point d r :+ p) -> Quadrant Source
Quadrants with respect to the origin
partitionIntoQuadrants :: (Ord r, Arity d, 1 <=. d, 2 <=. d) => (Point d r :+ q) -> [Point d r :+ p] -> ([Point d r :+ p], [Point d r :+ p], [Point d r :+ p], [Point d r :+ p]) Source
Given a center point c, and a set of points, partition the points into quadrants around c (based on their x and y coordinates). The quadrants are reported in the order topLeft, topRight, bottomLeft, bottomRight. The points are in the same order as they were in the original input lists. Points with the same x-or y coordinate as p, are "rounded" to above.
ccwCmpAround :: (Num r, Ord r) => (Point 2 r :+ qc) -> (Point 2 r :+ p) -> (Point 2 r :+ q) -> Ordering Source
Counter clockwise ordering of the points around c. Points are ordered with respect to the positive x-axis. Points nearer to the center come before points further away.
cwCmpAround :: (Num r, Ord r) => (Point 2 r :+ qc) -> (Point 2 r :+ p) -> (Point 2 r :+ q) -> Ordering Source
Clockwise ordering of the points around c. Points are ordered with respect to the positive x-axis. Points nearer to the center come before points further away.
insertIntoCyclicOrder :: (Ord r, Num r) => (Point 2 r :+ q) -> (Point 2 r :+ p) -> CList (Point 2 r :+ p) -> CList (Point 2 r :+ p) Source
Given a center c, a new point p, and a list of points ps, sorted in counter clockwise order around c. Insert p into the cyclic order. The focus of the returned cyclic list is the new point p.
running time: O(n)