Data.Manifold.WithBoundary

Documentation

class SemimanifoldWithBoundary m where

The class of spaces with a displacement operation like Semimanifold, but there may be a limited range how far it is possible to move before leaving the space.

Such spaces decompose into two Semimanifold spaces: the Interior and the Boundary.

Minimal complete definition

(.+^|), fromInterior, fromBoundary, (|+^)

Associated Types

type Interior m :: Type

Subspace of m representing the set of points where it is possible to move at least a small distance in any direction (with .+^|) without leaving m.

type Boundary m :: Type

The set of points where an infinitesimal movement is sufficient to leave m.

type HalfNeedle m :: Type

Methods

(.+^|)

Arguments

:: m

Starting point p

-> Needle (Interior m)

Displacement v

-> Either (Boundary m, Scalar (Needle (Interior m))) (Interior m)

If v is enough to leave m, yield the point where it does and what fraction of the length is still left (i.e. how much of v “pokes out of the space”). If it stays within the space, just give back the result.

Boundary-aware pendant to .+~^.

fromInterior :: Interior m -> m

fromBoundary :: Boundary m -> m

(|+^) :: Boundary m -> HalfNeedle m -> m

separateInterior :: m -> Either (Boundary m) (Interior m)

toInterior :: m -> Maybe (Interior m)

extendToBoundary :: Interior m -> Needle (Interior m) -> Maybe (Boundary m)

default extendToBoundary :: (VectorSpace (Needle (Interior m)), Num (Scalar (Needle (Interior m)))) => Interior m -> Needle (Interior m) -> Maybe (Boundary m)

smfdWBoundWitness :: SmfdWBoundWitness m

default smfdWBoundWitness :: (OpenManifold (Interior m), OpenManifold (Boundary m), FullSubspace (HalfNeedle m) ~ Needle (Boundary m)) => SmfdWBoundWitness m

needleIsOpenMfd :: (OpenManifold (Needle (Interior m)) => r) -> r

default needleIsOpenMfd :: OpenManifold (Needle (Interior m)) => (OpenManifold (Needle (Interior m)) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior m))) => r) -> r

default scalarIsOpenMfd :: OpenManifold (Scalar (Needle (Interior m))) => (OpenManifold (Scalar (Needle (Interior m))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary m)), Scalar (Needle (Boundary m)) ~ Scalar (Needle (Interior m))) => r) -> r

default boundaryHasSameScalar :: (LinearSpace (Needle (Boundary m)), Scalar (Needle (Boundary m)) ~ Scalar (Needle (Interior m))) => ((LinearSpace (Needle (Boundary m)), Scalar (Needle (Boundary m)) ~ Scalar (Needle (Interior m))) => r) -> r

Instances

SemimanifoldWithBoundary ℝay

Defined in Data.Manifold.Cone

Associated Types

type Interior ℝay

type Boundary ℝay

type HalfNeedle ℝay

Methods

(.+^|) :: ℝay -> Needle (Interior ℝay) -> Either (Boundary ℝay, Scalar (Needle (Interior ℝay))) (Interior ℝay)

fromInterior :: Interior ℝay -> ℝay

fromBoundary :: Boundary ℝay -> ℝay

(|+^) :: Boundary ℝay -> HalfNeedle ℝay -> ℝay

separateInterior :: ℝay -> Either (Boundary ℝay) (Interior ℝay)

toInterior :: ℝay -> Maybe (Interior ℝay)

extendToBoundary :: Interior ℝay -> Needle (Interior ℝay) -> Maybe (Boundary ℝay)

smfdWBoundWitness :: SmfdWBoundWitness ℝay

needleIsOpenMfd :: (OpenManifold (Needle (Interior ℝay)) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior ℝay))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary ℝay)), Scalar (Needle (Boundary ℝay)) ~ Scalar (Needle (Interior ℝay))) => r) -> r

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => SemimanifoldWithBoundary ℝ

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior ℝ

type Boundary ℝ

type HalfNeedle ℝ

Methods

(.+^|) :: ℝ -> Needle (Interior ℝ) -> Either (Boundary ℝ, Scalar (Needle (Interior ℝ))) (Interior ℝ)

fromInterior :: Interior ℝ -> ℝ

fromBoundary :: Boundary ℝ -> ℝ

(|+^) :: Boundary ℝ -> HalfNeedle ℝ -> ℝ

separateInterior :: ℝ -> Either (Boundary ℝ) (Interior ℝ)

toInterior :: ℝ -> Maybe (Interior ℝ)

extendToBoundary :: Interior ℝ -> Needle (Interior ℝ) -> Maybe (Boundary ℝ)

smfdWBoundWitness :: SmfdWBoundWitness ℝ

needleIsOpenMfd :: (OpenManifold (Needle (Interior ℝ)) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior ℝ))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary ℝ)), Scalar (Needle (Boundary ℝ)) ~ Scalar (Needle (Interior ℝ))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V0 s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (V0 s)

type Boundary (V0 s)

type HalfNeedle (V0 s)

Methods

(.+^|) :: V0 s -> Needle (Interior (V0 s)) -> Either (Boundary (V0 s), Scalar (Needle (Interior (V0 s)))) (Interior (V0 s))

fromInterior :: Interior (V0 s) -> V0 s

fromBoundary :: Boundary (V0 s) -> V0 s

(|+^) :: Boundary (V0 s) -> HalfNeedle (V0 s) -> V0 s

separateInterior :: V0 s -> Either (Boundary (V0 s)) (Interior (V0 s))

toInterior :: V0 s -> Maybe (Interior (V0 s))

extendToBoundary :: Interior (V0 s) -> Needle (Interior (V0 s)) -> Maybe (Boundary (V0 s))

smfdWBoundWitness :: SmfdWBoundWitness (V0 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V0 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V0 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V0 s))), Scalar (Needle (Boundary (V0 s))) ~ Scalar (Needle (Interior (V0 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V1 s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (V1 s)

type Boundary (V1 s)

type HalfNeedle (V1 s)

Methods

(.+^|) :: V1 s -> Needle (Interior (V1 s)) -> Either (Boundary (V1 s), Scalar (Needle (Interior (V1 s)))) (Interior (V1 s))

fromInterior :: Interior (V1 s) -> V1 s

fromBoundary :: Boundary (V1 s) -> V1 s

(|+^) :: Boundary (V1 s) -> HalfNeedle (V1 s) -> V1 s

separateInterior :: V1 s -> Either (Boundary (V1 s)) (Interior (V1 s))

toInterior :: V1 s -> Maybe (Interior (V1 s))

extendToBoundary :: Interior (V1 s) -> Needle (Interior (V1 s)) -> Maybe (Boundary (V1 s))

smfdWBoundWitness :: SmfdWBoundWitness (V1 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V1 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V1 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V1 s))), Scalar (Needle (Boundary (V1 s))) ~ Scalar (Needle (Interior (V1 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V2 s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (V2 s)

type Boundary (V2 s)

type HalfNeedle (V2 s)

Methods

(.+^|) :: V2 s -> Needle (Interior (V2 s)) -> Either (Boundary (V2 s), Scalar (Needle (Interior (V2 s)))) (Interior (V2 s))

fromInterior :: Interior (V2 s) -> V2 s

fromBoundary :: Boundary (V2 s) -> V2 s

(|+^) :: Boundary (V2 s) -> HalfNeedle (V2 s) -> V2 s

separateInterior :: V2 s -> Either (Boundary (V2 s)) (Interior (V2 s))

toInterior :: V2 s -> Maybe (Interior (V2 s))

extendToBoundary :: Interior (V2 s) -> Needle (Interior (V2 s)) -> Maybe (Boundary (V2 s))

smfdWBoundWitness :: SmfdWBoundWitness (V2 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V2 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V2 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V2 s))), Scalar (Needle (Boundary (V2 s))) ~ Scalar (Needle (Interior (V2 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V3 s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (V3 s)

type Boundary (V3 s)

type HalfNeedle (V3 s)

Methods

(.+^|) :: V3 s -> Needle (Interior (V3 s)) -> Either (Boundary (V3 s), Scalar (Needle (Interior (V3 s)))) (Interior (V3 s))

fromInterior :: Interior (V3 s) -> V3 s

fromBoundary :: Boundary (V3 s) -> V3 s

(|+^) :: Boundary (V3 s) -> HalfNeedle (V3 s) -> V3 s

separateInterior :: V3 s -> Either (Boundary (V3 s)) (Interior (V3 s))

toInterior :: V3 s -> Maybe (Interior (V3 s))

extendToBoundary :: Interior (V3 s) -> Needle (Interior (V3 s)) -> Maybe (Boundary (V3 s))

smfdWBoundWitness :: SmfdWBoundWitness (V3 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V3 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V3 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V3 s))), Scalar (Needle (Boundary (V3 s))) ~ Scalar (Needle (Interior (V3 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V4 s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (V4 s)

type Boundary (V4 s)

type HalfNeedle (V4 s)

Methods

(.+^|) :: V4 s -> Needle (Interior (V4 s)) -> Either (Boundary (V4 s), Scalar (Needle (Interior (V4 s)))) (Interior (V4 s))

fromInterior :: Interior (V4 s) -> V4 s

fromBoundary :: Boundary (V4 s) -> V4 s

(|+^) :: Boundary (V4 s) -> HalfNeedle (V4 s) -> V4 s

separateInterior :: V4 s -> Either (Boundary (V4 s)) (Interior (V4 s))

toInterior :: V4 s -> Maybe (Interior (V4 s))

extendToBoundary :: Interior (V4 s) -> Needle (Interior (V4 s)) -> Maybe (Boundary (V4 s))

smfdWBoundWitness :: SmfdWBoundWitness (V4 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V4 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V4 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V4 s))), Scalar (Needle (Boundary (V4 s))) ~ Scalar (Needle (Interior (V4 s)))) => r) -> r

(AffineSpace x, Manifold x, Diff x ~ Needle x, Atlas x, HasTrie (ChartIndex x), LinearSpace (Needle x), LinearSpace (Needle' x), Num' (Scalar (Needle x))) => SemimanifoldWithBoundary (Shade x)

Defined in Data.Manifold.Shade

Associated Types

type Interior (Shade x)

type Boundary (Shade x)

type HalfNeedle (Shade x)

Methods

(.+^|) :: Shade x -> Needle (Interior (Shade x)) -> Either (Boundary (Shade x), Scalar (Needle (Interior (Shade x)))) (Interior (Shade x))

fromInterior :: Interior (Shade x) -> Shade x

fromBoundary :: Boundary (Shade x) -> Shade x

(|+^) :: Boundary (Shade x) -> HalfNeedle (Shade x) -> Shade x

separateInterior :: Shade x -> Either (Boundary (Shade x)) (Interior (Shade x))

toInterior :: Shade x -> Maybe (Interior (Shade x))

extendToBoundary :: Interior (Shade x) -> Needle (Interior (Shade x)) -> Maybe (Boundary (Shade x))

smfdWBoundWitness :: SmfdWBoundWitness (Shade x)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Shade x))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Shade x)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Shade x))), Scalar (Needle (Boundary (Shade x))) ~ Scalar (Needle (Interior (Shade x)))) => r) -> r

(AffineSpace x, Manifold x, Diff x ~ Needle x, Atlas' x, LinearSpace (Needle x), LinearSpace (Needle' x)) => SemimanifoldWithBoundary (Shade' x)

Defined in Data.Manifold.Shade

Associated Types

type Interior (Shade' x)

type Boundary (Shade' x)

type HalfNeedle (Shade' x)

Methods

(.+^|) :: Shade' x -> Needle (Interior (Shade' x)) -> Either (Boundary (Shade' x), Scalar (Needle (Interior (Shade' x)))) (Interior (Shade' x))

fromInterior :: Interior (Shade' x) -> Shade' x

fromBoundary :: Boundary (Shade' x) -> Shade' x

(|+^) :: Boundary (Shade' x) -> HalfNeedle (Shade' x) -> Shade' x

separateInterior :: Shade' x -> Either (Boundary (Shade' x)) (Interior (Shade' x))

toInterior :: Shade' x -> Maybe (Interior (Shade' x))

extendToBoundary :: Interior (Shade' x) -> Needle (Interior (Shade' x)) -> Maybe (Boundary (Shade' x))

smfdWBoundWitness :: SmfdWBoundWitness (Shade' x)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Shade' x))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Shade' x)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Shade' x))), Scalar (Needle (Boundary (Shade' x))) ~ Scalar (Needle (Interior (Shade' x)))) => r) -> r

SemimanifoldWithBoundary (CD¹ ℝ⁰)

Defined in Data.Manifold.Cone

Associated Types

type Interior (CD¹ ℝ⁰)

type Boundary (CD¹ ℝ⁰)

type HalfNeedle (CD¹ ℝ⁰)

Methods

(.+^|) :: CD¹ ℝ⁰ -> Needle (Interior (CD¹ ℝ⁰)) -> Either (Boundary (CD¹ ℝ⁰), Scalar (Needle (Interior (CD¹ ℝ⁰)))) (Interior (CD¹ ℝ⁰))

fromInterior :: Interior (CD¹ ℝ⁰) -> CD¹ ℝ⁰

fromBoundary :: Boundary (CD¹ ℝ⁰) -> CD¹ ℝ⁰

(|+^) :: Boundary (CD¹ ℝ⁰) -> HalfNeedle (CD¹ ℝ⁰) -> CD¹ ℝ⁰

separateInterior :: CD¹ ℝ⁰ -> Either (Boundary (CD¹ ℝ⁰)) (Interior (CD¹ ℝ⁰))

toInterior :: CD¹ ℝ⁰ -> Maybe (Interior (CD¹ ℝ⁰))

extendToBoundary :: Interior (CD¹ ℝ⁰) -> Needle (Interior (CD¹ ℝ⁰)) -> Maybe (Boundary (CD¹ ℝ⁰))

smfdWBoundWitness :: SmfdWBoundWitness (CD¹ ℝ⁰)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (CD¹ ℝ⁰))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (CD¹ ℝ⁰)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (CD¹ ℝ⁰))), Scalar (Needle (Boundary (CD¹ ℝ⁰))) ~ Scalar (Needle (Interior (CD¹ ℝ⁰)))) => r) -> r

SemimanifoldWithBoundary (Cℝay S⁰)

Defined in Data.Manifold.Cone

Associated Types

type Interior (Cℝay S⁰)

type Boundary (Cℝay S⁰)

type HalfNeedle (Cℝay S⁰)

Methods

(.+^|) :: Cℝay S⁰ -> Needle (Interior (Cℝay S⁰)) -> Either (Boundary (Cℝay S⁰), Scalar (Needle (Interior (Cℝay S⁰)))) (Interior (Cℝay S⁰))

fromInterior :: Interior (Cℝay S⁰) -> Cℝay S⁰

fromBoundary :: Boundary (Cℝay S⁰) -> Cℝay S⁰

(|+^) :: Boundary (Cℝay S⁰) -> HalfNeedle (Cℝay S⁰) -> Cℝay S⁰

separateInterior :: Cℝay S⁰ -> Either (Boundary (Cℝay S⁰)) (Interior (Cℝay S⁰))

toInterior :: Cℝay S⁰ -> Maybe (Interior (Cℝay S⁰))

extendToBoundary :: Interior (Cℝay S⁰) -> Needle (Interior (Cℝay S⁰)) -> Maybe (Boundary (Cℝay S⁰))

smfdWBoundWitness :: SmfdWBoundWitness (Cℝay S⁰)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Cℝay S⁰))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Cℝay S⁰)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Cℝay S⁰))), Scalar (Needle (Boundary (Cℝay S⁰))) ~ Scalar (Needle (Interior (Cℝay S⁰)))) => r) -> r

(Semimanifold a, Semimanifold (VRep a), Needle a ~ GenericNeedle a, OpenManifold (Scalar (Needle (Rep a Void))), LinearSpace (Needle (Rep a Void)), Num' (Scalar (Needle (Rep a Void)))) => SemimanifoldWithBoundary (GenericNeedle a)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (GenericNeedle a)

type Boundary (GenericNeedle a)

type HalfNeedle (GenericNeedle a)

Methods

(.+^|) :: GenericNeedle a -> Needle (Interior (GenericNeedle a)) -> Either (Boundary (GenericNeedle a), Scalar (Needle (Interior (GenericNeedle a)))) (Interior (GenericNeedle a))

fromInterior :: Interior (GenericNeedle a) -> GenericNeedle a

fromBoundary :: Boundary (GenericNeedle a) -> GenericNeedle a

(|+^) :: Boundary (GenericNeedle a) -> HalfNeedle (GenericNeedle a) -> GenericNeedle a

separateInterior :: GenericNeedle a -> Either (Boundary (GenericNeedle a)) (Interior (GenericNeedle a))

toInterior :: GenericNeedle a -> Maybe (Interior (GenericNeedle a))

extendToBoundary :: Interior (GenericNeedle a) -> Needle (Interior (GenericNeedle a)) -> Maybe (Boundary (GenericNeedle a))

smfdWBoundWitness :: SmfdWBoundWitness (GenericNeedle a)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (GenericNeedle a))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (GenericNeedle a)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (GenericNeedle a))), Scalar (Needle (Boundary (GenericNeedle a))) ~ Scalar (Needle (Interior (GenericNeedle a)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (D¹_ s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (D¹_ s)

type Boundary (D¹_ s)

type HalfNeedle (D¹_ s)

Methods

(.+^|) :: D¹_ s -> Needle (Interior (D¹_ s)) -> Either (Boundary (D¹_ s), Scalar (Needle (Interior (D¹_ s)))) (Interior (D¹_ s))

fromInterior :: Interior (D¹_ s) -> D¹_ s

fromBoundary :: Boundary (D¹_ s) -> D¹_ s

(|+^) :: Boundary (D¹_ s) -> HalfNeedle (D¹_ s) -> D¹_ s

separateInterior :: D¹_ s -> Either (Boundary (D¹_ s)) (Interior (D¹_ s))

toInterior :: D¹_ s -> Maybe (Interior (D¹_ s))

extendToBoundary :: Interior (D¹_ s) -> Needle (Interior (D¹_ s)) -> Maybe (Boundary (D¹_ s))

smfdWBoundWitness :: SmfdWBoundWitness (D¹_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (D¹_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (D¹_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (D¹_ s))), Scalar (Needle (Boundary (D¹_ s))) ~ Scalar (Needle (Interior (D¹_ s)))) => r) -> r

(LinearSpace k, OpenManifold k, OpenManifold (Scalar k)) => SemimanifoldWithBoundary (EmptyMfd k)

Defined in Data.Manifold.WithBoundary.Class

Associated Types

type Interior (EmptyMfd k)

type Boundary (EmptyMfd k)

type HalfNeedle (EmptyMfd k)

Methods

(.+^|) :: EmptyMfd k -> Needle (Interior (EmptyMfd k)) -> Either (Boundary (EmptyMfd k), Scalar (Needle (Interior (EmptyMfd k)))) (Interior (EmptyMfd k))

fromInterior :: Interior (EmptyMfd k) -> EmptyMfd k

fromBoundary :: Boundary (EmptyMfd k) -> EmptyMfd k

(|+^) :: Boundary (EmptyMfd k) -> HalfNeedle (EmptyMfd k) -> EmptyMfd k

separateInterior :: EmptyMfd k -> Either (Boundary (EmptyMfd k)) (Interior (EmptyMfd k))

toInterior :: EmptyMfd k -> Maybe (Interior (EmptyMfd k))

extendToBoundary :: Interior (EmptyMfd k) -> Needle (Interior (EmptyMfd k)) -> Maybe (Boundary (EmptyMfd k))

smfdWBoundWitness :: SmfdWBoundWitness (EmptyMfd k)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (EmptyMfd k))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (EmptyMfd k)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (EmptyMfd k))), Scalar (Needle (Boundary (EmptyMfd k))) ~ Scalar (Needle (Interior (EmptyMfd k)))) => r) -> r

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

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (S²_ s)

type Boundary (S²_ s)

type HalfNeedle (S²_ s)

Methods

(.+^|) :: S²_ s -> Needle (Interior (S²_ s)) -> Either (Boundary (S²_ s), Scalar (Needle (Interior (S²_ s)))) (Interior (S²_ s))

fromInterior :: Interior (S²_ s) -> S²_ s

fromBoundary :: Boundary (S²_ s) -> S²_ s

(|+^) :: Boundary (S²_ s) -> HalfNeedle (S²_ s) -> S²_ s

separateInterior :: S²_ s -> Either (Boundary (S²_ s)) (Interior (S²_ s))

toInterior :: S²_ s -> Maybe (Interior (S²_ s))

extendToBoundary :: Interior (S²_ s) -> Needle (Interior (S²_ s)) -> Maybe (Boundary (S²_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S²_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S²_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S²_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S²_ s))), Scalar (Needle (Boundary (S²_ s))) ~ Scalar (Needle (Interior (S²_ s)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (S¹_ s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (S¹_ s)

type Boundary (S¹_ s)

type HalfNeedle (S¹_ s)

Methods

(.+^|) :: S¹_ s -> Needle (Interior (S¹_ s)) -> Either (Boundary (S¹_ s), Scalar (Needle (Interior (S¹_ s)))) (Interior (S¹_ s))

fromInterior :: Interior (S¹_ s) -> S¹_ s

fromBoundary :: Boundary (S¹_ s) -> S¹_ s

(|+^) :: Boundary (S¹_ s) -> HalfNeedle (S¹_ s) -> S¹_ s

separateInterior :: S¹_ s -> Either (Boundary (S¹_ s)) (Interior (S¹_ s))

toInterior :: S¹_ s -> Maybe (Interior (S¹_ s))

extendToBoundary :: Interior (S¹_ s) -> Needle (Interior (S¹_ s)) -> Maybe (Boundary (S¹_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S¹_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S¹_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S¹_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S¹_ s))), Scalar (Needle (Boundary (S¹_ s))) ~ Scalar (Needle (Interior (S¹_ s)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (S⁰_ s)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (S⁰_ s)

type Boundary (S⁰_ s)

type HalfNeedle (S⁰_ s)

Methods

(.+^|) :: S⁰_ s -> Needle (Interior (S⁰_ s)) -> Either (Boundary (S⁰_ s), Scalar (Needle (Interior (S⁰_ s)))) (Interior (S⁰_ s))

fromInterior :: Interior (S⁰_ s) -> S⁰_ s

fromBoundary :: Boundary (S⁰_ s) -> S⁰_ s

(|+^) :: Boundary (S⁰_ s) -> HalfNeedle (S⁰_ s) -> S⁰_ s

separateInterior :: S⁰_ s -> Either (Boundary (S⁰_ s)) (Interior (S⁰_ s))

toInterior :: S⁰_ s -> Maybe (Interior (S⁰_ s))

extendToBoundary :: Interior (S⁰_ s) -> Needle (Interior (S⁰_ s)) -> Maybe (Boundary (S⁰_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S⁰_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S⁰_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S⁰_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S⁰_ s))), Scalar (Needle (Boundary (S⁰_ s))) ~ Scalar (Needle (Interior (S⁰_ s)))) => r) -> r

(Num' k, OpenManifold k) => SemimanifoldWithBoundary (ZeroDim k)

Defined in Data.Manifold.WithBoundary.Class

Associated Types

type Interior (ZeroDim k)

type Boundary (ZeroDim k)

type HalfNeedle (ZeroDim k)

Methods

(.+^|) :: ZeroDim k -> Needle (Interior (ZeroDim k)) -> Either (Boundary (ZeroDim k), Scalar (Needle (Interior (ZeroDim k)))) (Interior (ZeroDim k))

fromInterior :: Interior (ZeroDim k) -> ZeroDim k

fromBoundary :: Boundary (ZeroDim k) -> ZeroDim k

(|+^) :: Boundary (ZeroDim k) -> HalfNeedle (ZeroDim k) -> ZeroDim k

separateInterior :: ZeroDim k -> Either (Boundary (ZeroDim k)) (Interior (ZeroDim k))

toInterior :: ZeroDim k -> Maybe (Interior (ZeroDim k))

extendToBoundary :: Interior (ZeroDim k) -> Needle (Interior (ZeroDim k)) -> Maybe (Boundary (ZeroDim k))

smfdWBoundWitness :: SmfdWBoundWitness (ZeroDim k)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (ZeroDim k))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (ZeroDim k)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (ZeroDim k))), Scalar (Needle (Boundary (ZeroDim k))) ~ Scalar (Needle (Interior (ZeroDim k)))) => r) -> r

(Num' n, OpenManifold n, LinearManifold (a n), Scalar (a n) ~ n, Needle (a n) ~ a n) => SemimanifoldWithBoundary (Point a n)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (Point a n)

type Boundary (Point a n)

type HalfNeedle (Point a n)

Methods

(.+^|) :: Point a n -> Needle (Interior (Point a n)) -> Either (Boundary (Point a n), Scalar (Needle (Interior (Point a n)))) (Interior (Point a n))

fromInterior :: Interior (Point a n) -> Point a n

fromBoundary :: Boundary (Point a n) -> Point a n

(|+^) :: Boundary (Point a n) -> HalfNeedle (Point a n) -> Point a n

separateInterior :: Point a n -> Either (Boundary (Point a n)) (Interior (Point a n))

toInterior :: Point a n -> Maybe (Interior (Point a n))

extendToBoundary :: Interior (Point a n) -> Needle (Interior (Point a n)) -> Maybe (Boundary (Point a n))

smfdWBoundWitness :: SmfdWBoundWitness (Point a n)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Point a n))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Point a n)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Point a n))), Scalar (Needle (Boundary (Point a n))) ~ Scalar (Needle (Interior (Point a n)))) => r) -> r

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b)], RealFrac'' (Scalar (Needle (Interior a))), ProjectableBoundary (Interior a), ProjectableBoundary (Interior b)) => SemimanifoldWithBoundary (a, b)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (a, b)

type Boundary (a, b)

type HalfNeedle (a, b)

Methods

(.+^|) :: (a, b) -> Needle (Interior (a, b)) -> Either (Boundary (a, b), Scalar (Needle (Interior (a, b)))) (Interior (a, b))

fromInterior :: Interior (a, b) -> (a, b)

fromBoundary :: Boundary (a, b) -> (a, b)

(|+^) :: Boundary (a, b) -> HalfNeedle (a, b) -> (a, b)

separateInterior :: (a, b) -> Either (Boundary (a, b)) (Interior (a, b))

toInterior :: (a, b) -> Maybe (Interior (a, b))

extendToBoundary :: Interior (a, b) -> Needle (Interior (a, b)) -> Maybe (Boundary (a, b))

smfdWBoundWitness :: SmfdWBoundWitness (a, b)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (a, b))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (a, b)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (a, b))), Scalar (Needle (Boundary (a, b))) ~ Scalar (Needle (Interior (a, b)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (LinearFunction s v w)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (LinearFunction s v w)

type Boundary (LinearFunction s v w)

type HalfNeedle (LinearFunction s v w)

Methods

(.+^|) :: LinearFunction s v w -> Needle (Interior (LinearFunction s v w)) -> Either (Boundary (LinearFunction s v w), Scalar (Needle (Interior (LinearFunction s v w)))) (Interior (LinearFunction s v w))

fromInterior :: Interior (LinearFunction s v w) -> LinearFunction s v w

fromBoundary :: Boundary (LinearFunction s v w) -> LinearFunction s v w

(|+^) :: Boundary (LinearFunction s v w) -> HalfNeedle (LinearFunction s v w) -> LinearFunction s v w

separateInterior :: LinearFunction s v w -> Either (Boundary (LinearFunction s v w)) (Interior (LinearFunction s v w))

toInterior :: LinearFunction s v w -> Maybe (Interior (LinearFunction s v w))

extendToBoundary :: Interior (LinearFunction s v w) -> Needle (Interior (LinearFunction s v w)) -> Maybe (Boundary (LinearFunction s v w))

smfdWBoundWitness :: SmfdWBoundWitness (LinearFunction s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (LinearFunction s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (LinearFunction s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (LinearFunction s v w))), Scalar (Needle (Boundary (LinearFunction s v w))) ~ Scalar (Needle (Interior (LinearFunction s v w)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (LinearMap s v w)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (LinearMap s v w)

type Boundary (LinearMap s v w)

type HalfNeedle (LinearMap s v w)

Methods

(.+^|) :: LinearMap s v w -> Needle (Interior (LinearMap s v w)) -> Either (Boundary (LinearMap s v w), Scalar (Needle (Interior (LinearMap s v w)))) (Interior (LinearMap s v w))

fromInterior :: Interior (LinearMap s v w) -> LinearMap s v w

fromBoundary :: Boundary (LinearMap s v w) -> LinearMap s v w

(|+^) :: Boundary (LinearMap s v w) -> HalfNeedle (LinearMap s v w) -> LinearMap s v w

separateInterior :: LinearMap s v w -> Either (Boundary (LinearMap s v w)) (Interior (LinearMap s v w))

toInterior :: LinearMap s v w -> Maybe (Interior (LinearMap s v w))

extendToBoundary :: Interior (LinearMap s v w) -> Needle (Interior (LinearMap s v w)) -> Maybe (Boundary (LinearMap s v w))

smfdWBoundWitness :: SmfdWBoundWitness (LinearMap s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (LinearMap s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (LinearMap s v w))), Scalar (Needle (Boundary (LinearMap s v w))) ~ Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (Tensor s v w)

Defined in Data.Manifold.WithBoundary

Associated Types

type Interior (Tensor s v w)

type Boundary (Tensor s v w)

type HalfNeedle (Tensor s v w)

Methods

(.+^|) :: Tensor s v w -> Needle (Interior (Tensor s v w)) -> Either (Boundary (Tensor s v w), Scalar (Needle (Interior (Tensor s v w)))) (Interior (Tensor s v w))

fromInterior :: Interior (Tensor s v w) -> Tensor s v w

fromBoundary :: Boundary (Tensor s v w) -> Tensor s v w

(|+^) :: Boundary (Tensor s v w) -> HalfNeedle (Tensor s v w) -> Tensor s v w

separateInterior :: Tensor s v w -> Either (Boundary (Tensor s v w)) (Interior (Tensor s v w))

toInterior :: Tensor s v w -> Maybe (Interior (Tensor s v w))

extendToBoundary :: Interior (Tensor s v w) -> Needle (Interior (Tensor s v w)) -> Maybe (Boundary (Tensor s v w))

smfdWBoundWitness :: SmfdWBoundWitness (Tensor s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Tensor s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Tensor s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Tensor s v w))), Scalar (Needle (Boundary (Tensor s v w))) ~ Scalar (Needle (Interior (Tensor s v w)))) => r) -> r

class (SemimanifoldWithBoundary m, PseudoAffine (Interior m), PseudoAffine (Boundary m)) => PseudoAffineWithBoundary m where

Minimal complete definition

(.--!), (!-|)

Methods

(.--!) :: m -> m -> Needle (Interior m)

Inverse of .+^|, provided the space is connected. For p :: Interior m, q :: m and v = fromInterior p.--!q,

  q .+^| v ≡ Right p
  

(up to floating-point). Similary, for b :: Boundary m and w = fromBoundary m.--!q,

  q .+^| w ≡ Left (b, 0)
  

(.-|) :: m -> Boundary m -> Maybe (HalfNeedle m)

(!-|) :: m -> Boundary m -> HalfNeedle m

(.--.) :: m -> m -> Maybe (Needle (Interior m))

Instances

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => PseudoAffineWithBoundary ℝ

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: ℝ -> ℝ -> Needle (Interior ℝ)

(.-|) :: ℝ -> Boundary ℝ -> Maybe (HalfNeedle ℝ)

(!-|) :: ℝ -> Boundary ℝ -> HalfNeedle ℝ

(.--.) :: ℝ -> ℝ -> Maybe (Needle (Interior ℝ))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V0 s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: V0 s -> V0 s -> Needle (Interior (V0 s))

(.-|) :: V0 s -> Boundary (V0 s) -> Maybe (HalfNeedle (V0 s))

(!-|) :: V0 s -> Boundary (V0 s) -> HalfNeedle (V0 s)

(.--.) :: V0 s -> V0 s -> Maybe (Needle (Interior (V0 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V1 s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: V1 s -> V1 s -> Needle (Interior (V1 s))

(.-|) :: V1 s -> Boundary (V1 s) -> Maybe (HalfNeedle (V1 s))

(!-|) :: V1 s -> Boundary (V1 s) -> HalfNeedle (V1 s)

(.--.) :: V1 s -> V1 s -> Maybe (Needle (Interior (V1 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V2 s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: V2 s -> V2 s -> Needle (Interior (V2 s))

(.-|) :: V2 s -> Boundary (V2 s) -> Maybe (HalfNeedle (V2 s))

(!-|) :: V2 s -> Boundary (V2 s) -> HalfNeedle (V2 s)

(.--.) :: V2 s -> V2 s -> Maybe (Needle (Interior (V2 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V3 s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: V3 s -> V3 s -> Needle (Interior (V3 s))

(.-|) :: V3 s -> Boundary (V3 s) -> Maybe (HalfNeedle (V3 s))

(!-|) :: V3 s -> Boundary (V3 s) -> HalfNeedle (V3 s)

(.--.) :: V3 s -> V3 s -> Maybe (Needle (Interior (V3 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V4 s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: V4 s -> V4 s -> Needle (Interior (V4 s))

(.-|) :: V4 s -> Boundary (V4 s) -> Maybe (HalfNeedle (V4 s))

(!-|) :: V4 s -> Boundary (V4 s) -> HalfNeedle (V4 s)

(.--.) :: V4 s -> V4 s -> Maybe (Needle (Interior (V4 s)))

(Semimanifold a, Semimanifold (VRep a), Needle a ~ GenericNeedle a, OpenManifold (Scalar (Needle (Rep a Void))), LinearSpace (Needle (Rep a Void)), Num' (Scalar (Needle (Rep a Void)))) => PseudoAffineWithBoundary (GenericNeedle a)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: GenericNeedle a -> GenericNeedle a -> Needle (Interior (GenericNeedle a))

(.-|) :: GenericNeedle a -> Boundary (GenericNeedle a) -> Maybe (HalfNeedle (GenericNeedle a))

(!-|) :: GenericNeedle a -> Boundary (GenericNeedle a) -> HalfNeedle (GenericNeedle a)

(.--.) :: GenericNeedle a -> GenericNeedle a -> Maybe (Needle (Interior (GenericNeedle a)))

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

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: S²_ s -> Boundary (S²_ s) -> Maybe (HalfNeedle (S²_ s))

(!-|) :: S²_ s -> Boundary (S²_ s) -> HalfNeedle (S²_ s)

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

RealFloat'' s => PseudoAffineWithBoundary (S¹_ s)

Defined in Data.Manifold.WithBoundary

Methods

(.--!) :: S¹_ s -> S¹_ s -> Needle (Interior (S¹_ s))

(.-|) :: S¹_ s -> Boundary (S¹_ s) -> Maybe (HalfNeedle (S¹_ s))

(!-|) :: S¹_ s -> Boundary (S¹_ s) -> HalfNeedle (S¹_ s)

(.--.) :: S¹_ s -> S¹_ s -> Maybe (Needle (Interior (S¹_ s)))

(Num' k, OpenManifold k) => PseudoAffineWithBoundary (ZeroDim k)

Defined in Data.Manifold.WithBoundary.Class

Methods

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

(.-|) :: ZeroDim k -> Boundary (ZeroDim k) -> Maybe (HalfNeedle (ZeroDim k))

(!-|) :: ZeroDim k -> Boundary (ZeroDim k) -> HalfNeedle (ZeroDim k)

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

(Num' n, OpenManifold n, LinearManifold (a n), Scalar (a n) ~ n, Needle (a n) ~ a n) => PseudoAffineWithBoundary (Point a n)

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: Point a n -> Boundary (Point a n) -> Maybe (HalfNeedle (Point a n))

(!-|) :: Point a n -> Boundary (Point a n) -> HalfNeedle (Point a n)

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

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b), Needle (Boundary a), Needle (Boundary b)], ProjectableBoundary (Interior a), ProjectableBoundary (Interior b), RealFrac'' (Scalar (Needle (Interior a)))) => PseudoAffineWithBoundary (a, b)

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: (a, b) -> Boundary (a, b) -> Maybe (HalfNeedle (a, b))

(!-|) :: (a, b) -> Boundary (a, b) -> HalfNeedle (a, b)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (LinearFunction s v w)

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: LinearFunction s v w -> Boundary (LinearFunction s v w) -> Maybe (HalfNeedle (LinearFunction s v w))

(!-|) :: LinearFunction s v w -> Boundary (LinearFunction s v w) -> HalfNeedle (LinearFunction s v w)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (LinearMap s v w)

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: LinearMap s v w -> Boundary (LinearMap s v w) -> Maybe (HalfNeedle (LinearMap s v w))

(!-|) :: LinearMap s v w -> Boundary (LinearMap s v w) -> HalfNeedle (LinearMap s v w)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (Tensor s v w)

Defined in Data.Manifold.WithBoundary

Methods

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

(.-|) :: Tensor s v w -> Boundary (Tensor s v w) -> Maybe (HalfNeedle (Tensor s v w))

(!-|) :: Tensor s v w -> Boundary (Tensor s v w) -> HalfNeedle (Tensor s v w)

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

class PseudoAffineWithBoundary m => ProjectableBoundary m where

Minimal complete definition

projectToBoundary, marginFromBoundary

Methods

projectToBoundary

Arguments

:: m

Point p to project

-> Boundary m

Intended “course region” representative r on boundary – we seek a point that is reachable from there.

-> Maybe (Needle (Boundary m), Scalar (Needle (Interior m)))

Needle δr connecting r to projection of the p, and a measure d of normal-distance such that marginFromBoundary (r.+~^δr) d == p.

marginFromBoundary :: Boundary m -> Scalar (Needle (Interior m)) -> m

needleBoundaryIsTriviallyProjectible :: forall r. (ProjectableBoundary (Needle (Interior m)) => r) -> r

default needleBoundaryIsTriviallyProjectible :: ProjectableBoundary (Needle (Interior m)) => (ProjectableBoundary (Needle (Interior m)) => r) -> r

scalarBoundaryIsTriviallyProjectible :: forall r. (ProjectableBoundary (Scalar (Needle (Interior m))) => r) -> r

default scalarBoundaryIsTriviallyProjectible :: ProjectableBoundary (Scalar (Needle (Interior m))) => (ProjectableBoundary (Scalar (Needle (Interior m))) => r) -> r

Instances

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => ProjectableBoundary ℝ

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: ℝ -> Boundary ℝ -> Maybe (Needle (Boundary ℝ), Scalar (Needle (Interior ℝ)))

marginFromBoundary :: Boundary ℝ -> Scalar (Needle (Interior ℝ)) -> ℝ

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior ℝ)) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior ℝ))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V0 s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: V0 s -> Boundary (V0 s) -> Maybe (Needle (Boundary (V0 s)), Scalar (Needle (Interior (V0 s))))

marginFromBoundary :: Boundary (V0 s) -> Scalar (Needle (Interior (V0 s))) -> V0 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V0 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V0 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V1 s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: V1 s -> Boundary (V1 s) -> Maybe (Needle (Boundary (V1 s)), Scalar (Needle (Interior (V1 s))))

marginFromBoundary :: Boundary (V1 s) -> Scalar (Needle (Interior (V1 s))) -> V1 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V1 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V1 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V2 s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: V2 s -> Boundary (V2 s) -> Maybe (Needle (Boundary (V2 s)), Scalar (Needle (Interior (V2 s))))

marginFromBoundary :: Boundary (V2 s) -> Scalar (Needle (Interior (V2 s))) -> V2 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V2 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V2 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V3 s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: V3 s -> Boundary (V3 s) -> Maybe (Needle (Boundary (V3 s)), Scalar (Needle (Interior (V3 s))))

marginFromBoundary :: Boundary (V3 s) -> Scalar (Needle (Interior (V3 s))) -> V3 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V3 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V3 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V4 s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: V4 s -> Boundary (V4 s) -> Maybe (Needle (Boundary (V4 s)), Scalar (Needle (Interior (V4 s))))

marginFromBoundary :: Boundary (V4 s) -> Scalar (Needle (Interior (V4 s))) -> V4 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V4 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V4 s)))) => r) -> r

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

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: S²_ s -> Boundary (S²_ s) -> Maybe (Needle (Boundary (S²_ s)), Scalar (Needle (Interior (S²_ s))))

marginFromBoundary :: Boundary (S²_ s) -> Scalar (Needle (Interior (S²_ s))) -> S²_ s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (S²_ s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (S²_ s)))) => r) -> r

RealFloat'' s => ProjectableBoundary (S¹_ s)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: S¹_ s -> Boundary (S¹_ s) -> Maybe (Needle (Boundary (S¹_ s)), Scalar (Needle (Interior (S¹_ s))))

marginFromBoundary :: Boundary (S¹_ s) -> Scalar (Needle (Interior (S¹_ s))) -> S¹_ s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (S¹_ s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (S¹_ s)))) => r) -> r

(Num' k, ProjectableBoundary k, OpenManifold k) => ProjectableBoundary (ZeroDim k)

Defined in Data.Manifold.WithBoundary.Class

Methods

projectToBoundary :: ZeroDim k -> Boundary (ZeroDim k) -> Maybe (Needle (Boundary (ZeroDim k)), Scalar (Needle (Interior (ZeroDim k))))

marginFromBoundary :: Boundary (ZeroDim k) -> Scalar (Needle (Interior (ZeroDim k))) -> ZeroDim k

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (ZeroDim k))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (ZeroDim k)))) => r) -> r

(Num' n, OpenManifold n, LinearManifold (a n), ProjectableBoundary n, Scalar (a n) ~ n, Needle (a n) ~ a n) => ProjectableBoundary (Point a n)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: Point a n -> Boundary (Point a n) -> Maybe (Needle (Boundary (Point a n)), Scalar (Needle (Interior (Point a n))))

marginFromBoundary :: Boundary (Point a n) -> Scalar (Needle (Interior (Point a n))) -> Point a n

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (Point a n))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (Point a n)))) => r) -> r

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b), Needle (Boundary a), Needle (Boundary b)], ProjectableBoundary (Interior a), ProjectableBoundary (Interior b), RealFrac'' (Scalar (Needle (Interior a)))) => ProjectableBoundary (a, b)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: (a, b) -> Boundary (a, b) -> Maybe (Needle (Boundary (a, b)), Scalar (Needle (Interior (a, b))))

marginFromBoundary :: Boundary (a, b) -> Scalar (Needle (Interior (a, b))) -> (a, b)

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (a, b))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (a, b)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (LinearMap s v w)

Defined in Data.Manifold.WithBoundary

Methods

projectToBoundary :: LinearMap s v w -> Boundary (LinearMap s v w) -> Maybe (Needle (Boundary (LinearMap s v w)), Scalar (Needle (Interior (LinearMap s v w))))

marginFromBoundary :: Boundary (LinearMap s v w) -> Scalar (Needle (Interior (LinearMap s v w))) -> LinearMap s v w

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (LinearMap s v w))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

data SmfdWBoundWitness m where

Constructors

OpenManifoldWitness :: forall m. OpenManifold m => SmfdWBoundWitness m

SmfdWBoundWitness :: forall m. (OpenManifold (Interior m), OpenManifold (Boundary m), FullSubspace (HalfNeedle m) ~ Needle (Boundary m)) => SmfdWBoundWitness m

class AdditiveMonoid h where

Minimal complete definition

Nothing

Methods

zeroHV :: h

addHVs :: h -> h -> h

Instances

AdditiveMonoid Int16

Defined in Data.Monoid.Additive

Methods

zeroHV :: Int16

addHVs :: Int16 -> Int16 -> Int16

AdditiveMonoid Int32

Defined in Data.Monoid.Additive

Methods

zeroHV :: Int32

addHVs :: Int32 -> Int32 -> Int32

AdditiveMonoid Int64

Defined in Data.Monoid.Additive

Methods

zeroHV :: Int64

addHVs :: Int64 -> Int64 -> Int64

AdditiveMonoid Int8

Defined in Data.Monoid.Additive

Methods

zeroHV :: Int8

addHVs :: Int8 -> Int8 -> Int8

AdditiveMonoid Word16

Defined in Data.Monoid.Additive

Methods

zeroHV :: Word16

addHVs :: Word16 -> Word16 -> Word16

AdditiveMonoid Word32

Defined in Data.Monoid.Additive

Methods

zeroHV :: Word32

addHVs :: Word32 -> Word32 -> Word32

AdditiveMonoid Word64

Defined in Data.Monoid.Additive

Methods

zeroHV :: Word64

addHVs :: Word64 -> Word64 -> Word64

AdditiveMonoid Word8

Defined in Data.Monoid.Additive

Methods

zeroHV :: Word8

addHVs :: Word8 -> Word8 -> Word8

AdditiveMonoid Integer

Defined in Data.Monoid.Additive

Methods

zeroHV :: Integer

addHVs :: Integer -> Integer -> Integer

AdditiveMonoid Double

Defined in Data.Monoid.Additive

Methods

zeroHV :: Double

addHVs :: Double -> Double -> Double

AdditiveMonoid Float

Defined in Data.Monoid.Additive

Methods

zeroHV :: Float

addHVs :: Float -> Float -> Float

AdditiveMonoid Int

Defined in Data.Monoid.Additive

Methods

zeroHV :: Int

addHVs :: Int -> Int -> Int

AdditiveMonoid Word

Defined in Data.Monoid.Additive

Methods

zeroHV :: Word

addHVs :: Word -> Word -> Word

Num k => AdditiveMonoid (Cℝay (ZeroDim k))

Defined in Data.Monoid.Additive

Methods

zeroHV :: Cℝay (ZeroDim k)

addHVs :: Cℝay (ZeroDim k) -> Cℝay (ZeroDim k) -> Cℝay (ZeroDim k)

AdditiveGroup (Needle (Rep a Void)) => AdditiveMonoid (GenericNeedle a)

Defined in Data.Monoid.Additive

Methods

zeroHV :: GenericNeedle a

addHVs :: GenericNeedle a -> GenericNeedle a -> GenericNeedle a

AdditiveMonoid (ZeroDim k)

Defined in Data.Monoid.Additive

Methods

zeroHV :: ZeroDim k

addHVs :: ZeroDim k -> ZeroDim k -> ZeroDim k

(AdditiveMonoid h, AdditiveMonoid i) => AdditiveMonoid (h, i)

Defined in Data.Monoid.Additive

Methods

zeroHV :: (h, i)

addHVs :: (h, i) -> (h, i) -> (h, i)

AdditiveMonoid h => AdditiveMonoid (Rec0 h s)

Defined in Data.Monoid.Additive

Methods

zeroHV :: Rec0 h s

addHVs :: Rec0 h s -> Rec0 h s -> Rec0 h s

(AdditiveMonoid h, AdditiveMonoid i, AdditiveMonoid j) => AdditiveMonoid (h, i, j)

Defined in Data.Monoid.Additive

Methods

zeroHV :: (h, i, j)

addHVs :: (h, i, j) -> (h, i, j) -> (h, i, j)

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

Defined in Data.Monoid.Additive

Methods

zeroHV :: (f :*: g) p

addHVs :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

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

Defined in Data.Monoid.Additive

Methods

zeroHV :: M1 i c f p

addHVs :: M1 i c f p -> M1 i c f p -> M1 i c f p

class AdditiveMonoid h => HalfSpace h where

Minimal complete definition

Nothing

Associated Types

type FullSubspace h

type FullSubspace h = GenericFullSubspace h

type Ray h

type Ray h = Ray (AMRep h)

type MirrorJoin h

type MirrorJoin h = GenericMirrorJoin h

Methods

scaleNonNeg :: Ray h -> h -> h

fromFullSubspace :: FullSubspace h -> h

projectToFullSubspace :: h -> FullSubspace h

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace h), ScalarSpace (Scalar (FullSubspace h)), Scalar (FullSubspace h) ~ MirrorJoin (Ray h)) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray h) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin h), Scalar (MirrorJoin h) ~ MirrorJoin (Ray h)) => r) -> r

fromPositiveHalf :: h -> MirrorJoin h

fromNegativeHalf :: h -> MirrorJoin h

Instances

(Num k, VectorSpace k, Scalar k ~ k) => HalfSpace (Cℝay (ZeroDim k))

Defined in Data.Monoid.Additive

Associated Types

type FullSubspace (Cℝay (ZeroDim k))

type Ray (Cℝay (ZeroDim k))

type MirrorJoin (Cℝay (ZeroDim k))

Methods

scaleNonNeg :: Ray (Cℝay (ZeroDim k)) -> Cℝay (ZeroDim k) -> Cℝay (ZeroDim k)

fromFullSubspace :: FullSubspace (Cℝay (ZeroDim k)) -> Cℝay (ZeroDim k)

projectToFullSubspace :: Cℝay (ZeroDim k) -> FullSubspace (Cℝay (ZeroDim k))

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace (Cℝay (ZeroDim k))), ScalarSpace (Scalar (FullSubspace (Cℝay (ZeroDim k)))), Scalar (FullSubspace (Cℝay (ZeroDim k))) ~ MirrorJoin (Ray (Cℝay (ZeroDim k)))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray (Cℝay (ZeroDim k))) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin (Cℝay (ZeroDim k))), Scalar (MirrorJoin (Cℝay (ZeroDim k))) ~ MirrorJoin (Ray (Cℝay (ZeroDim k)))) => r) -> r

fromPositiveHalf :: Cℝay (ZeroDim k) -> MirrorJoin (Cℝay (ZeroDim k))

fromNegativeHalf :: Cℝay (ZeroDim k) -> MirrorJoin (Cℝay (ZeroDim k))

ScalarSpace k => HalfSpace (ZeroDim k)

Defined in Data.Monoid.Additive

Associated Types

type FullSubspace (ZeroDim k)

type Ray (ZeroDim k)

type MirrorJoin (ZeroDim k)

Methods

scaleNonNeg :: Ray (ZeroDim k) -> ZeroDim k -> ZeroDim k

fromFullSubspace :: FullSubspace (ZeroDim k) -> ZeroDim k

projectToFullSubspace :: ZeroDim k -> FullSubspace (ZeroDim k)

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace (ZeroDim k)), ScalarSpace (Scalar (FullSubspace (ZeroDim k))), Scalar (FullSubspace (ZeroDim k)) ~ MirrorJoin (Ray (ZeroDim k))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray (ZeroDim k)) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin (ZeroDim k)), Scalar (MirrorJoin (ZeroDim k)) ~ MirrorJoin (Ray (ZeroDim k))) => r) -> r

fromPositiveHalf :: ZeroDim k -> MirrorJoin (ZeroDim k)

fromNegativeHalf :: ZeroDim k -> MirrorJoin (ZeroDim k)

(HalfSpace x, VectorSpace y, AdditiveMonoid y, Ray x ~ Cℝay (ZeroDim (Scalar y))) => HalfSpace (x, y)

Defined in Data.Monoid.Additive

Associated Types

type FullSubspace (x, y)

type Ray (x, y)

type MirrorJoin (x, y)

Methods

scaleNonNeg :: Ray (x, y) -> (x, y) -> (x, y)

fromFullSubspace :: FullSubspace (x, y) -> (x, y)

projectToFullSubspace :: (x, y) -> FullSubspace (x, y)

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace (x, y)), ScalarSpace (Scalar (FullSubspace (x, y))), Scalar (FullSubspace (x, y)) ~ MirrorJoin (Ray (x, y))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray (x, y)) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin (x, y)), Scalar (MirrorJoin (x, y)) ~ MirrorJoin (Ray (x, y))) => r) -> r

fromPositiveHalf :: (x, y) -> MirrorJoin (x, y)

fromNegativeHalf :: (x, y) -> MirrorJoin (x, y)

HalfSpace h => HalfSpace (Rec0 h s)

Defined in Data.Monoid.Additive

Associated Types

type FullSubspace (Rec0 h s)

type Ray (Rec0 h s)

type MirrorJoin (Rec0 h s)

Methods

scaleNonNeg :: Ray (Rec0 h s) -> Rec0 h s -> Rec0 h s

fromFullSubspace :: FullSubspace (Rec0 h s) -> Rec0 h s

projectToFullSubspace :: Rec0 h s -> FullSubspace (Rec0 h s)

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace (Rec0 h s)), ScalarSpace (Scalar (FullSubspace (Rec0 h s))), Scalar (FullSubspace (Rec0 h s)) ~ MirrorJoin (Ray (Rec0 h s))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray (Rec0 h s)) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin (Rec0 h s)), Scalar (MirrorJoin (Rec0 h s)) ~ MirrorJoin (Ray (Rec0 h s))) => r) -> r

fromPositiveHalf :: Rec0 h s -> MirrorJoin (Rec0 h s)

fromNegativeHalf :: Rec0 h s -> MirrorJoin (Rec0 h s)

(HalfSpace (f p), VectorSpace (g p), AdditiveMonoid (g p), Ray (f p) ~ Cℝay (ZeroDim (Scalar (g p)))) => HalfSpace ((f :*: g) p)

Defined in Data.Monoid.Additive

Associated Types

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

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

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

Methods

scaleNonNeg :: Ray ((f :*: g) p) -> (f :*: g) p -> (f :*: g) p

fromFullSubspace :: FullSubspace ((f :*: g) p) -> (f :*: g) p

projectToFullSubspace :: (f :*: g) p -> FullSubspace ((f :*: g) p)

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace ((f :*: g) p)), ScalarSpace (Scalar (FullSubspace ((f :*: g) p))), Scalar (FullSubspace ((f :*: g) p)) ~ MirrorJoin (Ray ((f :*: g) p))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray ((f :*: g) p)) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin ((f :*: g) p)), Scalar (MirrorJoin ((f :*: g) p)) ~ MirrorJoin (Ray ((f :*: g) p))) => r) -> r

fromPositiveHalf :: (f :*: g) p -> MirrorJoin ((f :*: g) p)

fromNegativeHalf :: (f :*: g) p -> MirrorJoin ((f :*: g) p)

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

Defined in Data.Monoid.Additive

Associated Types

type FullSubspace (M1 i c f p)

type Ray (M1 i c f p)

type MirrorJoin (M1 i c f p)

Methods

scaleNonNeg :: Ray (M1 i c f p) -> M1 i c f p -> M1 i c f p

fromFullSubspace :: FullSubspace (M1 i c f p) -> M1 i c f p

projectToFullSubspace :: M1 i c f p -> FullSubspace (M1 i c f p)

fullSubspaceIsVectorSpace :: ((VectorSpace (FullSubspace (M1 i c f p)), ScalarSpace (Scalar (FullSubspace (M1 i c f p))), Scalar (FullSubspace (M1 i c f p)) ~ MirrorJoin (Ray (M1 i c f p))) => r) -> r

rayIsHalfSpace :: (HalfSpace (Ray (M1 i c f p)) => r) -> r

mirrorJoinIsVectorSpace :: ((VectorSpace (MirrorJoin (M1 i c f p)), Scalar (MirrorJoin (M1 i c f p)) ~ MirrorJoin (Ray (M1 i c f p))) => r) -> r

fromPositiveHalf :: M1 i c f p -> MirrorJoin (M1 i c f p)

fromNegativeHalf :: M1 i c f p -> MirrorJoin (M1 i c f p)

Orphan instances

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => ProjectableBoundary ℝ

Methods

projectToBoundary :: ℝ -> Boundary ℝ -> Maybe (Needle (Boundary ℝ), Scalar (Needle (Interior ℝ)))

marginFromBoundary :: Boundary ℝ -> Scalar (Needle (Interior ℝ)) -> ℝ

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior ℝ)) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior ℝ))) => r) -> r

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => PseudoAffineWithBoundary ℝ

Methods

(.--!) :: ℝ -> ℝ -> Needle (Interior ℝ)

(.-|) :: ℝ -> Boundary ℝ -> Maybe (HalfNeedle ℝ)

(!-|) :: ℝ -> Boundary ℝ -> HalfNeedle ℝ

(.--.) :: ℝ -> ℝ -> Maybe (Needle (Interior ℝ))

(Num' ℝ, Eq ℝ, OpenManifold ℝ, ProjectableBoundary ℝ) => SemimanifoldWithBoundary ℝ

Associated Types

type Interior ℝ

type Boundary ℝ

type HalfNeedle ℝ

Methods

(.+^|) :: ℝ -> Needle (Interior ℝ) -> Either (Boundary ℝ, Scalar (Needle (Interior ℝ))) (Interior ℝ)

fromInterior :: Interior ℝ -> ℝ

fromBoundary :: Boundary ℝ -> ℝ

(|+^) :: Boundary ℝ -> HalfNeedle ℝ -> ℝ

separateInterior :: ℝ -> Either (Boundary ℝ) (Interior ℝ)

toInterior :: ℝ -> Maybe (Interior ℝ)

extendToBoundary :: Interior ℝ -> Needle (Interior ℝ) -> Maybe (Boundary ℝ)

smfdWBoundWitness :: SmfdWBoundWitness ℝ

needleIsOpenMfd :: (OpenManifold (Needle (Interior ℝ)) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior ℝ))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary ℝ)), Scalar (Needle (Boundary ℝ)) ~ Scalar (Needle (Interior ℝ))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V0 s)

Methods

projectToBoundary :: V0 s -> Boundary (V0 s) -> Maybe (Needle (Boundary (V0 s)), Scalar (Needle (Interior (V0 s))))

marginFromBoundary :: Boundary (V0 s) -> Scalar (Needle (Interior (V0 s))) -> V0 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V0 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V0 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V1 s)

Methods

projectToBoundary :: V1 s -> Boundary (V1 s) -> Maybe (Needle (Boundary (V1 s)), Scalar (Needle (Interior (V1 s))))

marginFromBoundary :: Boundary (V1 s) -> Scalar (Needle (Interior (V1 s))) -> V1 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V1 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V1 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V2 s)

Methods

projectToBoundary :: V2 s -> Boundary (V2 s) -> Maybe (Needle (Boundary (V2 s)), Scalar (Needle (Interior (V2 s))))

marginFromBoundary :: Boundary (V2 s) -> Scalar (Needle (Interior (V2 s))) -> V2 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V2 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V2 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V3 s)

Methods

projectToBoundary :: V3 s -> Boundary (V3 s) -> Maybe (Needle (Boundary (V3 s)), Scalar (Needle (Interior (V3 s))))

marginFromBoundary :: Boundary (V3 s) -> Scalar (Needle (Interior (V3 s))) -> V3 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V3 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V3 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (V4 s)

Methods

projectToBoundary :: V4 s -> Boundary (V4 s) -> Maybe (Needle (Boundary (V4 s)), Scalar (Needle (Interior (V4 s))))

marginFromBoundary :: Boundary (V4 s) -> Scalar (Needle (Interior (V4 s))) -> V4 s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (V4 s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (V4 s)))) => r) -> r

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

Methods

projectToBoundary :: S²_ s -> Boundary (S²_ s) -> Maybe (Needle (Boundary (S²_ s)), Scalar (Needle (Interior (S²_ s))))

marginFromBoundary :: Boundary (S²_ s) -> Scalar (Needle (Interior (S²_ s))) -> S²_ s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (S²_ s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (S²_ s)))) => r) -> r

RealFloat'' s => ProjectableBoundary (S¹_ s)

Methods

projectToBoundary :: S¹_ s -> Boundary (S¹_ s) -> Maybe (Needle (Boundary (S¹_ s)), Scalar (Needle (Interior (S¹_ s))))

marginFromBoundary :: Boundary (S¹_ s) -> Scalar (Needle (Interior (S¹_ s))) -> S¹_ s

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (S¹_ s))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (S¹_ s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V0 s)

Methods

(.--!) :: V0 s -> V0 s -> Needle (Interior (V0 s))

(.-|) :: V0 s -> Boundary (V0 s) -> Maybe (HalfNeedle (V0 s))

(!-|) :: V0 s -> Boundary (V0 s) -> HalfNeedle (V0 s)

(.--.) :: V0 s -> V0 s -> Maybe (Needle (Interior (V0 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V1 s)

Methods

(.--!) :: V1 s -> V1 s -> Needle (Interior (V1 s))

(.-|) :: V1 s -> Boundary (V1 s) -> Maybe (HalfNeedle (V1 s))

(!-|) :: V1 s -> Boundary (V1 s) -> HalfNeedle (V1 s)

(.--.) :: V1 s -> V1 s -> Maybe (Needle (Interior (V1 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V2 s)

Methods

(.--!) :: V2 s -> V2 s -> Needle (Interior (V2 s))

(.-|) :: V2 s -> Boundary (V2 s) -> Maybe (HalfNeedle (V2 s))

(!-|) :: V2 s -> Boundary (V2 s) -> HalfNeedle (V2 s)

(.--.) :: V2 s -> V2 s -> Maybe (Needle (Interior (V2 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V3 s)

Methods

(.--!) :: V3 s -> V3 s -> Needle (Interior (V3 s))

(.-|) :: V3 s -> Boundary (V3 s) -> Maybe (HalfNeedle (V3 s))

(!-|) :: V3 s -> Boundary (V3 s) -> HalfNeedle (V3 s)

(.--.) :: V3 s -> V3 s -> Maybe (Needle (Interior (V3 s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => PseudoAffineWithBoundary (V4 s)

Methods

(.--!) :: V4 s -> V4 s -> Needle (Interior (V4 s))

(.-|) :: V4 s -> Boundary (V4 s) -> Maybe (HalfNeedle (V4 s))

(!-|) :: V4 s -> Boundary (V4 s) -> HalfNeedle (V4 s)

(.--.) :: V4 s -> V4 s -> Maybe (Needle (Interior (V4 s)))

(Semimanifold a, Semimanifold (VRep a), Needle a ~ GenericNeedle a, OpenManifold (Scalar (Needle (Rep a Void))), LinearSpace (Needle (Rep a Void)), Num' (Scalar (Needle (Rep a Void)))) => PseudoAffineWithBoundary (GenericNeedle a)

Methods

(.--!) :: GenericNeedle a -> GenericNeedle a -> Needle (Interior (GenericNeedle a))

(.-|) :: GenericNeedle a -> Boundary (GenericNeedle a) -> Maybe (HalfNeedle (GenericNeedle a))

(!-|) :: GenericNeedle a -> Boundary (GenericNeedle a) -> HalfNeedle (GenericNeedle a)

(.--.) :: GenericNeedle a -> GenericNeedle a -> Maybe (Needle (Interior (GenericNeedle a)))

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

Methods

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

(.-|) :: S²_ s -> Boundary (S²_ s) -> Maybe (HalfNeedle (S²_ s))

(!-|) :: S²_ s -> Boundary (S²_ s) -> HalfNeedle (S²_ s)

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

RealFloat'' s => PseudoAffineWithBoundary (S¹_ s)

Methods

(.--!) :: S¹_ s -> S¹_ s -> Needle (Interior (S¹_ s))

(.-|) :: S¹_ s -> Boundary (S¹_ s) -> Maybe (HalfNeedle (S¹_ s))

(!-|) :: S¹_ s -> Boundary (S¹_ s) -> HalfNeedle (S¹_ s)

(.--.) :: S¹_ s -> S¹_ s -> Maybe (Needle (Interior (S¹_ s)))

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V0 s)

Associated Types

type Interior (V0 s)

type Boundary (V0 s)

type HalfNeedle (V0 s)

Methods

(.+^|) :: V0 s -> Needle (Interior (V0 s)) -> Either (Boundary (V0 s), Scalar (Needle (Interior (V0 s)))) (Interior (V0 s))

fromInterior :: Interior (V0 s) -> V0 s

fromBoundary :: Boundary (V0 s) -> V0 s

(|+^) :: Boundary (V0 s) -> HalfNeedle (V0 s) -> V0 s

separateInterior :: V0 s -> Either (Boundary (V0 s)) (Interior (V0 s))

toInterior :: V0 s -> Maybe (Interior (V0 s))

extendToBoundary :: Interior (V0 s) -> Needle (Interior (V0 s)) -> Maybe (Boundary (V0 s))

smfdWBoundWitness :: SmfdWBoundWitness (V0 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V0 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V0 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V0 s))), Scalar (Needle (Boundary (V0 s))) ~ Scalar (Needle (Interior (V0 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V1 s)

Associated Types

type Interior (V1 s)

type Boundary (V1 s)

type HalfNeedle (V1 s)

Methods

(.+^|) :: V1 s -> Needle (Interior (V1 s)) -> Either (Boundary (V1 s), Scalar (Needle (Interior (V1 s)))) (Interior (V1 s))

fromInterior :: Interior (V1 s) -> V1 s

fromBoundary :: Boundary (V1 s) -> V1 s

(|+^) :: Boundary (V1 s) -> HalfNeedle (V1 s) -> V1 s

separateInterior :: V1 s -> Either (Boundary (V1 s)) (Interior (V1 s))

toInterior :: V1 s -> Maybe (Interior (V1 s))

extendToBoundary :: Interior (V1 s) -> Needle (Interior (V1 s)) -> Maybe (Boundary (V1 s))

smfdWBoundWitness :: SmfdWBoundWitness (V1 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V1 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V1 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V1 s))), Scalar (Needle (Boundary (V1 s))) ~ Scalar (Needle (Interior (V1 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V2 s)

Associated Types

type Interior (V2 s)

type Boundary (V2 s)

type HalfNeedle (V2 s)

Methods

(.+^|) :: V2 s -> Needle (Interior (V2 s)) -> Either (Boundary (V2 s), Scalar (Needle (Interior (V2 s)))) (Interior (V2 s))

fromInterior :: Interior (V2 s) -> V2 s

fromBoundary :: Boundary (V2 s) -> V2 s

(|+^) :: Boundary (V2 s) -> HalfNeedle (V2 s) -> V2 s

separateInterior :: V2 s -> Either (Boundary (V2 s)) (Interior (V2 s))

toInterior :: V2 s -> Maybe (Interior (V2 s))

extendToBoundary :: Interior (V2 s) -> Needle (Interior (V2 s)) -> Maybe (Boundary (V2 s))

smfdWBoundWitness :: SmfdWBoundWitness (V2 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V2 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V2 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V2 s))), Scalar (Needle (Boundary (V2 s))) ~ Scalar (Needle (Interior (V2 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V3 s)

Associated Types

type Interior (V3 s)

type Boundary (V3 s)

type HalfNeedle (V3 s)

Methods

(.+^|) :: V3 s -> Needle (Interior (V3 s)) -> Either (Boundary (V3 s), Scalar (Needle (Interior (V3 s)))) (Interior (V3 s))

fromInterior :: Interior (V3 s) -> V3 s

fromBoundary :: Boundary (V3 s) -> V3 s

(|+^) :: Boundary (V3 s) -> HalfNeedle (V3 s) -> V3 s

separateInterior :: V3 s -> Either (Boundary (V3 s)) (Interior (V3 s))

toInterior :: V3 s -> Maybe (Interior (V3 s))

extendToBoundary :: Interior (V3 s) -> Needle (Interior (V3 s)) -> Maybe (Boundary (V3 s))

smfdWBoundWitness :: SmfdWBoundWitness (V3 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V3 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V3 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V3 s))), Scalar (Needle (Boundary (V3 s))) ~ Scalar (Needle (Interior (V3 s)))) => r) -> r

(Num' s, Eq s, OpenManifold s, ProjectableBoundary s) => SemimanifoldWithBoundary (V4 s)

Associated Types

type Interior (V4 s)

type Boundary (V4 s)

type HalfNeedle (V4 s)

Methods

(.+^|) :: V4 s -> Needle (Interior (V4 s)) -> Either (Boundary (V4 s), Scalar (Needle (Interior (V4 s)))) (Interior (V4 s))

fromInterior :: Interior (V4 s) -> V4 s

fromBoundary :: Boundary (V4 s) -> V4 s

(|+^) :: Boundary (V4 s) -> HalfNeedle (V4 s) -> V4 s

separateInterior :: V4 s -> Either (Boundary (V4 s)) (Interior (V4 s))

toInterior :: V4 s -> Maybe (Interior (V4 s))

extendToBoundary :: Interior (V4 s) -> Needle (Interior (V4 s)) -> Maybe (Boundary (V4 s))

smfdWBoundWitness :: SmfdWBoundWitness (V4 s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (V4 s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (V4 s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (V4 s))), Scalar (Needle (Boundary (V4 s))) ~ Scalar (Needle (Interior (V4 s)))) => r) -> r

(Semimanifold a, Semimanifold (VRep a), Needle a ~ GenericNeedle a, OpenManifold (Scalar (Needle (Rep a Void))), LinearSpace (Needle (Rep a Void)), Num' (Scalar (Needle (Rep a Void)))) => SemimanifoldWithBoundary (GenericNeedle a)

Associated Types

type Interior (GenericNeedle a)

type Boundary (GenericNeedle a)

type HalfNeedle (GenericNeedle a)

Methods

(.+^|) :: GenericNeedle a -> Needle (Interior (GenericNeedle a)) -> Either (Boundary (GenericNeedle a), Scalar (Needle (Interior (GenericNeedle a)))) (Interior (GenericNeedle a))

fromInterior :: Interior (GenericNeedle a) -> GenericNeedle a

fromBoundary :: Boundary (GenericNeedle a) -> GenericNeedle a

(|+^) :: Boundary (GenericNeedle a) -> HalfNeedle (GenericNeedle a) -> GenericNeedle a

separateInterior :: GenericNeedle a -> Either (Boundary (GenericNeedle a)) (Interior (GenericNeedle a))

toInterior :: GenericNeedle a -> Maybe (Interior (GenericNeedle a))

extendToBoundary :: Interior (GenericNeedle a) -> Needle (Interior (GenericNeedle a)) -> Maybe (Boundary (GenericNeedle a))

smfdWBoundWitness :: SmfdWBoundWitness (GenericNeedle a)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (GenericNeedle a))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (GenericNeedle a)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (GenericNeedle a))), Scalar (Needle (Boundary (GenericNeedle a))) ~ Scalar (Needle (Interior (GenericNeedle a)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (D¹_ s)

Associated Types

type Interior (D¹_ s)

type Boundary (D¹_ s)

type HalfNeedle (D¹_ s)

Methods

(.+^|) :: D¹_ s -> Needle (Interior (D¹_ s)) -> Either (Boundary (D¹_ s), Scalar (Needle (Interior (D¹_ s)))) (Interior (D¹_ s))

fromInterior :: Interior (D¹_ s) -> D¹_ s

fromBoundary :: Boundary (D¹_ s) -> D¹_ s

(|+^) :: Boundary (D¹_ s) -> HalfNeedle (D¹_ s) -> D¹_ s

separateInterior :: D¹_ s -> Either (Boundary (D¹_ s)) (Interior (D¹_ s))

toInterior :: D¹_ s -> Maybe (Interior (D¹_ s))

extendToBoundary :: Interior (D¹_ s) -> Needle (Interior (D¹_ s)) -> Maybe (Boundary (D¹_ s))

smfdWBoundWitness :: SmfdWBoundWitness (D¹_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (D¹_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (D¹_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (D¹_ s))), Scalar (Needle (Boundary (D¹_ s))) ~ Scalar (Needle (Interior (D¹_ s)))) => r) -> r

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

Associated Types

type Interior (S²_ s)

type Boundary (S²_ s)

type HalfNeedle (S²_ s)

Methods

(.+^|) :: S²_ s -> Needle (Interior (S²_ s)) -> Either (Boundary (S²_ s), Scalar (Needle (Interior (S²_ s)))) (Interior (S²_ s))

fromInterior :: Interior (S²_ s) -> S²_ s

fromBoundary :: Boundary (S²_ s) -> S²_ s

(|+^) :: Boundary (S²_ s) -> HalfNeedle (S²_ s) -> S²_ s

separateInterior :: S²_ s -> Either (Boundary (S²_ s)) (Interior (S²_ s))

toInterior :: S²_ s -> Maybe (Interior (S²_ s))

extendToBoundary :: Interior (S²_ s) -> Needle (Interior (S²_ s)) -> Maybe (Boundary (S²_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S²_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S²_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S²_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S²_ s))), Scalar (Needle (Boundary (S²_ s))) ~ Scalar (Needle (Interior (S²_ s)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (S¹_ s)

Associated Types

type Interior (S¹_ s)

type Boundary (S¹_ s)

type HalfNeedle (S¹_ s)

Methods

(.+^|) :: S¹_ s -> Needle (Interior (S¹_ s)) -> Either (Boundary (S¹_ s), Scalar (Needle (Interior (S¹_ s)))) (Interior (S¹_ s))

fromInterior :: Interior (S¹_ s) -> S¹_ s

fromBoundary :: Boundary (S¹_ s) -> S¹_ s

(|+^) :: Boundary (S¹_ s) -> HalfNeedle (S¹_ s) -> S¹_ s

separateInterior :: S¹_ s -> Either (Boundary (S¹_ s)) (Interior (S¹_ s))

toInterior :: S¹_ s -> Maybe (Interior (S¹_ s))

extendToBoundary :: Interior (S¹_ s) -> Needle (Interior (S¹_ s)) -> Maybe (Boundary (S¹_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S¹_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S¹_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S¹_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S¹_ s))), Scalar (Needle (Boundary (S¹_ s))) ~ Scalar (Needle (Interior (S¹_ s)))) => r) -> r

RealFloat'' s => SemimanifoldWithBoundary (S⁰_ s)

Associated Types

type Interior (S⁰_ s)

type Boundary (S⁰_ s)

type HalfNeedle (S⁰_ s)

Methods

(.+^|) :: S⁰_ s -> Needle (Interior (S⁰_ s)) -> Either (Boundary (S⁰_ s), Scalar (Needle (Interior (S⁰_ s)))) (Interior (S⁰_ s))

fromInterior :: Interior (S⁰_ s) -> S⁰_ s

fromBoundary :: Boundary (S⁰_ s) -> S⁰_ s

(|+^) :: Boundary (S⁰_ s) -> HalfNeedle (S⁰_ s) -> S⁰_ s

separateInterior :: S⁰_ s -> Either (Boundary (S⁰_ s)) (Interior (S⁰_ s))

toInterior :: S⁰_ s -> Maybe (Interior (S⁰_ s))

extendToBoundary :: Interior (S⁰_ s) -> Needle (Interior (S⁰_ s)) -> Maybe (Boundary (S⁰_ s))

smfdWBoundWitness :: SmfdWBoundWitness (S⁰_ s)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (S⁰_ s))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (S⁰_ s)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (S⁰_ s))), Scalar (Needle (Boundary (S⁰_ s))) ~ Scalar (Needle (Interior (S⁰_ s)))) => r) -> r

(Num' n, OpenManifold n, LinearManifold (a n), ProjectableBoundary n, Scalar (a n) ~ n, Needle (a n) ~ a n) => ProjectableBoundary (Point a n)

Methods

projectToBoundary :: Point a n -> Boundary (Point a n) -> Maybe (Needle (Boundary (Point a n)), Scalar (Needle (Interior (Point a n))))

marginFromBoundary :: Boundary (Point a n) -> Scalar (Needle (Interior (Point a n))) -> Point a n

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (Point a n))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (Point a n)))) => r) -> r

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b), Needle (Boundary a), Needle (Boundary b)], ProjectableBoundary (Interior a), ProjectableBoundary (Interior b), RealFrac'' (Scalar (Needle (Interior a)))) => ProjectableBoundary (a, b)

Methods

projectToBoundary :: (a, b) -> Boundary (a, b) -> Maybe (Needle (Boundary (a, b)), Scalar (Needle (Interior (a, b))))

marginFromBoundary :: Boundary (a, b) -> Scalar (Needle (Interior (a, b))) -> (a, b)

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (a, b))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (a, b)))) => r) -> r

(Num' n, OpenManifold n, LinearManifold (a n), Scalar (a n) ~ n, Needle (a n) ~ a n) => PseudoAffineWithBoundary (Point a n)

Methods

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

(.-|) :: Point a n -> Boundary (Point a n) -> Maybe (HalfNeedle (Point a n))

(!-|) :: Point a n -> Boundary (Point a n) -> HalfNeedle (Point a n)

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

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b), Needle (Boundary a), Needle (Boundary b)], ProjectableBoundary (Interior a), ProjectableBoundary (Interior b), RealFrac'' (Scalar (Needle (Interior a)))) => PseudoAffineWithBoundary (a, b)

Methods

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

(.-|) :: (a, b) -> Boundary (a, b) -> Maybe (HalfNeedle (a, b))

(!-|) :: (a, b) -> Boundary (a, b) -> HalfNeedle (a, b)

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

(Num' n, OpenManifold n, LinearManifold (a n), Scalar (a n) ~ n, Needle (a n) ~ a n) => SemimanifoldWithBoundary (Point a n)

Associated Types

type Interior (Point a n)

type Boundary (Point a n)

type HalfNeedle (Point a n)

Methods

(.+^|) :: Point a n -> Needle (Interior (Point a n)) -> Either (Boundary (Point a n), Scalar (Needle (Interior (Point a n)))) (Interior (Point a n))

fromInterior :: Interior (Point a n) -> Point a n

fromBoundary :: Boundary (Point a n) -> Point a n

(|+^) :: Boundary (Point a n) -> HalfNeedle (Point a n) -> Point a n

separateInterior :: Point a n -> Either (Boundary (Point a n)) (Interior (Point a n))

toInterior :: Point a n -> Maybe (Interior (Point a n))

extendToBoundary :: Interior (Point a n) -> Needle (Interior (Point a n)) -> Maybe (Boundary (Point a n))

smfdWBoundWitness :: SmfdWBoundWitness (Point a n)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Point a n))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Point a n)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Point a n))), Scalar (Needle (Boundary (Point a n))) ~ Scalar (Needle (Interior (Point a n)))) => r) -> r

(ProjectableBoundary a, ProjectableBoundary b, SameScalar LinearSpace '[Needle (Interior a), Needle (Interior b)], RealFrac'' (Scalar (Needle (Interior a))), ProjectableBoundary (Interior a), ProjectableBoundary (Interior b)) => SemimanifoldWithBoundary (a, b)

Associated Types

type Interior (a, b)

type Boundary (a, b)

type HalfNeedle (a, b)

Methods

(.+^|) :: (a, b) -> Needle (Interior (a, b)) -> Either (Boundary (a, b), Scalar (Needle (Interior (a, b)))) (Interior (a, b))

fromInterior :: Interior (a, b) -> (a, b)

fromBoundary :: Boundary (a, b) -> (a, b)

(|+^) :: Boundary (a, b) -> HalfNeedle (a, b) -> (a, b)

separateInterior :: (a, b) -> Either (Boundary (a, b)) (Interior (a, b))

toInterior :: (a, b) -> Maybe (Interior (a, b))

extendToBoundary :: Interior (a, b) -> Needle (Interior (a, b)) -> Maybe (Boundary (a, b))

smfdWBoundWitness :: SmfdWBoundWitness (a, b)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (a, b))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (a, b)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (a, b))), Scalar (Needle (Boundary (a, b))) ~ Scalar (Needle (Interior (a, b)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s, ProjectableBoundary s) => ProjectableBoundary (LinearMap s v w)

Methods

projectToBoundary :: LinearMap s v w -> Boundary (LinearMap s v w) -> Maybe (Needle (Boundary (LinearMap s v w)), Scalar (Needle (Interior (LinearMap s v w))))

marginFromBoundary :: Boundary (LinearMap s v w) -> Scalar (Needle (Interior (LinearMap s v w))) -> LinearMap s v w

needleBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Needle (Interior (LinearMap s v w))) => r) -> r

scalarBoundaryIsTriviallyProjectible :: (ProjectableBoundary (Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (LinearFunction s v w)

Methods

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

(.-|) :: LinearFunction s v w -> Boundary (LinearFunction s v w) -> Maybe (HalfNeedle (LinearFunction s v w))

(!-|) :: LinearFunction s v w -> Boundary (LinearFunction s v w) -> HalfNeedle (LinearFunction s v w)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (LinearMap s v w)

Methods

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

(.-|) :: LinearMap s v w -> Boundary (LinearMap s v w) -> Maybe (HalfNeedle (LinearMap s v w))

(!-|) :: LinearMap s v w -> Boundary (LinearMap s v w) -> HalfNeedle (LinearMap s v w)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => PseudoAffineWithBoundary (Tensor s v w)

Methods

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

(.-|) :: Tensor s v w -> Boundary (Tensor s v w) -> Maybe (HalfNeedle (Tensor s v w))

(!-|) :: Tensor s v w -> Boundary (Tensor s v w) -> HalfNeedle (Tensor s v w)

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

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (LinearFunction s v w)

Associated Types

type Interior (LinearFunction s v w)

type Boundary (LinearFunction s v w)

type HalfNeedle (LinearFunction s v w)

Methods

(.+^|) :: LinearFunction s v w -> Needle (Interior (LinearFunction s v w)) -> Either (Boundary (LinearFunction s v w), Scalar (Needle (Interior (LinearFunction s v w)))) (Interior (LinearFunction s v w))

fromInterior :: Interior (LinearFunction s v w) -> LinearFunction s v w

fromBoundary :: Boundary (LinearFunction s v w) -> LinearFunction s v w

(|+^) :: Boundary (LinearFunction s v w) -> HalfNeedle (LinearFunction s v w) -> LinearFunction s v w

separateInterior :: LinearFunction s v w -> Either (Boundary (LinearFunction s v w)) (Interior (LinearFunction s v w))

toInterior :: LinearFunction s v w -> Maybe (Interior (LinearFunction s v w))

extendToBoundary :: Interior (LinearFunction s v w) -> Needle (Interior (LinearFunction s v w)) -> Maybe (Boundary (LinearFunction s v w))

smfdWBoundWitness :: SmfdWBoundWitness (LinearFunction s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (LinearFunction s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (LinearFunction s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (LinearFunction s v w))), Scalar (Needle (Boundary (LinearFunction s v w))) ~ Scalar (Needle (Interior (LinearFunction s v w)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (LinearMap s v w)

Associated Types

type Interior (LinearMap s v w)

type Boundary (LinearMap s v w)

type HalfNeedle (LinearMap s v w)

Methods

(.+^|) :: LinearMap s v w -> Needle (Interior (LinearMap s v w)) -> Either (Boundary (LinearMap s v w), Scalar (Needle (Interior (LinearMap s v w)))) (Interior (LinearMap s v w))

fromInterior :: Interior (LinearMap s v w) -> LinearMap s v w

fromBoundary :: Boundary (LinearMap s v w) -> LinearMap s v w

(|+^) :: Boundary (LinearMap s v w) -> HalfNeedle (LinearMap s v w) -> LinearMap s v w

separateInterior :: LinearMap s v w -> Either (Boundary (LinearMap s v w)) (Interior (LinearMap s v w))

toInterior :: LinearMap s v w -> Maybe (Interior (LinearMap s v w))

extendToBoundary :: Interior (LinearMap s v w) -> Needle (Interior (LinearMap s v w)) -> Maybe (Boundary (LinearMap s v w))

smfdWBoundWitness :: SmfdWBoundWitness (LinearMap s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (LinearMap s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (LinearMap s v w))), Scalar (Needle (Boundary (LinearMap s v w))) ~ Scalar (Needle (Interior (LinearMap s v w)))) => r) -> r

(LinearSpace v, LinearSpace w, s ~ Scalar v, s ~ Scalar w, Num' s, OpenManifold s) => SemimanifoldWithBoundary (Tensor s v w)

Associated Types

type Interior (Tensor s v w)

type Boundary (Tensor s v w)

type HalfNeedle (Tensor s v w)

Methods

(.+^|) :: Tensor s v w -> Needle (Interior (Tensor s v w)) -> Either (Boundary (Tensor s v w), Scalar (Needle (Interior (Tensor s v w)))) (Interior (Tensor s v w))

fromInterior :: Interior (Tensor s v w) -> Tensor s v w

fromBoundary :: Boundary (Tensor s v w) -> Tensor s v w

(|+^) :: Boundary (Tensor s v w) -> HalfNeedle (Tensor s v w) -> Tensor s v w

separateInterior :: Tensor s v w -> Either (Boundary (Tensor s v w)) (Interior (Tensor s v w))

toInterior :: Tensor s v w -> Maybe (Interior (Tensor s v w))

extendToBoundary :: Interior (Tensor s v w) -> Needle (Interior (Tensor s v w)) -> Maybe (Boundary (Tensor s v w))

smfdWBoundWitness :: SmfdWBoundWitness (Tensor s v w)

needleIsOpenMfd :: (OpenManifold (Needle (Interior (Tensor s v w))) => r) -> r

scalarIsOpenMfd :: (OpenManifold (Scalar (Needle (Interior (Tensor s v w)))) => r) -> r

boundaryHasSameScalar :: ((LinearSpace (Needle (Boundary (Tensor s v w))), Scalar (Needle (Boundary (Tensor s v w))) ~ Scalar (Needle (Interior (Tensor s v w)))) => r) -> r