Data.Manifold.PseudoAffine

This is the second prototype of a manifold class. It appears to give considerable advantages over Manifold, so that class will probably soon be replaced with the one we define here (though PseudoAffine does not follow the standard notion of a manifold very closely, it should work quite equivalently for pretty much all Haskell types that qualify as manifolds).

Manifolds are interesting as objects of various categories, from continuous to diffeomorphic. At the moment, we mainly focus on region-wise differentiable functions, which are a promising compromise between flexibility of definition and provability of analytic properties. In particular, they are well-suited for visualisation purposes.

The classes in this module are mostly aimed at manifolds without boundary. Manifolds with boundary (which we call MWBound, never manifold!) are more or less treated as a disjoint sum of the interior and the boundary. To understand how this module works, best first forget about boundaries – in this case, Interior x ~ x, fromInterior and toInterior are trivial, and .+~|, |-~. and betweenBounds are irrelevant. The manifold structure of the boundary itself is not considered at all here.

Manifold class

class (OpenManifold m, ProjectableBoundary m, LSpace (Needle m)) => Manifold m

See Semimanifold and PseudoAffine for the methods. As a Manifold we understand a pseudo-affine space whose Needle space is a well-behaved vector space that is isomorphic to all of the manifold's tangent spaces. It must also be an instance of the SemimanifoldWithBoundary class with explicitly empty boundary (in other words, with no boundary).

Instances

(OpenManifold m, ProjectableBoundary m, LSpace (Needle m)) => Manifold m

Defined in Data.Manifold.PseudoAffine

class AdditiveGroup (Needle x) => Semimanifold x where

Minimal complete definition

Nothing

Associated Types

type Needle x

The space of “ways” starting from some reference point and going to some particular target point. Hence, the name: like a compass needle, but also with an actual length. For affine spaces, Needle is simply the space of line segments (aka vectors) between two points, i.e. the same as Diff. The AffineManifold constraint makes that requirement explicit.

This space should be isomorphic to the tangent space (and in fact serves an in many ways similar role), however whereas the tangent space of a manifold is really infinitesimally small, needles actually allow macroscopic displacements.

type Needle x = GenericNeedle x

Methods

(.+~^) :: x -> Needle x -> x infixl 6

Generalisation of the translation operation .+^ to possibly non-flat manifolds, instead of affine spaces.

(.-~^) :: x -> Needle x -> x infixl 6

Shorthand for \p v -> p .+~^ negateV v, which should obey the asymptotic law

p .-~^ v .+~^ v ≅ p

Meaning: if v is scaled down with sufficiently small factors η, then the difference (p.-~^v.+~^v) .-~. p should eventually scale down even faster: as O (η²). For large vectors, it may however behave differently, except in flat spaces (where all this should be equivalent to the AffineSpace instance).

semimanifoldWitness :: SemimanifoldWitness x

Instances

Semimanifold Rational

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle Rational

Methods

(.+~^) :: Rational -> Needle Rational -> Rational

(.-~^) :: Rational -> Needle Rational -> Rational

semimanifoldWitness :: SemimanifoldWitness Rational

Semimanifold ℝP²

Defined in Data.Manifold.PseudoAffine

Associated Types

type Needle ℝP²

Methods

(.+~^) :: ℝP² -> Needle ℝP² -> ℝP²

(.-~^) :: ℝP² -> Needle ℝP² -> ℝP²

semimanifoldWitness :: SemimanifoldWitness ℝP²

Semimanifold Double

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle Double

Methods

(.+~^) :: Double -> Needle Double -> Double

(.-~^) :: Double -> Needle Double -> Double

semimanifoldWitness :: SemimanifoldWitness Double

Semimanifold Float

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle Float

Methods

(.+~^) :: Float -> Needle Float -> Float

(.-~^) :: Float -> Needle Float -> Float

semimanifoldWitness :: SemimanifoldWitness Float

AdditiveGroup (DualVector (Needle (VRep m))) => Semimanifold (GenericNeedle' m)

Defined in Math.LinearMap.Category.Class

Associated Types

type Needle (GenericNeedle' m)

Methods

(.+~^) :: GenericNeedle' m -> Needle (GenericNeedle' m) -> GenericNeedle' m

(.-~^) :: GenericNeedle' m -> Needle (GenericNeedle' m) -> GenericNeedle' m

semimanifoldWitness :: SemimanifoldWitness (GenericNeedle' m)

AdditiveGroup v => Semimanifold (DualVectorFromBasis v)

Defined in Math.LinearMap.Category.Instances.Deriving

Associated Types

type Needle (DualVectorFromBasis v)

Methods

(.+~^) :: DualVectorFromBasis v -> Needle (DualVectorFromBasis v) -> DualVectorFromBasis v

(.-~^) :: DualVectorFromBasis v -> Needle (DualVectorFromBasis v) -> DualVectorFromBasis v

semimanifoldWitness :: SemimanifoldWitness (DualVectorFromBasis v)

(PseudoAffine x, VectorSpace (Needle x)) => Semimanifold (Shade x)

Defined in Data.Manifold.Shade

Associated Types

type Needle (Shade x)

Methods

(.+~^) :: Shade x -> Needle (Shade x) -> Shade x

(.-~^) :: Shade x -> Needle (Shade x) -> Shade x

semimanifoldWitness :: SemimanifoldWitness (Shade x)

AffineManifold x => Semimanifold (Shade' x)

Defined in Data.Manifold.Shade

Associated Types

type Needle (Shade' x)

Methods

(.+~^) :: Shade' x -> Needle (Shade' x) -> Shade' x

(.-~^) :: Shade' x -> Needle (Shade' x) -> Shade' x

semimanifoldWitness :: SemimanifoldWitness (Shade' x)

(LinearSpace v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), StiefelScalar (Scalar v)) => Semimanifold (Stiefel1 v)

Defined in Data.Manifold.Types

Associated Types

type Needle (Stiefel1 v)

Methods

(.+~^) :: Stiefel1 v -> Needle (Stiefel1 v) -> Stiefel1 v

(.-~^) :: Stiefel1 v -> Needle (Stiefel1 v) -> Stiefel1 v

semimanifoldWitness :: SemimanifoldWitness (Stiefel1 v)

AdditiveGroup (Needle (VRep x)) => Semimanifold (GenericNeedle x)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (GenericNeedle x)

Methods

(.+~^) :: GenericNeedle x -> Needle (GenericNeedle x) -> GenericNeedle x

(.-~^) :: GenericNeedle x -> Needle (GenericNeedle x) -> GenericNeedle x

semimanifoldWitness :: SemimanifoldWitness (GenericNeedle x)

RealFloat' s => Semimanifold (S²_ s)

Defined in Data.Manifold.PseudoAffine

Associated Types

type Needle (S²_ s)

Methods

(.+~^) :: S²_ s -> Needle (S²_ s) -> S²_ s

(.-~^) :: S²_ s -> Needle (S²_ s) -> S²_ s

semimanifoldWitness :: SemimanifoldWitness (S²_ s)

RealFloat' r => Semimanifold (S¹_ r)

Defined in Data.Manifold.PseudoAffine

Associated Types

type Needle (S¹_ r)

Methods

(.+~^) :: S¹_ r -> Needle (S¹_ r) -> S¹_ r

(.-~^) :: S¹_ r -> Needle (S¹_ r) -> S¹_ r

semimanifoldWitness :: SemimanifoldWitness (S¹_ r)

RealFloat' r => Semimanifold (S⁰_ r)

Defined in Data.Manifold.PseudoAffine

Associated Types

type Needle (S⁰_ r)

Methods

(.+~^) :: S⁰_ r -> Needle (S⁰_ r) -> S⁰_ r

(.-~^) :: S⁰_ r -> Needle (S⁰_ r) -> S⁰_ r

semimanifoldWitness :: SemimanifoldWitness (S⁰_ r)

ℝeal r => Semimanifold (ℝP¹_ r)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (ℝP¹_ r)

Methods

(.+~^) :: ℝP¹_ r -> Needle (ℝP¹_ r) -> ℝP¹_ r

(.-~^) :: ℝP¹_ r -> Needle (ℝP¹_ r) -> ℝP¹_ r

semimanifoldWitness :: SemimanifoldWitness (ℝP¹_ r)

Semimanifold (ℝP⁰_ r)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (ℝP⁰_ r)

Methods

(.+~^) :: ℝP⁰_ r -> Needle (ℝP⁰_ r) -> ℝP⁰_ r

(.-~^) :: ℝP⁰_ r -> Needle (ℝP⁰_ r) -> ℝP⁰_ r

semimanifoldWitness :: SemimanifoldWitness (ℝP⁰_ r)

Semimanifold (ZeroDim k)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (ZeroDim k)

Methods

(.+~^) :: ZeroDim k -> Needle (ZeroDim k) -> ZeroDim k

(.-~^) :: ZeroDim k -> Needle (ZeroDim k) -> ZeroDim k

semimanifoldWitness :: SemimanifoldWitness (ZeroDim k)

(LinearSpace (a n), Needle (a n) ~ a n) => Semimanifold (Point a n)

Defined in Data.Manifold.PseudoAffine

Associated Types

type Needle (Point a n)

Methods

(.+~^) :: Point a n -> Needle (Point a n) -> Point a n

(.-~^) :: Point a n -> Needle (Point a n) -> Point a n

semimanifoldWitness :: SemimanifoldWitness (Point a n)

(Generic1 f, TensorSpace y, TensorSpace (f y), Scalar (f y) ~ Scalar y, Monoidal f (LinearFunction (Scalar y)) (LinearFunction (Scalar y))) => Semimanifold (LinearApplicativeSpace f y)

Defined in Math.LinearMap.Category.Instances

Associated Types

type Needle (LinearApplicativeSpace f y)

Methods

(.+~^) :: LinearApplicativeSpace f y -> Needle (LinearApplicativeSpace f y) -> LinearApplicativeSpace f y

(.-~^) :: LinearApplicativeSpace f y -> Needle (LinearApplicativeSpace f y) -> LinearApplicativeSpace f y

semimanifoldWitness :: SemimanifoldWitness (LinearApplicativeSpace f y)

(TensorSpace v, Scalar v ~ s) => Semimanifold (SymmetricTensor s v)

Defined in Math.LinearMap.Category.Instances

Associated Types

type Needle (SymmetricTensor s v)

Methods

(.+~^) :: SymmetricTensor s v -> Needle (SymmetricTensor s v) -> SymmetricTensor s v

(.-~^) :: SymmetricTensor s v -> Needle (SymmetricTensor s v) -> SymmetricTensor s v

semimanifoldWitness :: SemimanifoldWitness (SymmetricTensor s v)

(AbstractLinearSpace a, VectorSpaceImplementation a ~ c, AdditiveGroup (DualVector c)) => Semimanifold (AbstractDualVector a c)

Defined in Math.LinearMap.Category.Instances.Deriving

Associated Types

type Needle (AbstractDualVector a c)

Methods

(.+~^) :: AbstractDualVector a c -> Needle (AbstractDualVector a c) -> AbstractDualVector a c

(.-~^) :: AbstractDualVector a c -> Needle (AbstractDualVector a c) -> AbstractDualVector a c

semimanifoldWitness :: SemimanifoldWitness (AbstractDualVector a c)

Semimanifold x => Semimanifold (WithAny x y)

Defined in Data.Manifold.Shade

Associated Types

type Needle (WithAny x y)

Methods

(.+~^) :: WithAny x y -> Needle (WithAny x y) -> WithAny x y

(.-~^) :: WithAny x y -> Needle (WithAny x y) -> WithAny x y

semimanifoldWitness :: SemimanifoldWitness (WithAny x y)

(ParallelTransporting (->) m f, Semimanifold f, ParallelTransporting (LinearFunction s) (Needle m) (Needle f), s ~ Scalar (Needle m)) => Semimanifold (FibreBundle m f)

Defined in Data.Manifold.FibreBundle

Associated Types

type Needle (FibreBundle m f)

Methods

(.+~^) :: FibreBundle m f -> Needle (FibreBundle m f) -> FibreBundle m f

(.-~^) :: FibreBundle m f -> Needle (FibreBundle m f) -> FibreBundle m f

semimanifoldWitness :: SemimanifoldWitness (FibreBundle m f)

(Semimanifold a, Semimanifold b) => Semimanifold (a, b)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (a, b)

Methods

(.+~^) :: (a, b) -> Needle (a, b) -> (a, b)

(.-~^) :: (a, b) -> Needle (a, b) -> (a, b)

semimanifoldWitness :: SemimanifoldWitness (a, b)

Semimanifold a => Semimanifold (Rec0 a s)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (Rec0 a s)

Methods

(.+~^) :: Rec0 a s -> Needle (Rec0 a s) -> Rec0 a s

(.-~^) :: Rec0 a s -> Needle (Rec0 a s) -> Rec0 a s

semimanifoldWitness :: SemimanifoldWitness (Rec0 a s)

VectorSpace w => Semimanifold (LinearFunction s v w)

Defined in Math.LinearMap.Asserted

Associated Types

type Needle (LinearFunction s v w)

Methods

(.+~^) :: LinearFunction s v w -> Needle (LinearFunction s v w) -> LinearFunction s v w

(.-~^) :: LinearFunction s v w -> Needle (LinearFunction s v w) -> LinearFunction s v w

semimanifoldWitness :: SemimanifoldWitness (LinearFunction s v w)

(AdditiveGroup (DualVector (f p)), AdditiveGroup (DualVector (g p))) => Semimanifold (GenericTupleDual f g p)

Defined in Math.LinearMap.Category.Class

Associated Types

type Needle (GenericTupleDual f g p)

Methods

(.+~^) :: GenericTupleDual f g p -> Needle (GenericTupleDual f g p) -> GenericTupleDual f g p

(.-~^) :: GenericTupleDual f g p -> Needle (GenericTupleDual f g p) -> GenericTupleDual f g p

semimanifoldWitness :: SemimanifoldWitness (GenericTupleDual f g p)

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

Defined in Math.LinearMap.Category.Class

Associated Types

type Needle (LinearMap s v w)

Methods

(.+~^) :: LinearMap s v w -> Needle (LinearMap s v w) -> LinearMap s v w

(.-~^) :: LinearMap s v w -> Needle (LinearMap s v w) -> LinearMap s v w

semimanifoldWitness :: SemimanifoldWitness (LinearMap s v w)

(TensorSpace v, TensorSpace w, Scalar v ~ s, Scalar w ~ s) => Semimanifold (Tensor s v w)

Defined in Math.LinearMap.Category.Class

Associated Types

type Needle (Tensor s v w)

Methods

(.+~^) :: Tensor s v w -> Needle (Tensor s v w) -> Tensor s v w

(.-~^) :: Tensor s v w -> Needle (Tensor s v w) -> Tensor s v w

semimanifoldWitness :: SemimanifoldWitness (Tensor s v w)

(Atlas x, HasTrie (ChartIndex x), Manifold y, LinearManifold (Needle x), Scalar (Needle x) ~ s, LinearManifold (Needle y), Scalar (Needle y) ~ s) => Semimanifold (Affine s x y)

Defined in Data.Function.Affine

Associated Types

type Needle (Affine s x y)

Methods

(.+~^) :: Affine s x y -> Needle (Affine s x y) -> Affine s x y

(.-~^) :: Affine s x y -> Needle (Affine s x y) -> Affine s x y

semimanifoldWitness :: SemimanifoldWitness (Affine s x y)

(Semimanifold (f p), Semimanifold (g p)) => Semimanifold (NeedleProductSpace f g p)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (NeedleProductSpace f g p)

Methods

(.+~^) :: NeedleProductSpace f g p -> Needle (NeedleProductSpace f g p) -> NeedleProductSpace f g p

(.-~^) :: NeedleProductSpace f g p -> Needle (NeedleProductSpace f g p) -> NeedleProductSpace f g p

semimanifoldWitness :: SemimanifoldWitness (NeedleProductSpace f g p)

(Semimanifold a, Semimanifold b, Semimanifold c) => Semimanifold (a, b, c)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (a, b, c)

Methods

(.+~^) :: (a, b, c) -> Needle (a, b, c) -> (a, b, c)

(.-~^) :: (a, b, c) -> Needle (a, b, c) -> (a, b, c)

semimanifoldWitness :: SemimanifoldWitness (a, b, c)

(Semimanifold (f p), Semimanifold (g p)) => Semimanifold ((f :*: g) p)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle ((f :*: g) p)

Methods

(.+~^) :: (f :*: g) p -> Needle ((f :*: g) p) -> (f :*: g) p

(.-~^) :: (f :*: g) p -> Needle ((f :*: g) p) -> (f :*: g) p

semimanifoldWitness :: SemimanifoldWitness ((f :*: g) p)

Semimanifold (f p) => Semimanifold (M1 i c f p)

Defined in Math.Manifold.Core.PseudoAffine

Associated Types

type Needle (M1 i c f p)

Methods

(.+~^) :: M1 i c f p -> Needle (M1 i c f p) -> M1 i c f p

(.-~^) :: M1 i c f p -> Needle (M1 i c f p) -> M1 i c f p

semimanifoldWitness :: SemimanifoldWitness (M1 i c f p)

type Needle' x = DualVector (Needle x)

A co-needle can be understood as a “paper stack”, with which you can measure the length that a needle reaches in a given direction by counting the number of holes punched through them.

class Semimanifold x => PseudoAffine x where

This is the class underlying what we understand as manifolds.

The interface is almost identical to the better-known AffineSpace class, but we don't require associativity of .+~^ with ^+^ – except in an asymptotic sense for small vectors.

That innocent-looking change makes the class applicable to vastly more general types: while an affine space is basically nothing but a vector space without particularly designated origin, a pseudo-affine space can have nontrivial topology on the global scale, and yet be used in practically the same way as an affine space. At least the usual spheres and tori make good instances, perhaps the class is in fact equivalent to manifolds in their usual maths definition (with an atlas of charts: a family of overlapping regions of the topological space, each homeomorphic to the Needle vector space or some simply-connected subset thereof).

The Semimanifold and PseudoAffine classes can be anyclass-derived or empty-instantiated based on Generic for product types (including newtypes) of existing PseudoAffine instances. For example, the definition

data Cylinder = CylinderPolar { zCyl :: !D¹, φCyl :: !S¹ }
  deriving (Generic, Semimanifold, PseudoAffine)

is equivalent to

data Cylinder = CylinderPolar { zCyl :: !D¹, φCyl :: !S¹ }

data CylinderNeedle = CylinderPolarNeedle { δzCyl :: !(Needle D¹), δφCyl :: !(Needle S¹) }

instance Semimanifold Cylinder where
  type Needle Cylinder = CylinderNeedle
  CylinderPolar z φ .+~^ CylinderPolarNeedle δz δφ
       = CylinderPolar (z.+~^δz) (φ.+~^δφ)

instance PseudoAffine Cylinder where
  CylinderPolar z₁ φ₁ .-~. CylinderPolar z₀ φ₀
       = CylinderPolarNeedle $ z₁.-~.z₀ * φ₁.-~.φ₀
  CylinderPolar z₁ φ₁ .-~! CylinderPolar z₀ φ₀
       = CylinderPolarNeedle (z₁.-~!z₀) (φ₁.-~.φ₀)

Minimal complete definition

Nothing

Methods

(.-~.) :: x -> x -> Maybe (Needle x) infix 6

The path reaching from one point to another. Should only yield Nothing if the points are on disjoint segments of a non–path-connected space.

For a connected manifold, you may define this method as

  p.-~.q = pure (p.-~!q)

(.-~!) :: x -> x -> Needle x infix 6

Unsafe version of .-~.. If the two points lie in disjoint regions, the behaviour is undefined.

Whenever p and q lie in a connected region, the identity

p .+~^ (q.-~.p) ≡ q

should hold (up to possible floating point rounding etc.). Meanwhile, you will in general have

(p.+~^v).-~^v ≠ p

(though in many instances this is at least for sufficiently small v approximately equal).

pseudoAffineWitness :: PseudoAffineWitness x

Instances

PseudoAffine Rational

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: Rational -> Rational -> Maybe (Needle Rational)

(.-~!) :: Rational -> Rational -> Needle Rational

pseudoAffineWitness :: PseudoAffineWitness Rational

PseudoAffine ℝP²

Defined in Data.Manifold.PseudoAffine

Methods

(.-~.) :: ℝP² -> ℝP² -> Maybe (Needle ℝP²)

(.-~!) :: ℝP² -> ℝP² -> Needle ℝP²

pseudoAffineWitness :: PseudoAffineWitness ℝP²

PseudoAffine Double

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: Double -> Double -> Maybe (Needle Double)

(.-~!) :: Double -> Double -> Needle Double

pseudoAffineWitness :: PseudoAffineWitness Double

PseudoAffine Float

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: Float -> Float -> Maybe (Needle Float)

(.-~!) :: Float -> Float -> Needle Float

pseudoAffineWitness :: PseudoAffineWitness Float

AdditiveGroup (DualVector (Needle (VRep m))) => PseudoAffine (GenericNeedle' m)

Defined in Math.LinearMap.Category.Class

Methods

(.-~.) :: GenericNeedle' m -> GenericNeedle' m -> Maybe (Needle (GenericNeedle' m))

(.-~!) :: GenericNeedle' m -> GenericNeedle' m -> Needle (GenericNeedle' m)

pseudoAffineWitness :: PseudoAffineWitness (GenericNeedle' m)

AdditiveGroup v => PseudoAffine (DualVectorFromBasis v)

Defined in Math.LinearMap.Category.Instances.Deriving

Methods

(.-~.) :: DualVectorFromBasis v -> DualVectorFromBasis v -> Maybe (Needle (DualVectorFromBasis v))

(.-~!) :: DualVectorFromBasis v -> DualVectorFromBasis v -> Needle (DualVectorFromBasis v)

pseudoAffineWitness :: PseudoAffineWitness (DualVectorFromBasis v)

(LinearSpace v, FiniteFreeSpace v, FiniteFreeSpace (DualVector v), StiefelScalar (Scalar v)) => PseudoAffine (Stiefel1 v)

Defined in Data.Manifold.Types

Methods

(.-~.) :: Stiefel1 v -> Stiefel1 v -> Maybe (Needle (Stiefel1 v))

(.-~!) :: Stiefel1 v -> Stiefel1 v -> Needle (Stiefel1 v)

pseudoAffineWitness :: PseudoAffineWitness (Stiefel1 v)

AdditiveGroup (Needle (VRep x)) => PseudoAffine (GenericNeedle x)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: GenericNeedle x -> GenericNeedle x -> Maybe (Needle (GenericNeedle x))

(.-~!) :: GenericNeedle x -> GenericNeedle x -> Needle (GenericNeedle x)

pseudoAffineWitness :: PseudoAffineWitness (GenericNeedle x)

RealFloat' s => PseudoAffine (S²_ s)

Defined in Data.Manifold.PseudoAffine

Methods

(.-~.) :: S²_ s -> S²_ s -> Maybe (Needle (S²_ s))

(.-~!) :: S²_ s -> S²_ s -> Needle (S²_ s)

pseudoAffineWitness :: PseudoAffineWitness (S²_ s)

RealFloat' r => PseudoAffine (S¹_ r)

Defined in Data.Manifold.PseudoAffine

Methods

(.-~.) :: S¹_ r -> S¹_ r -> Maybe (Needle (S¹_ r))

(.-~!) :: S¹_ r -> S¹_ r -> Needle (S¹_ r)

pseudoAffineWitness :: PseudoAffineWitness (S¹_ r)

RealFloat' r => PseudoAffine (S⁰_ r)

Defined in Data.Manifold.PseudoAffine

Methods

(.-~.) :: S⁰_ r -> S⁰_ r -> Maybe (Needle (S⁰_ r))

(.-~!) :: S⁰_ r -> S⁰_ r -> Needle (S⁰_ r)

pseudoAffineWitness :: PseudoAffineWitness (S⁰_ r)

ℝeal r => PseudoAffine (ℝP¹_ r)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: ℝP¹_ r -> ℝP¹_ r -> Maybe (Needle (ℝP¹_ r))

(.-~!) :: ℝP¹_ r -> ℝP¹_ r -> Needle (ℝP¹_ r)

pseudoAffineWitness :: PseudoAffineWitness (ℝP¹_ r)

PseudoAffine (ℝP⁰_ r)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: ℝP⁰_ r -> ℝP⁰_ r -> Maybe (Needle (ℝP⁰_ r))

(.-~!) :: ℝP⁰_ r -> ℝP⁰_ r -> Needle (ℝP⁰_ r)

pseudoAffineWitness :: PseudoAffineWitness (ℝP⁰_ r)

PseudoAffine (ZeroDim k)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: ZeroDim k -> ZeroDim k -> Maybe (Needle (ZeroDim k))

(.-~!) :: ZeroDim k -> ZeroDim k -> Needle (ZeroDim k)

pseudoAffineWitness :: PseudoAffineWitness (ZeroDim k)

(LinearSpace (a n), Needle (a n) ~ a n) => PseudoAffine (Point a n)

Defined in Data.Manifold.PseudoAffine

Methods

(.-~.) :: Point a n -> Point a n -> Maybe (Needle (Point a n))

(.-~!) :: Point a n -> Point a n -> Needle (Point a n)

pseudoAffineWitness :: PseudoAffineWitness (Point a n)

(Generic1 f, TensorSpace y, TensorSpace (f y), Scalar (f y) ~ Scalar y, Monoidal f (LinearFunction (Scalar y)) (LinearFunction (Scalar y))) => PseudoAffine (LinearApplicativeSpace f y)

Defined in Math.LinearMap.Category.Instances

Methods

(.-~.) :: LinearApplicativeSpace f y -> LinearApplicativeSpace f y -> Maybe (Needle (LinearApplicativeSpace f y))

(.-~!) :: LinearApplicativeSpace f y -> LinearApplicativeSpace f y -> Needle (LinearApplicativeSpace f y)

pseudoAffineWitness :: PseudoAffineWitness (LinearApplicativeSpace f y)

(TensorSpace v, Scalar v ~ s) => PseudoAffine (SymmetricTensor s v)

Defined in Math.LinearMap.Category.Instances

Methods

(.-~.) :: SymmetricTensor s v -> SymmetricTensor s v -> Maybe (Needle (SymmetricTensor s v))

(.-~!) :: SymmetricTensor s v -> SymmetricTensor s v -> Needle (SymmetricTensor s v)

pseudoAffineWitness :: PseudoAffineWitness (SymmetricTensor s v)

(AbstractLinearSpace a, VectorSpaceImplementation a ~ c, AdditiveGroup (DualVector c)) => PseudoAffine (AbstractDualVector a c)

Defined in Math.LinearMap.Category.Instances.Deriving

Methods

(.-~.) :: AbstractDualVector a c -> AbstractDualVector a c -> Maybe (Needle (AbstractDualVector a c))

(.-~!) :: AbstractDualVector a c -> AbstractDualVector a c -> Needle (AbstractDualVector a c)

pseudoAffineWitness :: PseudoAffineWitness (AbstractDualVector a c)

PseudoAffine x => PseudoAffine (WithAny x y)

Defined in Data.Manifold.Shade

Methods

(.-~.) :: WithAny x y -> WithAny x y -> Maybe (Needle (WithAny x y))

(.-~!) :: WithAny x y -> WithAny x y -> Needle (WithAny x y)

pseudoAffineWitness :: PseudoAffineWitness (WithAny x y)

(ParallelTransporting (->) m f, PseudoAffine f, ParallelTransporting (LinearFunction s) (Needle m) (Needle f), s ~ Scalar (Needle m)) => PseudoAffine (FibreBundle m f)

Defined in Data.Manifold.FibreBundle

Methods

(.-~.) :: FibreBundle m f -> FibreBundle m f -> Maybe (Needle (FibreBundle m f))

(.-~!) :: FibreBundle m f -> FibreBundle m f -> Needle (FibreBundle m f)

pseudoAffineWitness :: PseudoAffineWitness (FibreBundle m f)

(PseudoAffine a, PseudoAffine b) => PseudoAffine (a, b)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: (a, b) -> (a, b) -> Maybe (Needle (a, b))

(.-~!) :: (a, b) -> (a, b) -> Needle (a, b)

pseudoAffineWitness :: PseudoAffineWitness (a, b)

PseudoAffine a => PseudoAffine (Rec0 a s)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: Rec0 a s -> Rec0 a s -> Maybe (Needle (Rec0 a s))

(.-~!) :: Rec0 a s -> Rec0 a s -> Needle (Rec0 a s)

pseudoAffineWitness :: PseudoAffineWitness (Rec0 a s)

VectorSpace w => PseudoAffine (LinearFunction s v w)

Defined in Math.LinearMap.Asserted

Methods

(.-~.) :: LinearFunction s v w -> LinearFunction s v w -> Maybe (Needle (LinearFunction s v w))

(.-~!) :: LinearFunction s v w -> LinearFunction s v w -> Needle (LinearFunction s v w)

pseudoAffineWitness :: PseudoAffineWitness (LinearFunction s v w)

(AdditiveGroup (DualVector (f p)), AdditiveGroup (DualVector (g p))) => PseudoAffine (GenericTupleDual f g p)

Defined in Math.LinearMap.Category.Class

Methods

(.-~.) :: GenericTupleDual f g p -> GenericTupleDual f g p -> Maybe (Needle (GenericTupleDual f g p))

(.-~!) :: GenericTupleDual f g p -> GenericTupleDual f g p -> Needle (GenericTupleDual f g p)

pseudoAffineWitness :: PseudoAffineWitness (GenericTupleDual f g p)

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

Defined in Math.LinearMap.Category.Class

Methods

(.-~.) :: LinearMap s v w -> LinearMap s v w -> Maybe (Needle (LinearMap s v w))

(.-~!) :: LinearMap s v w -> LinearMap s v w -> Needle (LinearMap s v w)

pseudoAffineWitness :: PseudoAffineWitness (LinearMap s v w)

(TensorSpace v, TensorSpace w, Scalar v ~ s, Scalar w ~ s) => PseudoAffine (Tensor s v w)

Defined in Math.LinearMap.Category.Class

Methods

(.-~.) :: Tensor s v w -> Tensor s v w -> Maybe (Needle (Tensor s v w))

(.-~!) :: Tensor s v w -> Tensor s v w -> Needle (Tensor s v w)

pseudoAffineWitness :: PseudoAffineWitness (Tensor s v w)

(Atlas x, HasTrie (ChartIndex x), Manifold y, LinearManifold (Needle x), Scalar (Needle x) ~ s, LinearManifold (Needle y), Scalar (Needle y) ~ s) => PseudoAffine (Affine s x y)

Defined in Data.Function.Affine

Methods

(.-~.) :: Affine s x y -> Affine s x y -> Maybe (Needle (Affine s x y))

(.-~!) :: Affine s x y -> Affine s x y -> Needle (Affine s x y)

pseudoAffineWitness :: PseudoAffineWitness (Affine s x y)

(PseudoAffine (f p), PseudoAffine (g p)) => PseudoAffine (NeedleProductSpace f g p)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: NeedleProductSpace f g p -> NeedleProductSpace f g p -> Maybe (Needle (NeedleProductSpace f g p))

(.-~!) :: NeedleProductSpace f g p -> NeedleProductSpace f g p -> Needle (NeedleProductSpace f g p)

pseudoAffineWitness :: PseudoAffineWitness (NeedleProductSpace f g p)

(PseudoAffine a, PseudoAffine b, PseudoAffine c) => PseudoAffine (a, b, c)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: (a, b, c) -> (a, b, c) -> Maybe (Needle (a, b, c))

(.-~!) :: (a, b, c) -> (a, b, c) -> Needle (a, b, c)

pseudoAffineWitness :: PseudoAffineWitness (a, b, c)

(PseudoAffine (f p), PseudoAffine (g p)) => PseudoAffine ((f :*: g) p)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: (f :*: g) p -> (f :*: g) p -> Maybe (Needle ((f :*: g) p))

(.-~!) :: (f :*: g) p -> (f :*: g) p -> Needle ((f :*: g) p)

pseudoAffineWitness :: PseudoAffineWitness ((f :*: g) p)

PseudoAffine (f p) => PseudoAffine (M1 i c f p)

Defined in Math.Manifold.Core.PseudoAffine

Methods

(.-~.) :: M1 i c f p -> M1 i c f p -> Maybe (Needle (M1 i c f p))

(.-~!) :: M1 i c f p -> M1 i c f p -> Needle (M1 i c f p)

pseudoAffineWitness :: PseudoAffineWitness (M1 i c f p)

type LinearManifold m = (LinearSpace m, Manifold m)

type ScalarManifold s = (Num' s, Manifold s, Manifold (ZeroDim s))

class (Num s, LinearSpace s, FreeVectorSpace s, Dimensional 1 s) => Num' s

type RealFrac' s = (Fractional' s, IEEE s, InnerSpace s)

type RealFloat' s = (RealFrac' s, Floating s)

type Num'' s = ScalarManifold s

type RealFrac'' s = (RealFrac' s, ScalarManifold s)

type RealFloat'' s = (RealFloat' s, SimpleSpace s, ScalarManifold s)

Type definitions

Needles

newtype Local x

A point on a manifold, as seen from a nearby reference point.

Constructors

Local

Fields

• getLocalOffset :: Needle x

Instances

Show (Needle x) => Show (Local x)

Defined in Data.Manifold.PseudoAffine

Methods

showsPrec :: Int -> Local x -> ShowS

show :: Local x -> String

showList :: [Local x] -> ShowS

Metrics

type Metric x = Norm (Needle x)

The word “metric” is used in the sense as in general relativity. Actually this is just the type of scalar products on the tangent space. The actual metric is the function x -> x -> Scalar (Needle x) defined by

\p q -> m |$| (p.-~!q)

type Metric' x = Variance (Needle x)

type RieMetric x = x -> Metric x

A Riemannian metric assigns each point on a manifold a scalar product on the tangent space. Note that this association is not continuous, because the charts/tangent spaces in the bundle are a priori disjoint. However, for a proper Riemannian metric, all arising expressions of scalar products from needles between points on the manifold ought to be differentiable.

type RieMetric' x = x -> Metric' x

Constraints

data SemimanifoldWitness x where

This is the reified form of the property that the interior of a semimanifold is a manifold. These constraints would ideally be expressed directly as superclass constraints, but that would require the UndecidableSuperclasses extension, which is not reliable yet.

Also, if all those equality constraints are in scope, GHC tends to infer needlessly complicated types like Needle (Needle (Needle x)), which is the same as just Needle x.

Constructors

SemimanifoldWitness :: forall x. (Semimanifold (Needle x), Needle (Needle x) ~ Needle x) => SemimanifoldWitness x

data PseudoAffineWitness x where

Constructors

PseudoAffineWitness :: forall x. PseudoAffine (Needle x) => SemimanifoldWitness x -> PseudoAffineWitness x

type DualNeedleWitness x = DualSpaceWitness (Needle x)

type WithField s c x = (c x, s ~ Scalar (Needle x), s ~ Scalar (Needle' x))

Require some constraint on a manifold, and also fix the type of the manifold's underlying field. For example, WithField ℝ HilbertManifold v constrains v to be a real (i.e., Double-) Hilbert space. Note that for this to compile, you will in general need the -XLiberalTypeSynonyms extension (except if the constraint is an actual type class (like Manifold): only those can always be partially applied, for type constraints this is by default not allowed).

type LocallyScalable s x = (PseudoAffine x, LSpace (Needle x), s ~ Scalar (Needle x), s ~ Scalar (Needle' x), Num' s)

Local functions

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

type LocalBilinear x y = LinearMap (Scalar (Needle x)) (SymmetricTensor (Scalar (Needle x)) (Needle x)) (Needle y)

type LocalAffine x y = (Needle y, LocalLinear x y)

Misc

alerpB :: (AffineSpace x, VectorSpace (Diff x), Scalar (Diff x) ~ ℝ) => x -> x -> D¹ -> x

Like alerp, but actually restricted to the interval between the points.

palerp :: (PseudoAffine x, VectorSpace (Needle x)) => x -> x -> Maybe (Scalar (Needle x) -> x)

Interpolate between points, approximately linearly. For points that aren't close neighbours (i.e. lie in an almost flat region), the pathway is basically undefined – save for its end points.

A proper, really well-defined (on global scales) interpolation only makes sense on a Riemannian manifold, as Geodesic.

palerpB :: (PseudoAffine x, VectorSpace (Needle x), Scalar (Needle x) ~ ℝ) => x -> x -> Maybe (D¹ -> x)

Like palerp, but actually restricted to the interval between the points, with a signature like geodesicBetween rather than alerp.

class (Semimanifold x, Semimanifold ξ, LSpace (Needle x), LSpace (Needle ξ), Scalar (Needle x) ~ Scalar (Needle ξ)) => LocallyCoercible x ξ where

Instances of this class must be diffeomorphic manifolds, and even have canonically isomorphic tangent spaces, so that fromPackedVector . asPackedVector :: Needle x -> Needle ξ defines a meaningful “representational identity“ between these spaces.

Minimal complete definition

locallyTrivialDiffeomorphism, coerceNeedle, coerceNeedle'

Methods

locallyTrivialDiffeomorphism :: x -> ξ

Must be compatible with the isomorphism on the tangent spaces, i.e. locallyTrivialDiffeomorphism (p .+~^ v) ≡ locallyTrivialDiffeomorphism p .+~^ coerceNeedle v

coerceNeedle :: Functor p => p (x, ξ) -> Needle x -+> Needle ξ

coerceNeedle' :: Functor p => p (x, ξ) -> Needle' x -+> Needle' ξ

coerceNorm :: Functor p => p (x, ξ) -> Metric x -> Metric ξ

coerceVariance :: Functor p => p (x, ξ) -> Metric' x -> Metric' ξ

oppositeLocalCoercion :: CanonicalDiffeomorphism ξ x

default oppositeLocalCoercion :: LocallyCoercible ξ x => CanonicalDiffeomorphism ξ x

Instances

LocallyCoercible ℝ ℝ

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ℝ -> ℝ

coerceNeedle :: Functor p => p (ℝ, ℝ) -> Needle ℝ -+> Needle ℝ

coerceNeedle' :: Functor p => p (ℝ, ℝ) -> Needle' ℝ -+> Needle' ℝ

coerceNorm :: Functor p => p (ℝ, ℝ) -> Metric ℝ -> Metric ℝ

coerceVariance :: Functor p => p (ℝ, ℝ) -> Metric' ℝ -> Metric' ℝ

oppositeLocalCoercion :: CanonicalDiffeomorphism ℝ ℝ

LocallyCoercible ℝ (V1 ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ℝ -> V1 ℝ

coerceNeedle :: Functor p => p (ℝ, V1 ℝ) -> Needle ℝ -+> Needle (V1 ℝ)

coerceNeedle' :: Functor p => p (ℝ, V1 ℝ) -> Needle' ℝ -+> Needle' (V1 ℝ)

coerceNorm :: Functor p => p (ℝ, V1 ℝ) -> Metric ℝ -> Metric (V1 ℝ)

coerceVariance :: Functor p => p (ℝ, V1 ℝ) -> Metric' ℝ -> Metric' (V1 ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V1 ℝ) ℝ

LocallyCoercible (V1 ℝ) ℝ

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V1 ℝ -> ℝ

coerceNeedle :: Functor p => p (V1 ℝ, ℝ) -> Needle (V1 ℝ) -+> Needle ℝ

coerceNeedle' :: Functor p => p (V1 ℝ, ℝ) -> Needle' (V1 ℝ) -+> Needle' ℝ

coerceNorm :: Functor p => p (V1 ℝ, ℝ) -> Metric (V1 ℝ) -> Metric ℝ

coerceVariance :: Functor p => p (V1 ℝ, ℝ) -> Metric' (V1 ℝ) -> Metric' ℝ

oppositeLocalCoercion :: CanonicalDiffeomorphism ℝ (V1 ℝ)

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

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V0 s -> V0 s

coerceNeedle :: Functor p => p (V0 s, V0 s) -> Needle (V0 s) -+> Needle (V0 s)

coerceNeedle' :: Functor p => p (V0 s, V0 s) -> Needle' (V0 s) -+> Needle' (V0 s)

coerceNorm :: Functor p => p (V0 s, V0 s) -> Metric (V0 s) -> Metric (V0 s)

coerceVariance :: Functor p => p (V0 s, V0 s) -> Metric' (V0 s) -> Metric' (V0 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V0 s) (V0 s)

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

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V0 s -> ZeroDim s

coerceNeedle :: Functor p => p (V0 s, ZeroDim s) -> Needle (V0 s) -+> Needle (ZeroDim s)

coerceNeedle' :: Functor p => p (V0 s, ZeroDim s) -> Needle' (V0 s) -+> Needle' (ZeroDim s)

coerceNorm :: Functor p => p (V0 s, ZeroDim s) -> Metric (V0 s) -> Metric (ZeroDim s)

coerceVariance :: Functor p => p (V0 s, ZeroDim s) -> Metric' (V0 s) -> Metric' (ZeroDim s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (ZeroDim s) (V0 s)

NumPrime s => LocallyCoercible (V1 s) (V1 s)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V1 s -> V1 s

coerceNeedle :: Functor p => p (V1 s, V1 s) -> Needle (V1 s) -+> Needle (V1 s)

coerceNeedle' :: Functor p => p (V1 s, V1 s) -> Needle' (V1 s) -+> Needle' (V1 s)

coerceNorm :: Functor p => p (V1 s, V1 s) -> Metric (V1 s) -> Metric (V1 s)

coerceVariance :: Functor p => p (V1 s, V1 s) -> Metric' (V1 s) -> Metric' (V1 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V1 s) (V1 s)

NumPrime s => LocallyCoercible (V2 s) (V2 s)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V2 s -> V2 s

coerceNeedle :: Functor p => p (V2 s, V2 s) -> Needle (V2 s) -+> Needle (V2 s)

coerceNeedle' :: Functor p => p (V2 s, V2 s) -> Needle' (V2 s) -+> Needle' (V2 s)

coerceNorm :: Functor p => p (V2 s, V2 s) -> Metric (V2 s) -> Metric (V2 s)

coerceVariance :: Functor p => p (V2 s, V2 s) -> Metric' (V2 s) -> Metric' (V2 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V2 s) (V2 s)

NumPrime s => LocallyCoercible (V3 s) (V3 s)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V3 s -> V3 s

coerceNeedle :: Functor p => p (V3 s, V3 s) -> Needle (V3 s) -+> Needle (V3 s)

coerceNeedle' :: Functor p => p (V3 s, V3 s) -> Needle' (V3 s) -+> Needle' (V3 s)

coerceNorm :: Functor p => p (V3 s, V3 s) -> Metric (V3 s) -> Metric (V3 s)

coerceVariance :: Functor p => p (V3 s, V3 s) -> Metric' (V3 s) -> Metric' (V3 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V3 s) (V3 s)

NumPrime s => LocallyCoercible (V4 s) (V4 s)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V4 s -> V4 s

coerceNeedle :: Functor p => p (V4 s, V4 s) -> Needle (V4 s) -+> Needle (V4 s)

coerceNeedle' :: Functor p => p (V4 s, V4 s) -> Needle' (V4 s) -+> Needle' (V4 s)

coerceNorm :: Functor p => p (V4 s, V4 s) -> Metric (V4 s) -> Metric (V4 s)

coerceVariance :: Functor p => p (V4 s, V4 s) -> Metric' (V4 s) -> Metric' (V4 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V4 s) (V4 s)

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

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ZeroDim s -> V0 s

coerceNeedle :: Functor p => p (ZeroDim s, V0 s) -> Needle (ZeroDim s) -+> Needle (V0 s)

coerceNeedle' :: Functor p => p (ZeroDim s, V0 s) -> Needle' (ZeroDim s) -+> Needle' (V0 s)

coerceNorm :: Functor p => p (ZeroDim s, V0 s) -> Metric (ZeroDim s) -> Metric (V0 s)

coerceVariance :: Functor p => p (ZeroDim s, V0 s) -> Metric' (ZeroDim s) -> Metric' (V0 s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V0 s) (ZeroDim s)

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

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ZeroDim s -> ZeroDim s

coerceNeedle :: Functor p => p (ZeroDim s, ZeroDim s) -> Needle (ZeroDim s) -+> Needle (ZeroDim s)

coerceNeedle' :: Functor p => p (ZeroDim s, ZeroDim s) -> Needle' (ZeroDim s) -+> Needle' (ZeroDim s)

coerceNorm :: Functor p => p (ZeroDim s, ZeroDim s) -> Metric (ZeroDim s) -> Metric (ZeroDim s)

coerceVariance :: Functor p => p (ZeroDim s, ZeroDim s) -> Metric' (ZeroDim s) -> Metric' (ZeroDim s)

oppositeLocalCoercion :: CanonicalDiffeomorphism (ZeroDim s) (ZeroDim s)

LocallyCoercible (V2 ℝ) (ℝ, ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V2 ℝ -> (ℝ, ℝ)

coerceNeedle :: Functor p => p (V2 ℝ, (ℝ, ℝ)) -> Needle (V2 ℝ) -+> Needle (ℝ, ℝ)

coerceNeedle' :: Functor p => p (V2 ℝ, (ℝ, ℝ)) -> Needle' (V2 ℝ) -+> Needle' (ℝ, ℝ)

coerceNorm :: Functor p => p (V2 ℝ, (ℝ, ℝ)) -> Metric (V2 ℝ) -> Metric (ℝ, ℝ)

coerceVariance :: Functor p => p (V2 ℝ, (ℝ, ℝ)) -> Metric' (V2 ℝ) -> Metric' (ℝ, ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (ℝ, ℝ) (V2 ℝ)

LocallyCoercible (V3 ℝ) (ℝ, (ℝ, ℝ))

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V3 ℝ -> (ℝ, (ℝ, ℝ))

coerceNeedle :: Functor p => p (V3 ℝ, (ℝ, (ℝ, ℝ))) -> Needle (V3 ℝ) -+> Needle (ℝ, (ℝ, ℝ))

coerceNeedle' :: Functor p => p (V3 ℝ, (ℝ, (ℝ, ℝ))) -> Needle' (V3 ℝ) -+> Needle' (ℝ, (ℝ, ℝ))

coerceNorm :: Functor p => p (V3 ℝ, (ℝ, (ℝ, ℝ))) -> Metric (V3 ℝ) -> Metric (ℝ, (ℝ, ℝ))

coerceVariance :: Functor p => p (V3 ℝ, (ℝ, (ℝ, ℝ))) -> Metric' (V3 ℝ) -> Metric' (ℝ, (ℝ, ℝ))

oppositeLocalCoercion :: CanonicalDiffeomorphism (ℝ, (ℝ, ℝ)) (V3 ℝ)

LocallyCoercible (V3 ℝ) ((ℝ, ℝ), ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V3 ℝ -> ((ℝ, ℝ), ℝ)

coerceNeedle :: Functor p => p (V3 ℝ, ((ℝ, ℝ), ℝ)) -> Needle (V3 ℝ) -+> Needle ((ℝ, ℝ), ℝ)

coerceNeedle' :: Functor p => p (V3 ℝ, ((ℝ, ℝ), ℝ)) -> Needle' (V3 ℝ) -+> Needle' ((ℝ, ℝ), ℝ)

coerceNorm :: Functor p => p (V3 ℝ, ((ℝ, ℝ), ℝ)) -> Metric (V3 ℝ) -> Metric ((ℝ, ℝ), ℝ)

coerceVariance :: Functor p => p (V3 ℝ, ((ℝ, ℝ), ℝ)) -> Metric' (V3 ℝ) -> Metric' ((ℝ, ℝ), ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism ((ℝ, ℝ), ℝ) (V3 ℝ)

LocallyCoercible (V4 ℝ) ((ℝ, ℝ), (ℝ, ℝ))

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: V4 ℝ -> ((ℝ, ℝ), (ℝ, ℝ))

coerceNeedle :: Functor p => p (V4 ℝ, ((ℝ, ℝ), (ℝ, ℝ))) -> Needle (V4 ℝ) -+> Needle ((ℝ, ℝ), (ℝ, ℝ))

coerceNeedle' :: Functor p => p (V4 ℝ, ((ℝ, ℝ), (ℝ, ℝ))) -> Needle' (V4 ℝ) -+> Needle' ((ℝ, ℝ), (ℝ, ℝ))

coerceNorm :: Functor p => p (V4 ℝ, ((ℝ, ℝ), (ℝ, ℝ))) -> Metric (V4 ℝ) -> Metric ((ℝ, ℝ), (ℝ, ℝ))

coerceVariance :: Functor p => p (V4 ℝ, ((ℝ, ℝ), (ℝ, ℝ))) -> Metric' (V4 ℝ) -> Metric' ((ℝ, ℝ), (ℝ, ℝ))

oppositeLocalCoercion :: CanonicalDiffeomorphism ((ℝ, ℝ), (ℝ, ℝ)) (V4 ℝ)

LocallyCoercible (ℝ, ℝ) (V2 ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: (ℝ, ℝ) -> V2 ℝ

coerceNeedle :: Functor p => p ((ℝ, ℝ), V2 ℝ) -> Needle (ℝ, ℝ) -+> Needle (V2 ℝ)

coerceNeedle' :: Functor p => p ((ℝ, ℝ), V2 ℝ) -> Needle' (ℝ, ℝ) -+> Needle' (V2 ℝ)

coerceNorm :: Functor p => p ((ℝ, ℝ), V2 ℝ) -> Metric (ℝ, ℝ) -> Metric (V2 ℝ)

coerceVariance :: Functor p => p ((ℝ, ℝ), V2 ℝ) -> Metric' (ℝ, ℝ) -> Metric' (V2 ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V2 ℝ) (ℝ, ℝ)

LocallyCoercible (ℝ, (ℝ, ℝ)) (V3 ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: (ℝ, (ℝ, ℝ)) -> V3 ℝ

coerceNeedle :: Functor p => p ((ℝ, (ℝ, ℝ)), V3 ℝ) -> Needle (ℝ, (ℝ, ℝ)) -+> Needle (V3 ℝ)

coerceNeedle' :: Functor p => p ((ℝ, (ℝ, ℝ)), V3 ℝ) -> Needle' (ℝ, (ℝ, ℝ)) -+> Needle' (V3 ℝ)

coerceNorm :: Functor p => p ((ℝ, (ℝ, ℝ)), V3 ℝ) -> Metric (ℝ, (ℝ, ℝ)) -> Metric (V3 ℝ)

coerceVariance :: Functor p => p ((ℝ, (ℝ, ℝ)), V3 ℝ) -> Metric' (ℝ, (ℝ, ℝ)) -> Metric' (V3 ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V3 ℝ) (ℝ, (ℝ, ℝ))

LocallyCoercible ((ℝ, ℝ), ℝ) (V3 ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ((ℝ, ℝ), ℝ) -> V3 ℝ

coerceNeedle :: Functor p => p (((ℝ, ℝ), ℝ), V3 ℝ) -> Needle ((ℝ, ℝ), ℝ) -+> Needle (V3 ℝ)

coerceNeedle' :: Functor p => p (((ℝ, ℝ), ℝ), V3 ℝ) -> Needle' ((ℝ, ℝ), ℝ) -+> Needle' (V3 ℝ)

coerceNorm :: Functor p => p (((ℝ, ℝ), ℝ), V3 ℝ) -> Metric ((ℝ, ℝ), ℝ) -> Metric (V3 ℝ)

coerceVariance :: Functor p => p (((ℝ, ℝ), ℝ), V3 ℝ) -> Metric' ((ℝ, ℝ), ℝ) -> Metric' (V3 ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V3 ℝ) ((ℝ, ℝ), ℝ)

LocallyCoercible ((ℝ, ℝ), (ℝ, ℝ)) (V4 ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ((ℝ, ℝ), (ℝ, ℝ)) -> V4 ℝ

coerceNeedle :: Functor p => p (((ℝ, ℝ), (ℝ, ℝ)), V4 ℝ) -> Needle ((ℝ, ℝ), (ℝ, ℝ)) -+> Needle (V4 ℝ)

coerceNeedle' :: Functor p => p (((ℝ, ℝ), (ℝ, ℝ)), V4 ℝ) -> Needle' ((ℝ, ℝ), (ℝ, ℝ)) -+> Needle' (V4 ℝ)

coerceNorm :: Functor p => p (((ℝ, ℝ), (ℝ, ℝ)), V4 ℝ) -> Metric ((ℝ, ℝ), (ℝ, ℝ)) -> Metric (V4 ℝ)

coerceVariance :: Functor p => p (((ℝ, ℝ), (ℝ, ℝ)), V4 ℝ) -> Metric' ((ℝ, ℝ), (ℝ, ℝ)) -> Metric' (V4 ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (V4 ℝ) ((ℝ, ℝ), (ℝ, ℝ))

LocallyCoercible (ℝ, ℝ) (ℝ, ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: (ℝ, ℝ) -> (ℝ, ℝ)

coerceNeedle :: Functor p => p ((ℝ, ℝ), (ℝ, ℝ)) -> Needle (ℝ, ℝ) -+> Needle (ℝ, ℝ)

coerceNeedle' :: Functor p => p ((ℝ, ℝ), (ℝ, ℝ)) -> Needle' (ℝ, ℝ) -+> Needle' (ℝ, ℝ)

coerceNorm :: Functor p => p ((ℝ, ℝ), (ℝ, ℝ)) -> Metric (ℝ, ℝ) -> Metric (ℝ, ℝ)

coerceVariance :: Functor p => p ((ℝ, ℝ), (ℝ, ℝ)) -> Metric' (ℝ, ℝ) -> Metric' (ℝ, ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism (ℝ, ℝ) (ℝ, ℝ)

LocallyCoercible (ℝ, (ℝ, ℝ)) (ℝ, (ℝ, ℝ))

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: (ℝ, (ℝ, ℝ)) -> (ℝ, (ℝ, ℝ))

coerceNeedle :: Functor p => p ((ℝ, (ℝ, ℝ)), (ℝ, (ℝ, ℝ))) -> Needle (ℝ, (ℝ, ℝ)) -+> Needle (ℝ, (ℝ, ℝ))

coerceNeedle' :: Functor p => p ((ℝ, (ℝ, ℝ)), (ℝ, (ℝ, ℝ))) -> Needle' (ℝ, (ℝ, ℝ)) -+> Needle' (ℝ, (ℝ, ℝ))

coerceNorm :: Functor p => p ((ℝ, (ℝ, ℝ)), (ℝ, (ℝ, ℝ))) -> Metric (ℝ, (ℝ, ℝ)) -> Metric (ℝ, (ℝ, ℝ))

coerceVariance :: Functor p => p ((ℝ, (ℝ, ℝ)), (ℝ, (ℝ, ℝ))) -> Metric' (ℝ, (ℝ, ℝ)) -> Metric' (ℝ, (ℝ, ℝ))

oppositeLocalCoercion :: CanonicalDiffeomorphism (ℝ, (ℝ, ℝ)) (ℝ, (ℝ, ℝ))

LocallyCoercible ((ℝ, ℝ), ℝ) ((ℝ, ℝ), ℝ)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ((ℝ, ℝ), ℝ) -> ((ℝ, ℝ), ℝ)

coerceNeedle :: Functor p => p (((ℝ, ℝ), ℝ), ((ℝ, ℝ), ℝ)) -> Needle ((ℝ, ℝ), ℝ) -+> Needle ((ℝ, ℝ), ℝ)

coerceNeedle' :: Functor p => p (((ℝ, ℝ), ℝ), ((ℝ, ℝ), ℝ)) -> Needle' ((ℝ, ℝ), ℝ) -+> Needle' ((ℝ, ℝ), ℝ)

coerceNorm :: Functor p => p (((ℝ, ℝ), ℝ), ((ℝ, ℝ), ℝ)) -> Metric ((ℝ, ℝ), ℝ) -> Metric ((ℝ, ℝ), ℝ)

coerceVariance :: Functor p => p (((ℝ, ℝ), ℝ), ((ℝ, ℝ), ℝ)) -> Metric' ((ℝ, ℝ), ℝ) -> Metric' ((ℝ, ℝ), ℝ)

oppositeLocalCoercion :: CanonicalDiffeomorphism ((ℝ, ℝ), ℝ) ((ℝ, ℝ), ℝ)

(Semimanifold a, Semimanifold b, Semimanifold c, LSpace (Needle a), LSpace (Needle b), LSpace (Needle c), Scalar (Needle a) ~ Scalar (Needle b), Scalar (Needle b) ~ Scalar (Needle c)) => LocallyCoercible ((a, b), c) (a, (b, c))

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: ((a, b), c) -> (a, (b, c))

coerceNeedle :: Functor p => p (((a, b), c), (a, (b, c))) -> Needle ((a, b), c) -+> Needle (a, (b, c))

coerceNeedle' :: Functor p => p (((a, b), c), (a, (b, c))) -> Needle' ((a, b), c) -+> Needle' (a, (b, c))

coerceNorm :: Functor p => p (((a, b), c), (a, (b, c))) -> Metric ((a, b), c) -> Metric (a, (b, c))

coerceVariance :: Functor p => p (((a, b), c), (a, (b, c))) -> Metric' ((a, b), c) -> Metric' (a, (b, c))

oppositeLocalCoercion :: CanonicalDiffeomorphism (a, (b, c)) ((a, b), c)

(Semimanifold a, Semimanifold b, Semimanifold c, LSpace (Needle a), LSpace (Needle b), LSpace (Needle c), Scalar (Needle a) ~ Scalar (Needle b), Scalar (Needle b) ~ Scalar (Needle c)) => LocallyCoercible (a, (b, c)) ((a, b), c)

Defined in Data.Manifold.PseudoAffine

Methods

locallyTrivialDiffeomorphism :: (a, (b, c)) -> ((a, b), c)

coerceNeedle :: Functor p => p ((a, (b, c)), ((a, b), c)) -> Needle (a, (b, c)) -+> Needle ((a, b), c)

coerceNeedle' :: Functor p => p ((a, (b, c)), ((a, b), c)) -> Needle' (a, (b, c)) -+> Needle' ((a, b), c)

coerceNorm :: Functor p => p ((a, (b, c)), ((a, b), c)) -> Metric (a, (b, c)) -> Metric ((a, b), c)

coerceVariance :: Functor p => p ((a, (b, c)), ((a, b), c)) -> Metric' (a, (b, c)) -> Metric' ((a, b), c)

oppositeLocalCoercion :: CanonicalDiffeomorphism ((a, b), c) (a, (b, c))

data CanonicalDiffeomorphism a b where

Constructors

CanonicalDiffeomorphism :: LocallyCoercible a b => CanonicalDiffeomorphism a b

class ImpliesMetric s where

Associated Types

type MetricRequirement s x :: Constraint

type MetricRequirement s x = Semimanifold x

Methods

inferMetric :: (MetricRequirement s x, LSpace (Needle x)) => s x -> Metric x

inferMetric' :: (MetricRequirement s x, LSpace (Needle x)) => s x -> Metric' x

Instances

ImpliesMetric Norm

Defined in Data.Manifold.PseudoAffine

Associated Types

type MetricRequirement Norm x

Methods

inferMetric :: (MetricRequirement Norm x, LSpace (Needle x)) => Norm x -> Metric x

inferMetric' :: (MetricRequirement Norm x, LSpace (Needle x)) => Norm x -> Metric' x

ImpliesMetric Shade

Defined in Data.Manifold.Shade

Associated Types

type MetricRequirement Shade x

Methods

inferMetric :: (MetricRequirement Shade x, LSpace (Needle x)) => Shade x -> Metric x

inferMetric' :: (MetricRequirement Shade x, LSpace (Needle x)) => Shade x -> Metric' x

ImpliesMetric Shade'

Defined in Data.Manifold.Shade

Associated Types

type MetricRequirement Shade' x

Methods

inferMetric :: (MetricRequirement Shade' x, LSpace (Needle x)) => Shade' x -> Metric x

inferMetric' :: (MetricRequirement Shade' x, LSpace (Needle x)) => Shade' x -> Metric' x

coerceMetric :: forall x ξ. (LocallyCoercible x ξ, LSpace (Needle ξ)) => RieMetric ξ -> RieMetric x

coerceMetric' :: forall x ξ. (LocallyCoercible x ξ, LSpace (Needle ξ)) => RieMetric' ξ -> RieMetric' x

class PseudoAffine m => Connected m where

A connected manifold is one where any point can be reached by translation from any other point.

Minimal complete definition

Nothing

Methods

(.−.) :: m -> m -> Needle m infix 6

Safe version of (.-~.).

Instances

Connected ℝ²

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ² -> ℝ² -> Needle ℝ²

Connected ℝ³

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ³ -> ℝ³ -> Needle ℝ³

Connected ℝ¹

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ¹ -> ℝ¹ -> Needle ℝ¹

Connected ℝ⁴

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ⁴ -> ℝ⁴ -> Needle ℝ⁴

Connected S²

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: S² -> S² -> Needle S²

Connected S¹

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: S¹ -> S¹ -> Needle S¹

Connected ℝ

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ -> ℝ -> Needle ℝ

Connected ℝP²

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝP² -> ℝP² -> Needle ℝP²

Connected ℝP¹

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝP¹ -> ℝP¹ -> Needle ℝP¹

Connected ℝP⁰

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝP⁰ -> ℝP⁰ -> Needle ℝP⁰

Connected ℝ⁰

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: ℝ⁰ -> ℝ⁰ -> Needle ℝ⁰

(Connected x, Connected y, PseudoAffine (FibreBundle x y)) => Connected (FibreBundle x y)

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: FibreBundle x y -> FibreBundle x y -> Needle (FibreBundle x y)

(Connected x, Connected y) => Connected (x, y)

Defined in Data.Manifold.PseudoAffine

Methods

(.−.) :: (x, y) -> (x, y) -> Needle (x, y)

Orphan instances

PseudoAffine ℝP²

Methods

(.-~.) :: ℝP² -> ℝP² -> Maybe (Needle ℝP²)

(.-~!) :: ℝP² -> ℝP² -> Needle ℝP²

pseudoAffineWitness :: PseudoAffineWitness ℝP²

Semimanifold ℝP²

Associated Types

type Needle ℝP²

Methods

(.+~^) :: ℝP² -> Needle ℝP² -> ℝP²

(.-~^) :: ℝP² -> Needle ℝP² -> ℝP²

semimanifoldWitness :: SemimanifoldWitness ℝP²

RealFloat' s => PseudoAffine (S²_ s)

Methods

(.-~.) :: S²_ s -> S²_ s -> Maybe (Needle (S²_ s))

(.-~!) :: S²_ s -> S²_ s -> Needle (S²_ s)

pseudoAffineWitness :: PseudoAffineWitness (S²_ s)

RealFloat' r => PseudoAffine (S¹_ r)

Methods

(.-~.) :: S¹_ r -> S¹_ r -> Maybe (Needle (S¹_ r))

(.-~!) :: S¹_ r -> S¹_ r -> Needle (S¹_ r)

pseudoAffineWitness :: PseudoAffineWitness (S¹_ r)

RealFloat' r => PseudoAffine (S⁰_ r)

Methods

(.-~.) :: S⁰_ r -> S⁰_ r -> Maybe (Needle (S⁰_ r))

(.-~!) :: S⁰_ r -> S⁰_ r -> Needle (S⁰_ r)

pseudoAffineWitness :: PseudoAffineWitness (S⁰_ r)

RealFloat' s => Semimanifold (S²_ s)

Associated Types

type Needle (S²_ s)

Methods

(.+~^) :: S²_ s -> Needle (S²_ s) -> S²_ s

(.-~^) :: S²_ s -> Needle (S²_ s) -> S²_ s

semimanifoldWitness :: SemimanifoldWitness (S²_ s)

RealFloat' r => Semimanifold (S¹_ r)

Associated Types

type Needle (S¹_ r)

Methods

(.+~^) :: S¹_ r -> Needle (S¹_ r) -> S¹_ r

(.-~^) :: S¹_ r -> Needle (S¹_ r) -> S¹_ r

semimanifoldWitness :: SemimanifoldWitness (S¹_ r)

RealFloat' r => Semimanifold (S⁰_ r)

Associated Types

type Needle (S⁰_ r)

Methods

(.+~^) :: S⁰_ r -> Needle (S⁰_ r) -> S⁰_ r

(.-~^) :: S⁰_ r -> Needle (S⁰_ r) -> S⁰_ r

semimanifoldWitness :: SemimanifoldWitness (S⁰_ r)

(LinearSpace (a n), Needle (a n) ~ a n) => PseudoAffine (Point a n)

Methods

(.-~.) :: Point a n -> Point a n -> Maybe (Needle (Point a n))

(.-~!) :: Point a n -> Point a n -> Needle (Point a n)

pseudoAffineWitness :: PseudoAffineWitness (Point a n)

(LinearSpace (a n), Needle (a n) ~ a n) => Semimanifold (Point a n)

Associated Types

type Needle (Point a n)

Methods

(.+~^) :: Point a n -> Needle (Point a n) -> Point a n

(.-~^) :: Point a n -> Needle (Point a n) -> Point a n

semimanifoldWitness :: SemimanifoldWitness (Point a n)