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 s :: * -> *

Constructors

Origin

Instances

LtdErrorShow ℝ⁰

Refinable ℝ⁰

Eq (ZeroDim s)

Show (ZeroDim s)

Monoid (ZeroDim s)

VectorSpace (ZeroDim s)

AffineSpace (ZeroDim s)

HasBasis (ZeroDim s)

AdditiveGroup s => InnerSpace (ZeroDim s)

AdditiveGroup (ZeroDim s)

RieszDecomposable (ZeroDim ℝ)

(Fractional' s, SemiInner s) => SemiInner (ZeroDim s)

Num' s => FiniteDimensional (ZeroDim s)

Num' s => TensorSpace (ZeroDim s)

Num' s => LinearSpace (ZeroDim s)

PseudoAffine (ZeroDim k)

Semimanifold (ZeroDim k)

TensorDecomposable (ZeroDim ℝ)

Atlas (ZeroDim s)

Geodesic (ZeroDim s)

NumPrime s => LocallyCoercible (V0 s) (ZeroDim s)

NumPrime s => LocallyCoercible (ZeroDim s) (V0 s)

NumPrime s => LocallyCoercible (ZeroDim s) (ZeroDim s)

type Basis (ZeroDim k) = Void

type Diff (ZeroDim s) = ZeroDim s

type Scalar (ZeroDim s) = s

data SubBasis (ZeroDim s) = ZeroBasis

type DualVector (ZeroDim s) = ZeroDim s

type Interior (ZeroDim k) = ZeroDim k

type Needle (ZeroDim k) = ZeroDim k

type ChartIndex (ZeroDim s) = ()

type TensorProduct (ZeroDim s) v = ZeroDim s

type ℝ = Double

type ℝ⁰ = ZeroDim ℝ

type ℝ¹ = V1 ℝ

type ℝ² = V2 ℝ

type ℝ³ = V3 ℝ

type ℝ⁴ = V4 ℝ

Hyperspheres

General form: Stiefel manifolds

newtype Stiefel1 v

Constructors

Stiefel1

Fields

getStiefel1N :: DualVector v

Instances

(Geodesic v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), LinearSpace v, (~) * (Scalar v) ℝ, Geodesic (DualVector v), InnerSpace (DualVector v)) => Geodesic (Stiefel1 v)

type Interior (Stiefel1 v) = Stiefel1 v

type Needle (Stiefel1 v)

stiefel1Project

Arguments

:: LinearSpace v

=> DualVector v

Must be nonzero.

-> Stiefel1 v

stiefel1Embed :: (HilbertSpace v, RealFloat (Scalar v)) => Stiefel1 v -> v

Specific examples

class (PseudoAffine v, InnerSpace v, NaturallyEmbedded (UnitSphere v) (DualVector 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⁰ :: *

Constructors

PositiveHalfSphere

NegativeHalfSphere

Instances

Eq S⁰

Show S⁰

PseudoAffine S⁰

Semimanifold S⁰

Atlas S⁰

Geodesic S⁰

type Interior S⁰ = S⁰

type Needle S⁰ = ZeroDim ℝ

type ChartIndex S⁰ = S⁰

newtype S¹ :: *

Constructors

S¹

Fields

φParamS¹ :: Double

Instances

Show S¹

PseudoAffine S¹

Semimanifold S¹

Atlas S¹

Geodesic S¹

type Interior S¹ = S¹

type Needle S¹ = ℝ

type ChartIndex S¹ = S⁰

data S²

The ordinary unit sphere.

Constructors

S²

Fields

ϑParamS² :: !Double

Range [0, π[.

φParamS² :: !Double

Range [-π, π[.

Instances

Show S²

Atlas S²

type Interior S² = S²

type Needle S² = ℝ²

type ChartIndex 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²

type Interior ℝP² = ℝP²

type Needle ℝP² = ℝ²

Intervals/disks/cones

newtype D¹ :: *

Constructors

D¹

Fields

xParamD¹ :: Double

Instances

Show D¹

PseudoAffine D¹

Semimanifold D¹

IntervalLike D¹

type Interior D¹ = ℝ

type Needle 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

Show x => Show (CD¹ x)

type Interior (CD¹ m)

type Needle (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

Show x => Show (Cℝay x)

type Interior (Cℝay m)

type Needle (Cℝay m)

Affine subspaces

Lines

data Line x

Constructors

Line

Fields

lineHandle :: x

lineDirection :: Stiefel1 (Needle' x)

lineAsPlaneIntersection :: forall x. (WithField ℝ Manifold x, FiniteDimensional (Needle' 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 ℝ PseudoAffine x, LinearSpace (Needle x))

=> Cutplane x

Hyperplane to measure the distance from.

-> Metric' 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.

-> Maybe ℝ

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 ℝ PseudoAffine x, LinearSpace (Needle x)) => Cutplane x -> x -> Maybe S⁰

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

Linear mappings

data LinearMap s v w :: * -> * -> * -> *

Instances

Num' s => EnhancedCat (->) (LinearMap s)

(Show (SubBasis (DualVector u)), Show (SubBasis v)) => Show (SubBasis (LinearMap s u v))

Num' s => Morphism (LinearMap s)

Num' s => PreArrow (LinearMap s)

Category (LinearMap s)

Num' s => Cartesian (LinearMap s)

Num' s => EnhancedCat (LinearMap s) (LinearFunction s)

Num' s => EnhancedCat (LinearFunction s) (LinearMap s)

EnhancedCat (Affine s) (LinearMap s)

(Num' s, LinearSpace v, (~) * (Scalar v) s) => Monoidal (LinearMap s v) (LinearFunction s) (LinearFunction s)

(LinearSpace v, Num' s, (~) * (Scalar v) s) => Functor (LinearMap s v) (LinearFunction s) (LinearFunction s)

(LinearSpace v, (~) * (Scalar v) s) => Functor (LinearMap s v) (Coercion *) (Coercion *)

(LinearSpace v, TensorSpace w, (~) * (Scalar v) s, (~) * (Scalar w) s) => VectorSpace (LinearMap s v w)

(LinearSpace u, TensorSpace v, (~) * s (Scalar u), (~) * s (Scalar v)) => AffineSpace (LinearMap s u v)

(LinearSpace v, TensorSpace w, (~) * (Scalar v) s, (~) * (Scalar w) s) => AdditiveGroup (LinearMap s v w)

(LinearSpace u, SemiInner (DualVector u), SemiInner v, (~) * (Scalar u) s, (~) * (Scalar v) s) => SemiInner (LinearMap s u v)

(LSpace u, FiniteDimensional (DualVector u), FiniteDimensional v, (~) * (Scalar u) s, (~) * (Scalar v) s, (~) * (Scalar (DualVector v)) s, Fractional' (Scalar v)) => FiniteDimensional (LinearMap s u v)

(LinearSpace u, TensorSpace v, (~) * (Scalar u) s, (~) * (Scalar v) s) => TensorSpace (LinearMap s u v)

(LinearSpace u, LinearSpace v, (~) * (Scalar u) s, (~) * (Scalar v) s) => LinearSpace (LinearMap s u v)

(LinearSpace v, TensorSpace w, (~) * (Scalar v) s, (~) * (Scalar w) s) => PseudoAffine (LinearMap s v w)

(LinearSpace v, TensorSpace w, (~) * (Scalar v) s, (~) * (Scalar w) s) => Semimanifold (LinearMap s v w)

(LinearSpace v, (~) * (Scalar v) s, TensorSpace w, (~) * (Scalar w) s) => Atlas (LinearMap s v w)

(LinearSpace v, (~) * (Scalar v) ℝ, TensorSpace w, (~) * (Scalar w) ℝ) => Geodesic (LinearMap ℝ v w)

(SimpleSpace a, SimpleSpace b, Refinable a, Refinable b, (~) * (Scalar a) ℝ, (~) * (Scalar b) ℝ, (~) * (Scalar (DualVector a)) ℝ, (~) * (Scalar (DualVector b)) ℝ, (~) * (Scalar (DualVector (DualVector a))) ℝ, (~) * (Scalar (DualVector (DualVector b))) ℝ) => Refinable (LinearMap ℝ a b)

type UnitObject (LinearMap s) = ZeroDim s

type Object (LinearMap s) v = (LinearSpace v, (~) * (Scalar v) s)

type PairObjects (LinearMap s) a b = ()

type Diff (LinearMap s u v) = LinearMap s u v

type Scalar (LinearMap s v w) = s

data SubBasis (LinearMap s u v) = LinMapBasis !(SubBasis (DualVector u)) !(SubBasis v)

type DualVector (LinearMap s u v) = Tensor s u (DualVector v)

type Interior (LinearMap s v w) = LinearMap s v w

type Needle (LinearMap s v w) = LinearMap s v w

type ChartIndex (LinearMap s v w) = ()

type TensorProduct (LinearMap s u v) w = TensorProduct (DualVector u) (Tensor s v w)

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

Misc

type StiefelScalar s = (RealFloat s, Unbox s)