Data.Manifold.Types

Several commonly-used manifolds, represented in some simple way as Haskell data types. All these are in the PseudoAffine class.

Index / ASCII names

type Real0 = ℝ⁰

type Real1 = ℝ

type RealPlus = ℝay

type Real2 = ℝ²

type Real3 = ℝ³

type Sphere0 = S⁰

type Sphere1 = S¹

type Sphere2 = S²

type Projective1 = ℝP¹

type Projective2 = ℝP²

type Disk1 = D¹

type Disk2 = D²

type Cone = CD¹

type OpenCone = Cℝay

Linear manifolds

data ZeroDim k

A single point. Can be considered a zero-dimensional vector space, WRT any scalar.

Constructors

Origin

Instances

Eq (ZeroDim k)

Show (ZeroDim k)

Monoid (ZeroDim k)

AffineSpace (ZeroDim k)

HasBasis (ZeroDim k)

VectorSpace (ZeroDim k)

AdditiveGroup (ZeroDim k)

SmoothScalar k => FiniteDimensional (ZeroDim k)

MetricScalar k => HasMetric' (ZeroDim k)

PseudoAffine (ZeroDim k)

Semimanifold (ZeroDim k)

IntervalLike (Cℝay ℝ⁰)

IntervalLike (CD¹ ℝ⁰)

Geodesic (Cℝay ℝ⁰)

Geodesic (CD¹ ℝ⁰)

Geodesic (ZeroDim ℝ)

type Diff (ZeroDim k) = ZeroDim k

type Basis (ZeroDim k) = Void

type Scalar (ZeroDim k) = k

type DualSpace (ZeroDim k) = ZeroDim k

type Needle (ZeroDim k) = ZeroDim k

type Interior (ZeroDim k) = ZeroDim k

type ℝ⁰ = ZeroDim ℝ

type ℝ = Double

type ℝ² = (ℝ, ℝ)

type ℝ³ = (ℝ², ℝ)

Hyperspheres

General form: Stiefel manifolds

data Stiefel1 v

The n-th Stiefel manifold is the space of all possible configurations of n orthonormal vectors. In the case n = 1, simply the subspace of normalised vectors, i.e. equivalent to the UnitSphere. Even so, it strictly speaking requires the containing space to be at least metric (if not Hilbert); we would however like to be able to use this concept also in spaces with no inner product, therefore we define this space not as normalised vectors, but rather as all vectors modulo scaling by positive factors.

Instances

(Geodesic v, WithField ℝ HilbertSpace v) => Geodesic (Stiefel1 v)

type Needle (Stiefel1 v)

type Interior (Stiefel1 v) = Stiefel1 v

stiefel1Project

Arguments

:: LinearManifold v

=> DualSpace v

Must be nonzero.

-> Stiefel1 v

stiefel1Embed :: HilbertSpace v => Stiefel1 v -> v

Specific examples

class (PseudoAffine v, InnerSpace v, NaturallyEmbedded (UnitSphere v) (DualSpace v)) => HasUnitSphere v where

Minimal complete definition

Nothing

Associated Types

type UnitSphere v :: *

Methods

stiefel :: UnitSphere v -> Stiefel1 v

unstiefel :: Stiefel1 v -> UnitSphere v

Instances

HasUnitSphere ℝ³

HasUnitSphere ℝ²

HasUnitSphere ℝ

data S⁰

The zero-dimensional sphere is actually just two points. Implementation might therefore change to ℝ⁰ + ℝ⁰: the disjoint sum of two single-point spaces.

Constructors

PositiveHalfSphere

NegativeHalfSphere

Instances

Eq S⁰

Show S⁰

PseudoAffine S⁰

Semimanifold S⁰

Geodesic S⁰

IntervalLike (Cℝay S⁰)

IntervalLike (CD¹ S⁰)

Geodesic (Cℝay S⁰)

Geodesic (CD¹ S⁰)

type Needle S⁰ = ℝ⁰

type Interior S⁰ = S⁰

newtype S¹

The unit circle.

Constructors

S¹

Fields

φParamS¹ :: Double

Must be in range [-π, π[.

Instances

Show S¹

PseudoAffine S¹

Semimanifold S¹

Geodesic S¹

Geodesic (Cℝay S¹)

Geodesic (CD¹ S¹)

type Needle S¹ = ℝ

type Interior S¹ = S¹

data S²

The ordinary unit sphere.

Constructors

S²

Fields

ϑParamS² :: !Double

Range [0, π[.

φParamS² :: !Double

Range [-π, π[.

Instances

Show S²

PseudoAffine S²

Semimanifold S²

Geodesic (Cℝay S²)

Geodesic (CD¹ S²)

type Needle S² = ℝ²

type Interior S² = S²

Projective spaces

type ℝP¹ = S¹

data ℝP²

The two-dimensional real projective space, implemented as a unit disk with opposing points on the rim glued together.

Constructors

ℝP²

Fields

rParamℝP² :: !Double

Range [0, 1].

φParamℝP² :: !Double

Range [-π, π[.

Instances

Show ℝP²

PseudoAffine ℝP²

Semimanifold ℝP²

type Needle ℝP² = ℝ²

type Interior ℝP² = ℝP²

Intervals/disks/cones

newtype D¹

The “one-dimensional disk” – really just the line segment between the two points -1 and 1 of 'S⁰', i.e. this is simply a closed interval.

Constructors

D¹

Fields

xParamD¹ :: Double

Range [-1, 1].

Instances

PseudoAffine D¹

Semimanifold D¹

IntervalLike D¹

type Needle D¹ = ℝ

type Interior D¹ = ℝ

data D²

The standard, closed unit disk. Homeomorphic to the cone over 'S¹', but not in the the obvious, “flat” way. (And not at all, despite the identical ADT definition, to the projective space 'ℝP²'!)

Constructors

D²

Fields

rParamD² :: !Double

Range [0, 1].

φParamD² :: !Double

Range [-π, π[.

Instances

Show D²

type ℝay = Cℝay ℝ⁰

Better known as ℝ⁺ (which is not a legal Haskell name), the ray of positive numbers (including zero, i.e. closed on one end).

data CD¹ x

A (closed) cone over a space x is the product of x with the closed interval 'D¹' of “heights”, except on its “tip”: here, x is smashed to a single point.

This construct becomes (homeomorphic-to-) an actual geometric cone (and to 'D²') in the special case x = 'S¹'.

Constructors

CD¹

Fields

hParamCD¹ :: !Double

Range [0, 1]

pParamCD¹ :: !x

Irrelevant at h = 0.

Instances

IntervalLike (CD¹ ℝ⁰)

IntervalLike (CD¹ S⁰)

(WithField ℝ HilbertSpace a, WithField ℝ HilbertSpace b, Geodesic (a, b)) => Geodesic (CD¹ (a, b))

Geodesic (CD¹ ℝ)

Geodesic (CD¹ ℝ⁰)

Geodesic (CD¹ S²)

Geodesic (CD¹ S¹)

Geodesic (CD¹ S⁰)

type Needle (CD¹ m)

type Interior (CD¹ m)

data Cℝay x

An open cone is homeomorphic to a closed cone without the “lid”, i.e. without the “last copy” of x, at the far end of the height interval. Since that means the height does not include its supremum, it is actually more natural to express it as the entire real ray, hence the name.

Constructors

Cℝay

Fields

hParamCℝay :: !Double

Range [0, ∞[

pParamCℝay :: !x

Irrelevant at h = 0.

Instances

IntervalLike (Cℝay ℝ⁰)

IntervalLike (Cℝay S⁰)

(WithField ℝ HilbertSpace a, WithField ℝ HilbertSpace b, Geodesic (a, b)) => Geodesic (Cℝay (a, b))

Geodesic (Cℝay ℝ)

Geodesic (Cℝay ℝ⁰)

Geodesic (Cℝay S²)

Geodesic (Cℝay S¹)

Geodesic (Cℝay S⁰)

type Needle (Cℝay m)

type Interior (Cℝay m)

Affine subspaces

Lines

data Line x

Constructors

Line

Fields

lineHandle :: x

lineDirection :: Stiefel1 (Needle' x)

lineAsPlaneIntersection :: WithField ℝ Manifold x => Line x -> [Cutplane x]

Hyperplanes

data Cutplane x

Oriented hyperplanes, naïvely generalised to PseudoAffine manifolds: Cutplane p w represents the set of all points q such that (q.-~.p) ^<.> w ≡ 0.

In vector spaces this is indeed a hyperplane; for general manifolds it should behave locally as a plane, globally as an (n−1)-dimensional submanifold.

Constructors

Cutplane

Fields

sawHandle :: x

cutNormal :: Stiefel1 (Needle x)

fathomCutDistance

Arguments

:: WithField ℝ Manifold x

=> Cutplane x

Hyperplane to measure the distance from.

-> HerMetric' (Needle x)

Metric to use for measuring that distance. This can only be accurate if the metric is valid both around the cut-plane's sawHandle, and around the points you measure. (Strictly speaking, we would need parallel transport to ensure this).

-> x

Point to measure the distance to.

-> Option ℝ

A signed number, giving the distance from plane to point with indication on which side the point lies. Nothing if the point isn't reachable from the plane.

sideOfCut :: WithField ℝ Manifold x => Cutplane x -> x -> Option S⁰

cutPosBetween :: WithField ℝ Manifold x => Cutplane x -> (x, x) -> Option D¹

Linear mappings

data Linear s a b

A linear mapping between finite-dimensional spaces, implemeted as a dense matrix.

Note that this is equivalent to the tensor product DualSpace a ⊗ b. One of the types should be deprecated in the future, or either implemented in terms of the other.

Instances

SmoothScalar s => EnhancedCat (->) (Linear s)

SmoothScalar s => Morphism (Linear s)

SmoothScalar s => PreArrow (Linear s)

SmoothScalar s => CartesianAgent (Linear s)

SmoothScalar s => Category (Linear s)

SmoothScalar s => Cartesian (Linear s)

SmoothScalar s => HasAgent (Linear s)

(FiniteDimensional v, (~) * (Scalar v) s, FiniteDimensional w, (~) * (Scalar w) s, SmoothScalar s) => AffineSpace (Linear s v w)

(FiniteDimensional v, (~) * (Scalar v) s, FiniteDimensional w, (~) * (Scalar w) s, SmoothScalar s) => HasBasis (Linear s v w)

(FiniteDimensional v, (~) * (Scalar v) s, FiniteDimensional w, (~) * (Scalar w) s, SmoothScalar s) => VectorSpace (Linear s v w)

(FiniteDimensional v, (~) * (Scalar v) s, FiniteDimensional w, (~) * (Scalar w) s, SmoothScalar s) => AdditiveGroup (Linear s v w)

(FiniteDimensional v, (~) * (Scalar v) s, FiniteDimensional w, (~) * (Scalar w) s) => FiniteDimensional (Linear s v w)

(HasMetric v, HasMetric w, (~) * s (Scalar v), (~) * s (Scalar w)) => HasMetric' (Linear s v w)

(HasMetric a, FiniteDimensional b, (~) * (Scalar a) s, (~) * (Scalar b) s) => PseudoAffine (Linear s a b)

(HasMetric a, FiniteDimensional b, (~) * (Scalar a) s, (~) * (Scalar b) s) => Semimanifold (Linear s a b)

type UnitObject (Linear s) = ZeroDim s

type Object (Linear s) v = (FiniteDimensional v, (~) * (Scalar v) s)

type PairObjects (Linear s) a b = ()

type AgentVal (Linear s) a v = GenericAgent (Linear s) a v

type Diff (Linear s v w) = Linear s v w

type Basis (Linear s v w) = (Basis v, Basis w)

type Scalar (Linear s v w) = s

type DualSpace (Linear s v w) = Linear s w v

type Needle (Linear s a b) = Linear s a b

type Interior (Linear s a b) = Linear s a b

type LocalLinear x y = Linear (Scalar (Needle x)) (Needle x) (Needle y)

denseLinear :: forall v w s. (FiniteDimensional v, FiniteDimensional w, Scalar w ~ s) => (v -> w) -> Linear s v w