dimensions alternatives and similar packages
Based on the "Geometry" category.
Alternatively, view dimensions alternatives based on common mentions on social networks and blogs.

hgeometry
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: (1) Strong type safety, and (2) implementations of geometric algorithms and data structures that have good asymptotic running time guarantees.
Less time debugging, more time building
Do you think we are missing an alternative of dimensions or a related project?
Popular Comparisons
README
Easytensor: manydimensional typesafe numeric ops
The project consists of two parts:
dimensions
is a library to support typelevel operations on lists of dimensions;easytensor
wraps lowlevel operations on primitive byte arrays in a typesafe data type indexed over an element type and a list of dimensions.
dimensions
Data.Type.List
and Data.Type.Lits
provide typelevel operations on lists, Nat
s, and Symbols
s.
Numeric.TypedList
is the core module providing a typelistindexed type that is, in fact, just a newtype wrapper on a plain haskell list.
The TypedList (f :: k > Type) (xs :: [k])
represents a lot of things; by changing type parameter f
, I use TypedList
as a flexible (yet typesafe) tuple, a finite dimensions list, or an index over such a list.
Numeric.Dimensions
provides:
 promoted type
XNat = N Nat  XN
similar to typeMaybe
; kindXNat
is used for type variables when some of dimensions in a typelevel list are not known at compile time;  data type
Dims (ds :: [k])
, wherek
is eitherNat
orXNat
, together with classDimensions ds
it allows lots of typelevel operations on typelevel dimensionality;  data type
Idxs (ds :: [k])
is used to index over manydimensional space defined byDims ds
.
easytensor
This library aims at providing fast, simple, and useful geometry types for use in computer graphics and lowdimensional physics modelling.
All geometry types implement standard Prelude
numerical classes, such as Num
, Fractional
, Floating
, lexicographical Ord
favouring elementwise operations:
functions like +
, *
, /
are all elementwise.
Common matrix and vector operations are provided separately.
Data type DataFrame
is presented in two versions:
DataFrame t (ds :: [Nat])
 dimensionality of a dataframe is totally known at compile time.DataFrame t (ds :: [XNat]
 some dimensions may be known at runtime only.
Parameter t
of a DataFrame can be arbitrary type that has an instance of PrimBytes
.
PrimBytes
typeclass can be automatically derived using Generics
.
This mechanics allows creating interleaved arrays, e.g. DataFrame (Double, Float, Float) ds
.
Parameter t
of a DataFrame
can also be a list of PrimBytes
types:
this way, DataFrame
consists of several "columns" or "variables" of different types and same dimensionality.
Behind the scenes all data types are implemented as primitive values or primitive byte arrays, aiming at maximum performance.
Tricky layers of newtypes and closed type families (which are not exposed to a user) allow some kind of adhoc polymorphism:
for example, Vector t n
implemented as ByteArray#
is overloaded by a specialized FloatX2 Float# Float#
in case of Vector Float 2
.
Supported GHC versions
The packages are tested on GHC 8.4+.
dimensions
may work on GHC 8.2, but the corresponding tests were dropped.
Support of easytensor
on GHC 8.2 was dropped due to:
 https://gitlab.haskell.org/ghc/ghc/issues/14058
 https://gitlab.haskell.org/ghc/ghc/issues/13188
 Annoying
Semigroup
Monoid
story
What have changed since version 1
Everything! In general, v2 of easytensor
is meant to show an expectable behavior:
 All
Show
andRead
instances look like automaticallygenerated instances for algebraic data types.  0based indexing instead of 1based indexing makes conversion between offsets, indices, and
Enum
more intuitive.  Order of dimensions in
Dims
list is reversed (the first dimension is "the most significant"), thus makingOrd
instances ofDims
andIdxs
coincide with conventional Haskell lexicographic ordering. The implication of this is the next two points. DataFrame
Ord
instances are now proper total lexicographic ordering.DataFrame
layout now is rowfirst instead of columnfirst. Therefore, to keep lowlevel SIMD optimizations of 3D geometry possible, I've had to transpose all matrices inHomTransform4
class.Nat
indexedDims
,Idxs
, andDataFrame
now haveGeneric
andData
instances that make these datatypes look like ordinary algebraic data types. More obvious ways to construct
DataFrame
s from pieces.  Removed all declarations and modules that may look controversial or do not belong here.
 Just added more tests and focused on the core functionality and correctness :)