hgeometry: Geometric Algorithms, Data structures, and Data types.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain]

Warnings:

HGeometry provides some basic geometry types, and geometric algorithms and data structures for them. The main two focusses are: (1) Strong type safety, and (2) implementations of geometric algorithms and data structures with good asymptotic running time guarantees. Note that HGeometry is still highly experimental, don't be surprised to find bugs.


[Skip to ReadMe]

Properties

Versions0.1.0.0, 0.1.1.0, 0.1.1.1, 0.4.0.0, 0.5.0.0, 0.6.0.0, 0.7.0.0, 0.8.0.0, 0.9.0.0, 0.9.0.0
Change logNone available
Dependenciesaeson (>=1.0), base (>=4.11 && <5), bifunctors (>=4.1), bytestring (>=0.10), containers (>=0.5.9), data-clist (>=0.1.2.3), deepseq (>=1.1), dlist (>=0.7), fingertree (>=0.1), fixed-vector (>=1.0), hgeometry-combinatorial (>=0.9.0.0), lens (>=4.2), linear (>=1.10), MonadRandom (>=0.5), mtl, QuickCheck (>=2.5), quickcheck-instances (>=0.3), reflection (>=2.1), semigroupoids (>=5), semigroups (>=0.18), singletons (>=2.0), template-haskell, text (>=1.1.1.0), vector (>=0.11), vector-builder (>=0.3.7), vinyl (>=0.10), yaml (>=0.8) [details]
LicenseBSD-3-Clause
AuthorFrank Staals
Maintainerfrank@fstaals.net
CategoryGeometry
Home pagehttps://fstaals.net/software/hgeometry
Source repositoryhead: git clone https://github.com/noinia/hgeometry
UploadedWed Oct 16 19:58:58 UTC 2019 by FrankStaals

Modules

Downloads

Maintainers' corner

For package maintainers and hackage trustees


Readme for hgeometry-0.9.0.0

[back to package description]

HGeometry

Build Status Hackage

HGeometry is a library for computing with geometric objects in Haskell. It defines basic geometric types and primitives, and it implements some geometric data structures and algorithms. The main two focusses are:

Design choices showing these aspects are for example:

newtype Point (d :: Nat) (r :: *) = Point { toVec :: Vector d r }

Please note that aspect two, implementing good algorithms, is much work in progress. Only a few algorithms have been implemented, some of which could use some improvements.

HGeometry Packages

HGeometry is split into a few smaller packages. In particular:

In addition there is a hgeometry-examples package that defines some example applications, and a hgometry-test package that contains all testcases. The latter is to work around a bug in cabal.

Available Geometric Algorithms

Apart from some basic geometric primitives such as intersecting line segments, testing if a point lies in a polygon etc, HGeometry implements some more advanced geometric algorithms. In particuar, the following algorithms are currently available:

Available Geometric Data Structures

HGeometry also contains an implementation of some geometric data structures. In particular,

There is also support for working with planar subdivisions. As a result, [hgeometry-combinatorial] also includes a data structure for working with planar graphs. In particular, it has an EdgeOracle data structure, that can be built in (O(n)) time that can test if the planar graph contains an edge in constant time.

Avoiding Floating-point issues

All geometry types are parameterized by a numerical type r. It is well known that Floating-point arithmetic and Geometric algorithms don't go well together; i.e. because of floating point errors one may get completely wrong results. Hence, I strongly advise against using Double or Float for these types. In several algorithms it is sufficient if the type r is Fractional. Hence, you can use an exact number type such as Rational.

Working with additional data

In many applications we do not just have geometric data, e.g. Point d rs or Polygon rs, but instead, these types have some additional properties, like a color, size, thickness, elevation, or whatever. Hence, we would like that our library provides functions that also allow us to work with ColoredPolygon rs etc. The typical Haskell approach would be to construct type-classes such as PolygonLike and define functions that work with any type that is PolygonLike. However, geometric algorithms are often hard enough by themselves, and thus we would like all the help that the type-system/compiler can give us. Hence, we choose to work with concrete types.

To still allow for some extensibility our types will use the Ext (:+) type, as defined in the hgeometry-combinatorial package. For example, our Polygon data type, has an extra type parameter p that allows the vertices of the polygon to cary some extra information of type p (for example a color, a size, or whatever).

data Polygon (t :: PolygonType) p r where
  SimplePolygon :: C.CSeq (Point 2 r :+ p)                         -> Polygon Simple p r
  MultiPolygon  :: C.CSeq (Point 2 r :+ p) -> [Polygon Simple p r] -> Polygon Multi  p r

In all places this extra data is accessable by the (:+) type in Data.Ext, which is essentially just a pair.