| Copyright | (c) Justus Sagemüller 2015 |
|---|---|
| License | GPL v3 |
| Maintainer | (@) sagemueller $ geo.uni-koeln.de |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | None |
| Language | Haskell2010 |
Data.Manifold.Types
Contents
Description
Several commonly-used manifolds, represented in some simple way as Haskell
data types. All these are in the PseudoAffine class.
- type Real0 = ℝ⁰
- type Real1 = ℝ
- type RealPlus = ℝay
- type Real2 = ℝ²
- type Real3 = ℝ³
- type Sphere0 = S⁰
- type Sphere1 = S¹
- type Sphere2 = S²
- type Projective0 = ℝP⁰
- type Projective1 = ℝP¹
- type Projective2 = ℝP²
- type Disk1 = D¹
- type Disk2 = D²
- type Cone = CD¹
- type OpenCone = Cℝay
- data FibreBundle b f :: * -> * -> * = FibreBundle {
- baseSpace :: !b
- fibreSpace :: !f
- type TangentBundle m = FibreBundle m (Needle m)
- data ZeroDim s :: * -> * = Origin
- type ℝ = Double
- type ℝ⁰ = ZeroDim ℝ
- type ℝ¹ = V1 ℝ
- type ℝ² = V2 ℝ
- type ℝ³ = V3 ℝ
- type ℝ⁴ = V4 ℝ
- newtype Stiefel1 v = Stiefel1 {
- getStiefel1N :: DualVector v
- stiefel1Project :: LinearSpace v => DualVector v -> Stiefel1 v
- stiefel1Embed :: (HilbertSpace v, RealFloat (Scalar v)) => Stiefel1 v -> v
- class (PseudoAffine v, InnerSpace v, NaturallyEmbedded (UnitSphere v) (DualVector v)) => HasUnitSphere v where
- type UnitSphere v :: *
- data S⁰ :: *
- newtype S¹ :: * = S¹Polar {}
- pattern S¹ :: Double -> S¹
- data S² :: * = S²Polar {}
- pattern S² :: Double -> Double -> S²
- data ℝP⁰ :: * = ℝPZero
- newtype ℝP¹ :: * = HemisphereℝP¹Polar {}
- pattern ℝP¹ :: Double -> ℝP¹
- data ℝP² :: * = HemisphereℝP²Polar {}
- pattern ℝP² :: Double -> Double -> ℝP²
- newtype D¹ :: * = D¹ {}
- data D² :: * = D²Polar {}
- pattern D² :: Double -> Double -> D²
- type ℝay = Cℝay ℝ⁰
- data CD¹ x :: * -> * = CD¹ {}
- data Cℝay x :: * -> * = Cℝay {
- hParamCℝay :: !Double
- pParamCℝay :: !x
- data Line x = Line {
- lineHandle :: x
- lineDirection :: Stiefel1 (Needle' x)
- lineAsPlaneIntersection :: forall x. (WithField ℝ Manifold x, FiniteDimensional (Needle' x)) => Line x -> [Cutplane x]
- data Cutplane x = Cutplane {}
- normalPlane :: x -> Needle' x -> Cutplane x
- fathomCutDistance :: forall x. (WithField ℝ PseudoAffine x, LinearSpace (Needle x)) => Cutplane x -> Metric' x -> x -> Maybe ℝ
- sideOfCut :: (WithField ℝ PseudoAffine x, LinearSpace (Needle x)) => Cutplane x -> x -> Maybe S⁰
- cutPosBetween :: WithField ℝ Manifold x => Cutplane x -> (x, x) -> Maybe D¹
- data LinearMap s v w :: * -> * -> * -> *
- type LocalLinear x y = LinearMap (Scalar (Needle x)) (Needle x) (Needle y)
- type StiefelScalar s = (RealFloat s, Unbox s)
Index / ASCII names
type Projective0 = ℝP⁰ Source #
type Projective1 = ℝP¹ Source #
type Projective2 = ℝP² Source #
data FibreBundle b f :: * -> * -> * #
A fibre bundle combines points in the base space b with points in the fibre
f. The type FibreBundle b f is thus isomorphic to the tuple space (b,f), but
it can have a different topology, the prime example being TangentBundle, where
nearby points may have differently-oriented tangent spaces.
Constructors
| FibreBundle | |
Fields
| |
Instances
| (Show (CoordinateIdentifier b), Show (CoordinateIdentifier f), Eq b, Eq (CoordinateIdentifier f), Arbitrary b, Show b) => Show (CoordinateIdentifier (FibreBundle b f)) # | |
| (CoordDifferential m, (~) * f (Needle m), (~) * m (Interior m), Arbitrary m, Arbitrary (CoordinateIdentifier m), Arbitrary (CoordinateIdentifier f)) => Arbitrary (CoordinateIdentifier (FibreBundle m f)) # | |
| (Show f, Show b) => Show (FibreBundle b f) | |
| Generic (FibreBundle b f) | |
| (Connected x, Connected y, PseudoAffine (FibreBundle x y)) => Connected (FibreBundle x y) Source # | |
| (HasCoordinates b, HasCoordinates f) => HasCoordinates (FibreBundle b f) Source # | |
| type Rep (FibreBundle b f) | |
| type Interior (FibreBundle m f) # | |
| type Needle (FibreBundle m f) # | |
| type AxisSpace (FibreBundle S² ℝ²) # | |
| data CoordinateIdentifier (FibreBundle b f) Source # | |
type TangentBundle m = FibreBundle m (Needle m) #
Points on a manifold, combined with vectors in the respective tangent space.
Linear manifolds
Constructors
| Origin |
Instances
Hyperspheres
General form: Stiefel manifolds
Constructors
| Stiefel1 | |
Fields
| |
Instances
| Show (DualVector v) => Show (Stiefel1 v) Source # | |
| (Geodesic v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), LinearSpace v, (~) * (Scalar v) ℝ, Geodesic (DualVector v), InnerSpace (DualVector v)) => Geodesic (Stiefel1 v) Source # | |
| type Interior (Stiefel1 v) # | |
| type Needle (Stiefel1 v) # | |
Arguments
| :: LinearSpace v | |
| => DualVector v | Must be nonzero. |
| -> Stiefel1 v |
stiefel1Embed :: (HilbertSpace v, RealFloat (Scalar v)) => Stiefel1 v -> v Source #
Specific examples
class (PseudoAffine v, InnerSpace v, NaturallyEmbedded (UnitSphere v) (DualVector v)) => HasUnitSphere v where Source #
Associated Types
type UnitSphere v :: * Source #
Methods
stiefel :: UnitSphere v -> Stiefel1 v Source #
unstiefel :: Stiefel1 v -> UnitSphere v Source #
Instances
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 |
The unit circle.
Instances
| Eq S¹ | |
| Show S¹ | |
| Semimanifold S¹ | |
| PseudoAffine S¹ | |
| Rotatable S¹ | |
| Connected S¹ Source # | |
| Atlas S¹ Source # | |
| Geodesic S¹ Source # | |
| HasAzimuth S¹ Source # | |
| CoordDifferential S¹ Source # | |
| HasCoordinates S¹ Source # | |
| NaturallyEmbedded S¹ ℝ² Source # | |
| (Category k, Object k ℝ) => ParallelTransporting k S¹ ℝ Source # | |
| Eq (CoordinateIdentifier S¹) # | |
| Show (CoordinateIdentifier S¹) # | |
| Arbitrary (CoordinateIdentifier S¹) # | |
| type Interior S¹ | |
| type Needle S¹ | |
| type AxisSpace S¹ | |
| type ChartIndex S¹ Source # | |
| data CoordinateIdentifier S¹ Source # | |
The ordinary unit sphere.
Instances
| Eq S² | |
| Show S² | |
| Rotatable S² | |
| Connected S² Source # | |
| Atlas S² Source # | |
| HasZenithDistance S² Source # | |
| HasAzimuth S² Source # | |
| CoordDifferential S² Source # | |
| HasCoordinates S² Source # | |
| NaturallyEmbedded S² ℝ³ Source # | |
| (EnhancedCat k (LinearMap ℝ), Object k ℝ²) => ParallelTransporting k S² ℝ² Source # | |
| Eq (CoordinateIdentifier S²) # | |
| Show (CoordinateIdentifier S²) # | |
| Arbitrary (CoordinateIdentifier S²) # | |
| type Interior S² # | |
| type Needle S² # | |
| type AxisSpace S² | |
| type ChartIndex S² Source # | |
| data CoordinateIdentifier S² Source # | |
| type AxisSpace (FibreBundle S² ℝ²) # | |
Projective spaces
Constructors
| ℝPZero |
Constructors
| HemisphereℝP¹Polar | |
The two-dimensional real projective space, implemented as a disk with opposing points on the rim glued together. Image this disk as the northern hemisphere of a unit sphere; 'ℝP²' is the space of all straight lines passing through the origin of 'ℝ³', and each of these lines is represented by the point at which it passes through the hemisphere.
Constructors
| HemisphereℝP²Polar | |
Intervals/disks/cones
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.
Instances
| Show D¹ | |
| Semimanifold D¹ | |
| PseudoAffine D¹ | |
| IntervalLike D¹ Source # | |
| NaturallyEmbedded D¹ ℝ Source # | |
| type Interior D¹ | |
| type Needle D¹ | |
The standard, closed unit disk. Homeomorphic to the cone over 'S¹', but not in the the obvious, “flat” way. (In is not homeomorphic, despite the almost identical ADT definition, to the projective space 'ℝP²'!)
Better known as ℝ⁺ (which is not a legal Haskell name), the ray of positive numbers (including zero, i.e. closed on one end).
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¹'.
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
| |
Affine subspaces
Lines
Constructors
| Line | |
Fields
| |
lineAsPlaneIntersection :: forall x. (WithField ℝ Manifold x, FiniteDimensional (Needle' x)) => Line x -> [Cutplane x] Source #
Hyperplanes
Oriented hyperplanes, naïvely generalised to PseudoAffine manifolds:
Cutplane p wq 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.
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 |
| -> 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.
|
sideOfCut :: (WithField ℝ PseudoAffine x, LinearSpace (Needle x)) => Cutplane x -> x -> Maybe S⁰ Source #
Linear mappings
data LinearMap s v w :: * -> * -> * -> * #
The tensor product between one space's dual space and another space is the space spanned by vector–dual-vector pairs, in bra-ket notation written as
m = ∑ |w⟩⟨v|
Any linear mapping can be written as such a (possibly infinite) sum. The
TensorProduct data structure only stores the linear independent parts
though; for simple finite-dimensional spaces this means e.g. LinearMap ℝ ℝ³ ℝ³|w⟩.
(The ⟨v| dual-vectors are then simply assumed to come from the canonical basis.)
For bigger spaces, the tensor product may be implemented in a more efficient
sparse structure; this can be defined in the TensorSpace instance.
Instances
Misc
type StiefelScalar s = (RealFloat s, Unbox s) Source #
Orphan instances
| (LinearSpace v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), StiefelScalar (Scalar v)) => Semimanifold (Stiefel1 v) Source # | |
| (LinearSpace v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), StiefelScalar (Scalar v)) => PseudoAffine (Stiefel1 v) Source # | |