Data.Manifold.TreeCover

Shades

data Shade x where

A Shade is a very crude description of a region within a manifold. It can be interpreted as either an ellipsoid shape, or as the Gaussian peak of a normal distribution (use http://hackage.haskell.org/package/manifold-random for actually sampling from that distribution).

For a precise description of an arbitrarily-shaped connected subset of a manifold, there is Region, whose implementation is vastly more complex.

Constructors

Shade :: (Semimanifold x, SimpleSpace (Needle x)) => {..} -> Shade x

Fields

• _shadeCtr :: !(Interior x)
• _shadeExpanse :: !(Metric' x)

Instances

ImpliesMetric Shade

Associated Types

type MetricRequirement (Shade :: * -> *) x :: Constraint

Methods

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

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

IsShade Shade

Methods

shadeCtr :: Functor f => (Interior x -> f (Interior x)) -> Shade x -> f (Shade x)

occlusion :: (PseudoAffine x, SimpleSpace (Needle x), (* ~ s) (Scalar (Needle x)), RealFloat' s) => Shade x -> x -> s

factoriseShade :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade (x, y) -> (Shade x, Shade y)

coerceShade :: (Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => Shade x -> Shade y

orthoShades :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade x -> Shade y -> Shade (x, y)

linIsoTransformShade :: (SimpleSpace x, SimpleSpace y, (* ~ Scalar x) (Scalar y), Num' (Scalar x)) => (x +> y) -> Shade x -> Shade y

projectShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade y -> Shade x

embedShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade x -> Shade y

(Show (Interior x), Show (Metric' x), WithField ℝ PseudoAffine x) => Show (Shade x)

Methods

showsPrec :: Int -> Shade x -> ShowS

show :: Shade x -> String

showList :: [Shade x] -> ShowS

PseudoAffine x => Semimanifold (Shade x)

Associated Types

type Needle (Shade x) :: *

type Interior (Shade x) :: *

Methods

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

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

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

translateP :: Tagged * (Shade x) (Interior (Shade x) -> Needle (Shade x) -> Interior (Shade x))

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

semimanifoldWitness :: SemimanifoldWitness (Shade x)

LtdErrorShow x => Show (Shade x)

Methods

showsPrec :: Int -> Shade x -> ShowS

show :: Shade x -> String

showList :: [Shade x] -> ShowS

(WithField ℝ PseudoAffine x, Geodesic (Interior x), SimpleSpace (Needle x)) => Geodesic (Shade x)

Methods

geodesicBetween :: Shade x -> Shade x -> Maybe (D¹ -> Shade x)

geodesicWitness :: GeodesicWitness (Shade x)

middleBetween :: Shade x -> Shade x -> Maybe (Shade x)

type MetricRequirement Shade x

type MetricRequirement Shade x = (Manifold x, SimpleSpace (Needle x))

type Interior (Shade x)

type Interior (Shade x) = Shade x

type Needle (Shade x)

type Needle (Shade x) = Needle x

pattern (:±) :: forall x. () => (Semimanifold x, SimpleSpace (Needle x)) => Interior x -> [Needle x] -> Shade x infixl 6

Span a Shade from a center point and multiple deviation-vectors.

data Shade' x

A “co-shade” can describe ellipsoid regions as well, but unlike Shade it can be unlimited / infinitely wide in some directions. It does OTOH need to have nonzero thickness, which Shade needs not.

Constructors

Shade'

Fields

• _shade'Ctr :: !(Interior x)
• _shade'Narrowness :: !(Metric x)

Instances

ImpliesMetric Shade'

Associated Types

type MetricRequirement (Shade' :: * -> *) x :: Constraint

Methods

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

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

IsShade Shade'

Methods

shadeCtr :: Functor f => (Interior x -> f (Interior x)) -> Shade' x -> f (Shade' x)

occlusion :: (PseudoAffine x, SimpleSpace (Needle x), (* ~ s) (Scalar (Needle x)), RealFloat' s) => Shade' x -> x -> s

factoriseShade :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade' (x, y) -> (Shade' x, Shade' y)

coerceShade :: (Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => Shade' x -> Shade' y

orthoShades :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade' x -> Shade' y -> Shade' (x, y)

linIsoTransformShade :: (SimpleSpace x, SimpleSpace y, (* ~ Scalar x) (Scalar y), Num' (Scalar x)) => (x +> y) -> Shade' x -> Shade' y

projectShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade' y -> Shade' x

embedShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade' x -> Shade' y

LtdErrorShow x => Show (Shade' x)

Methods

showsPrec :: Int -> Shade' x -> ShowS

show :: Shade' x -> String

showList :: [Shade' x] -> ShowS

AffineManifold x => Semimanifold (Shade' x)

Associated Types

type Needle (Shade' x) :: *

type Interior (Shade' x) :: *

Methods

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

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

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

translateP :: Tagged * (Shade' x) (Interior (Shade' x) -> Needle (Shade' x) -> Interior (Shade' x))

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

semimanifoldWitness :: SemimanifoldWitness (Shade' x)

LtdErrorShow x => Show (Shade' x)

Methods

showsPrec :: Int -> Shade' x -> ShowS

show :: Shade' x -> String

showList :: [Shade' x] -> ShowS

(WithField ℝ AffineManifold x, Geodesic x, SimpleSpace (Needle x)) => Geodesic (Shade' x)

Methods

geodesicBetween :: Shade' x -> Shade' x -> Maybe (D¹ -> Shade' x)

geodesicWitness :: GeodesicWitness (Shade' x)

middleBetween :: Shade' x -> Shade' x -> Maybe (Shade' x)

type MetricRequirement Shade' x

type MetricRequirement Shade' x = (Manifold x, SimpleSpace (Needle x))

type Interior (Shade' x)

type Interior (Shade' x) = Shade' x

type Needle (Shade' x)

type Needle (Shade' x) = Needle x

(|±|) :: forall x. WithField ℝ EuclidSpace x => x -> [Needle x] -> Shade' x infixl 6

Similar to ':±', but instead of expanding the shade, each vector restricts it. Iff these form a orthogonal basis (in whatever sense applicable), then both methods will be equivalent.

Note that '|±|' is only possible, as such, in an inner-product space; in general you need reciprocal vectors (Needle') to define a Shade'.

class IsShade shade where

Minimal complete definition

shadeCtr, occlusion, factoriseShade, coerceShade, orthoShades, linIsoTransformShade, projectShade, embedShade

Methods

shadeCtr :: Lens' (shade x) (Interior x)

Access the center of a Shade or a Shade'.

occlusion :: (PseudoAffine x, SimpleSpace (Needle x), s ~ Scalar (Needle x), RealFloat' s) => shade x -> x -> s

Check the statistical likelihood-density of a point being within a shade. This is taken as a normal distribution.

factoriseShade :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), Scalar (Needle x) ~ Scalar (Needle y)) => shade (x, y) -> (shade x, shade y)

coerceShade :: (Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => shade x -> shade y

linIsoTransformShade :: (SimpleSpace x, SimpleSpace y, Scalar x ~ Scalar y, Num' (Scalar x)) => (x +> y) -> shade x -> shade y

projectShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> shade y -> shade x

Squash a shade down into a lower dimensional space.

embedShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> shade x -> shade y

Include a shade in a higher-dimensional space. Notice that this behaves fundamentally different for Shade and Shade'. For Shade, it gives a “flat image” of the region, whereas for Shade' it gives an “extrusion pillar” pointing in the projection's orthogonal complement.

Instances

IsShade Shade'

Methods

shadeCtr :: Functor f => (Interior x -> f (Interior x)) -> Shade' x -> f (Shade' x)

occlusion :: (PseudoAffine x, SimpleSpace (Needle x), (* ~ s) (Scalar (Needle x)), RealFloat' s) => Shade' x -> x -> s

factoriseShade :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade' (x, y) -> (Shade' x, Shade' y)

coerceShade :: (Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => Shade' x -> Shade' y

orthoShades :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade' x -> Shade' y -> Shade' (x, y)

linIsoTransformShade :: (SimpleSpace x, SimpleSpace y, (* ~ Scalar x) (Scalar y), Num' (Scalar x)) => (x +> y) -> Shade' x -> Shade' y

projectShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade' y -> Shade' x

embedShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade' x -> Shade' y

IsShade Shade

Methods

shadeCtr :: Functor f => (Interior x -> f (Interior x)) -> Shade x -> f (Shade x)

occlusion :: (PseudoAffine x, SimpleSpace (Needle x), (* ~ s) (Scalar (Needle x)), RealFloat' s) => Shade x -> x -> s

factoriseShade :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade (x, y) -> (Shade x, Shade y)

coerceShade :: (Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => Shade x -> Shade y

orthoShades :: (PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), (* ~ Scalar (Needle x)) (Scalar (Needle y))) => Shade x -> Shade y -> Shade (x, y)

linIsoTransformShade :: (SimpleSpace x, SimpleSpace y, (* ~ Scalar x) (Scalar y), Num' (Scalar x)) => (x +> y) -> Shade x -> Shade y

projectShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade y -> Shade x

embedShade :: (Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> Shade x -> Shade y

Lenses

shadeCtr :: IsShade shade => Lens' (shade x) (Interior x)

Access the center of a Shade or a Shade'.

shadeExpanse :: Lens' (Shade x) (Metric' x)

shadeNarrowness :: Lens' (Shade' x) (Metric x)

Construction

fullShade :: (Semimanifold x, SimpleSpace (Needle x)) => Interior x -> Metric' x -> Shade x

fullShade' :: WithField ℝ SimpleSpace x => Interior x -> Metric x -> Shade' x

pointsShades :: (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => [Interior x] -> [Shade x]

Attempt to find a Shade that describes the distribution of given points. At least in an affine space (and thus locally in any manifold), this can be used to estimate the parameters of a normal distribution from which some points were sampled. Note that some points will be “outside” of the shade, as happens for a normal distribution with some statistical likelyhood. (Use pointsCovers if you need to prevent that.)

For nonconnected manifolds it will be necessary to yield separate shades for each connected component. And for an empty input list, there is no shade! Hence the result type is a list.

pointsShade's :: forall x. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => [Interior x] -> [Shade' x]

pointsCovers :: forall x. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => [Interior x] -> [Shade x]

Like pointsShades, but ensure that all points are actually in the shade, i.e. if [Shade x₀ ex] is the result then metric (recipMetric ex) (p-x₀) ≤ 1 for all p in the list.

pointsCover's :: forall x. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => [Interior x] -> [Shade' x]

coverAllAround :: forall x s. (Fractional' s, WithField s PseudoAffine x, SimpleSpace (Needle x)) => Interior x -> [Needle x] -> Shade x

Evaluation

occlusion :: (IsShade shade, PseudoAffine x, SimpleSpace (Needle x), s ~ Scalar (Needle x), RealFloat' s) => shade x -> x -> s

Check the statistical likelihood-density of a point being within a shade. This is taken as a normal distribution.

prettyShowsPrecShade' :: LtdErrorShow m => Int -> Shade' m -> ShowS

prettyShowShade' :: LtdErrorShow x => Shade' x -> String

Misc

factoriseShade :: (IsShade shade, PseudoAffine x, SimpleSpace (Needle x), PseudoAffine y, SimpleSpace (Needle y), Scalar (Needle x) ~ Scalar (Needle y)) => shade (x, y) -> (shade x, shade y)

intersectShade's :: forall y. Refinable y => NonEmpty (Shade' y) -> Maybe (Shade' y)

linIsoTransformShade :: (IsShade shade, SimpleSpace x, SimpleSpace y, Scalar x ~ Scalar y, Num' (Scalar x)) => (x +> y) -> shade x -> shade y

embedShade :: (IsShade shade, Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SemiInner (Needle x), SimpleSpace (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> shade x -> shade y

Include a shade in a higher-dimensional space. Notice that this behaves fundamentally different for Shade and Shade'. For Shade, it gives a “flat image” of the region, whereas for Shade' it gives an “extrusion pillar” pointing in the projection's orthogonal complement.

projectShade :: (IsShade shade, Semimanifold x, Semimanifold y, Object (Affine s) (Interior x), Object (Affine s) (Interior y), SimpleSpace (Needle x), SemiInner (Needle y)) => Embedding (Affine s) (Interior x) (Interior y) -> shade y -> shade x

Squash a shade down into a lower dimensional space.

class (WithField ℝ PseudoAffine y, SimpleSpace (Needle y)) => Refinable y where

Class of manifolds which can use Shade' as a basic set type. This is easily possible for vector spaces with the default implementations.

Methods

subShade' :: Shade' y -> Shade' y -> Bool

a subShade' b ≡ True means a is fully contained in b, i.e. from minusLogOcclusion' a p < 1 follows also minusLogOcclusion' b p < 1.

refineShade' :: Shade' y -> Shade' y -> Maybe (Shade' y)

Intersection between two shades.

convolveShade' :: Shade' y -> Shade' (Needle y) -> Shade' y

Instances

Refinable ℝ

Methods

debugView :: Maybe (DebugView ℝ)

subShade' :: Shade' ℝ -> Shade' ℝ -> Bool

refineShade' :: Shade' ℝ -> Shade' ℝ -> Maybe (Shade' ℝ)

convolveMetric :: Functor p => p ℝ -> Metric ℝ -> Metric ℝ -> Metric ℝ

convolveShade' :: Shade' ℝ -> Shade' (Needle ℝ) -> Shade' ℝ

Refinable ℝ⁰

Methods

debugView :: Maybe (DebugView ℝ⁰)

subShade' :: Shade' ℝ⁰ -> Shade' ℝ⁰ -> Bool

refineShade' :: Shade' ℝ⁰ -> Shade' ℝ⁰ -> Maybe (Shade' ℝ⁰)

convolveMetric :: Functor p => p ℝ⁰ -> Metric ℝ⁰ -> Metric ℝ⁰ -> Metric ℝ⁰

convolveShade' :: Shade' ℝ⁰ -> Shade' (Needle ℝ⁰) -> Shade' ℝ⁰

Refinable ℝ⁴

Methods

debugView :: Maybe (DebugView ℝ⁴)

subShade' :: Shade' ℝ⁴ -> Shade' ℝ⁴ -> Bool

refineShade' :: Shade' ℝ⁴ -> Shade' ℝ⁴ -> Maybe (Shade' ℝ⁴)

convolveMetric :: Functor p => p ℝ⁴ -> Metric ℝ⁴ -> Metric ℝ⁴ -> Metric ℝ⁴

convolveShade' :: Shade' ℝ⁴ -> Shade' (Needle ℝ⁴) -> Shade' ℝ⁴

Refinable ℝ³

Methods

debugView :: Maybe (DebugView ℝ³)

subShade' :: Shade' ℝ³ -> Shade' ℝ³ -> Bool

refineShade' :: Shade' ℝ³ -> Shade' ℝ³ -> Maybe (Shade' ℝ³)

convolveMetric :: Functor p => p ℝ³ -> Metric ℝ³ -> Metric ℝ³ -> Metric ℝ³

convolveShade' :: Shade' ℝ³ -> Shade' (Needle ℝ³) -> Shade' ℝ³

Refinable ℝ²

Methods

debugView :: Maybe (DebugView ℝ²)

subShade' :: Shade' ℝ² -> Shade' ℝ² -> Bool

refineShade' :: Shade' ℝ² -> Shade' ℝ² -> Maybe (Shade' ℝ²)

convolveMetric :: Functor p => p ℝ² -> Metric ℝ² -> Metric ℝ² -> Metric ℝ²

convolveShade' :: Shade' ℝ² -> Shade' (Needle ℝ²) -> Shade' ℝ²

Refinable ℝ¹

Methods

debugView :: Maybe (DebugView ℝ¹)

subShade' :: Shade' ℝ¹ -> Shade' ℝ¹ -> Bool

refineShade' :: Shade' ℝ¹ -> Shade' ℝ¹ -> Maybe (Shade' ℝ¹)

convolveMetric :: Functor p => p ℝ¹ -> Metric ℝ¹ -> Metric ℝ¹ -> Metric ℝ¹

convolveShade' :: Shade' ℝ¹ -> Shade' (Needle ℝ¹) -> Shade' ℝ¹

(Refinable a, Refinable b, (~) * (Scalar (DualVector (DualVector (Needle b)))) (Scalar (DualVector (DualVector (Needle a))))) => Refinable (a, b)

Methods

debugView :: Maybe (DebugView (a, b))

subShade' :: Shade' (a, b) -> Shade' (a, b) -> Bool

refineShade' :: Shade' (a, b) -> Shade' (a, b) -> Maybe (Shade' (a, b))

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

convolveShade' :: Shade' (a, b) -> Shade' (Needle (a, b)) -> Shade' (a, b)

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

Methods

debugView :: Maybe (DebugView (LinearMap ℝ a b))

subShade' :: Shade' (LinearMap ℝ a b) -> Shade' (LinearMap ℝ a b) -> Bool

refineShade' :: Shade' (LinearMap ℝ a b) -> Shade' (LinearMap ℝ a b) -> Maybe (Shade' (LinearMap ℝ a b))

convolveMetric :: Functor p => p (LinearMap ℝ a b) -> Metric (LinearMap ℝ a b) -> Metric (LinearMap ℝ a b) -> Metric (LinearMap ℝ a b)

convolveShade' :: Shade' (LinearMap ℝ a b) -> Shade' (Needle (LinearMap ℝ a b)) -> Shade' (LinearMap ℝ a b)

subShade' :: Refinable y => Shade' y -> Shade' y -> Bool

a subShade' b ≡ True means a is fully contained in b, i.e. from minusLogOcclusion' a p < 1 follows also minusLogOcclusion' b p < 1.

refineShade' :: Refinable y => Shade' y -> Shade' y -> Maybe (Shade' y)

Intersection between two shades.

convolveShade' :: Refinable y => Shade' y -> Shade' (Needle y) -> Shade' y

coerceShade :: (IsShade shade, Manifold x, Manifold y, LocallyCoercible x y, SimpleSpace (Needle y)) => shade x -> shade y

mixShade's :: forall y. (WithField ℝ Manifold y, SimpleSpace (Needle y)) => NonEmpty (Shade' y) -> Maybe (Shade' y)

Weakened version of intersectShade's. What this function calculates is rather the weighted mean of ellipsoid regions. If you interpret the shades as uncertain physical measurements with normal distribution, it gives the maximum-likelyhood result for multiple measurements of the same quantity.

Shade trees

type ShadeTree x = x `Shaded` ()

fromLeafPoints :: forall x. (WithField ℝ Manifold x, SimpleSpace (Needle x)) => [x] -> ShadeTree x

Build a quite nicely balanced tree from a cloud of points, on any real manifold.

Example: https://nbviewer.jupyter.org/github/leftaroundabout/manifolds/blob/master/test/Trees-and-Webs.ipynb#pseudorandomCloudTree

fromLeafPoints_ :: forall x y. (WithField ℝ Manifold x, SimpleSpace (Needle x)) => [(x, y)] -> x `Shaded` y

onlyLeaves :: WithField ℝ PseudoAffine x => (x `Shaded` y) -> [(x, y)]

onlyLeaves_ :: WithField ℝ PseudoAffine x => ShadeTree x -> [x]

Left (and, typically, also right) inverse of fromLeafNodes.

indexShadeTree :: forall x y. (x `Shaded` y) -> Int -> Either Int ([x `Shaded` y], (x, y))

The leaves of a shade tree are numbered. For a given index, this function attempts to find the leaf with that ID, within its immediate environment.

treeLeaf :: forall x y f. Functor f => Int -> (y -> f y) -> (x `Shaded` y) -> Either Int (f (x `Shaded` y))

positionIndex

Arguments

:: (WithField ℝ Manifold x, SimpleSpace (Needle x))

=> Maybe (Metric x)

For deciding (at the lowest level) what “close” means; this is optional for any tree of depth >1.

-> (x `Shaded` y)

The tree to index into

-> x

Position to look up

-> Maybe (Int, ([x `Shaded` y], (x, y)))

Index of the leaf near to the query point, the “path” of environment trees leading down to its position (in decreasing order of size), and actual position+info of the found node.

“Inverse indexing” of a tree. This is roughly a nearest-neighbour search, but not guaranteed to give the correct result unless evaluated at the precise position of a tree leaf.

View helpers

entireTree :: forall x y. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => (x `Shaded` y) -> LeafyTree x y

onlyNodes :: forall x. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => ShadeTree x -> Trees x

Imitate the specialised ShadeTree structure with a simpler, generic tree.

trunkBranches :: (x `Shaded` y) -> NonEmpty (LeafIndex, x `Shaded` y)

nLeaves :: (x `Shaded` y) -> Int

treeDepth :: (x `Shaded` y) -> Int

Auxiliary types

type SimpleTree = GenericTree Maybe []

SimpleTree x ≅ Maybe (x, Trees x)

type Trees = GenericTree [] []

Trees x ≅ [(x, Trees x)]

type NonEmptyTree = GenericTree NonEmpty []

NonEmptyTree x ≅ (x, Trees x)

newtype GenericTree c b x

Constructors

GenericTree

Fields

• treeBranches :: c (x, GenericTree b b x)

Instances

(Functor b, Functor c) => Functor (GenericTree c b)

Methods

fmap :: (a -> b) -> GenericTree c b a -> GenericTree c b b

(<$) :: a -> GenericTree c b b -> GenericTree c b a

(Foldable b, Foldable c) => Foldable (GenericTree c b)

Methods

fold :: Monoid m => GenericTree c b m -> m

foldMap :: Monoid m => (a -> m) -> GenericTree c b a -> m

foldr :: (a -> b -> b) -> b -> GenericTree c b a -> b

foldr' :: (a -> b -> b) -> b -> GenericTree c b a -> b

foldl :: (b -> a -> b) -> b -> GenericTree c b a -> b

foldl' :: (b -> a -> b) -> b -> GenericTree c b a -> b

foldr1 :: (a -> a -> a) -> GenericTree c b a -> a

foldl1 :: (a -> a -> a) -> GenericTree c b a -> a

toList :: GenericTree c b a -> [a]

null :: GenericTree c b a -> Bool

length :: GenericTree c b a -> Int

elem :: Eq a => a -> GenericTree c b a -> Bool

maximum :: Ord a => GenericTree c b a -> a

minimum :: Ord a => GenericTree c b a -> a

sum :: Num a => GenericTree c b a -> a

product :: Num a => GenericTree c b a -> a

(Traversable b, Traversable c) => Traversable (GenericTree c b)

Methods

traverse :: Applicative f => (a -> f b) -> GenericTree c b a -> f (GenericTree c b b)

sequenceA :: Applicative f => GenericTree c b (f a) -> f (GenericTree c b a)

mapM :: Monad m => (a -> m b) -> GenericTree c b a -> m (GenericTree c b b)

sequence :: Monad m => GenericTree c b (m a) -> m (GenericTree c b a)

Eq (c (x, GenericTree b b x)) => Eq (GenericTree c b x)

Methods

(==) :: GenericTree c b x -> GenericTree c b x -> Bool

(/=) :: GenericTree c b x -> GenericTree c b x -> Bool

Show (c (x, GenericTree b b x)) => Show (GenericTree c b x)

Methods

showsPrec :: Int -> GenericTree c b x -> ShowS

show :: GenericTree c b x -> String

showList :: [GenericTree c b x] -> ShowS

Generic (GenericTree c b x)

Associated Types

type Rep (GenericTree c b x) :: * -> *

Methods

from :: GenericTree c b x -> Rep (GenericTree c b x) x

to :: Rep (GenericTree c b x) x -> GenericTree c b x

MonadPlus c => Semigroup (GenericTree c b x)

Methods

(<>) :: GenericTree c b x -> GenericTree c b x -> GenericTree c b x

sconcat :: NonEmpty (GenericTree c b x) -> GenericTree c b x

stimes :: Integral b => b -> GenericTree c b x -> GenericTree c b x

MonadPlus c => Monoid (GenericTree c b x)

Methods

mempty :: GenericTree c b x

mappend :: GenericTree c b x -> GenericTree c b x -> GenericTree c b x

mconcat :: [GenericTree c b x] -> GenericTree c b x

(NFData x, Foldable c, Foldable b) => NFData (GenericTree c b x)

Methods

rnf :: GenericTree c b x -> ()

type Rep (GenericTree c b x)

type Rep (GenericTree c b x) = D1 (MetaData "GenericTree" "Data.Manifold.TreeCover" "manifolds-0.4.4.0-4U7mLxDASVE34WPYCdNRgy" True) (C1 (MetaCons "GenericTree" PrefixI True) (S1 (MetaSel (Just Symbol "treeBranches") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (c (x, GenericTree b b x)))))

朳 :: c (x, GenericTree b b x) -> GenericTree c b x

U+6733 CJK UNIFIED IDEOGRAPH tree. The main purpose of this is to give GenericTree a more concise Show instance.

Misc

class HasFlatView f where

Minimal complete definition

flatView, superFlatView

Associated Types

type FlatView f x

Methods

flatView :: f x -> FlatView f x

superFlatView :: f x -> [[x]]

shadesMerge

Arguments

:: (WithField ℝ Manifold x, SimpleSpace (Needle x))

=> ℝ

How near (inverse normalised distance, relative to shade expanse) two shades must be to be merged. If this is zero, any shades in the same connected region of a manifold are merged.

-> [Shade x]

A list of n shades.

-> [Shade x]

m ≤ n shades which cover at least the same area.

Attempt to reduce the number of shades to fewer (ideally, a single one). In the simplest cases these should guaranteed cover the same area; for non-flat manifolds it only works in a heuristic sense.

allTwigs :: forall x y. WithField ℝ PseudoAffine x => (x `Shaded` y) -> [Twig x y]

twigsWithEnvirons :: forall x y. (WithField ℝ Manifold x, SimpleSpace (Needle x)) => (x `Shaded` y) -> [(Twig x y, TwigEnviron x y)]

Example: https://nbviewer.jupyter.org/github/leftaroundabout/manifolds/blob/master/test/Trees-and-Webs.ipynb#pseudorandomCloudTree

type Twig x y = (Int, x `Shaded` y)

type TwigEnviron x y = [Twig x y]

seekPotentialNeighbours :: forall x y. (WithField ℝ PseudoAffine x, SimpleSpace (Needle x)) => (x `Shaded` y) -> x `Shaded` (y, [Int])

completeTopShading :: forall x y. (WithField ℝ PseudoAffine x, WithField ℝ PseudoAffine y, SimpleSpace (Needle x), SimpleSpace (Needle y)) => (x `Shaded` y) -> [Shade' (x, y)]

flexTwigsShading :: forall x y f. (WithField ℝ Manifold x, WithField ℝ Manifold y, SimpleSpace (Needle x), SimpleSpace (Needle y), Applicative f) => (Shade' (x, y) -> f (x, (Shade' y, LocalLinear x y))) -> (x `Shaded` y) -> f (x `Shaded` y)

traverseTrunkBranchChoices :: Applicative f => ((Int, x `Shaded` y) -> (x `Shaded` y) -> f (x `Shaded` z)) -> (x `Shaded` y) -> f (x `Shaded` z)

data Shaded x y

Constructors

PlainLeaves [(x, y)]

DisjointBranches !LeafCount (NonEmpty (x `Shaded` y))

OverlappingBranches !LeafCount !(Shade x) (NonEmpty (DBranch x y))

Instances

Functor (Shaded x)

Methods

fmap :: (a -> b) -> Shaded x a -> Shaded x b

(<$) :: a -> Shaded x b -> Shaded x a

Foldable (Shaded x)

Methods

fold :: Monoid m => Shaded x m -> m

foldMap :: Monoid m => (a -> m) -> Shaded x a -> m

foldr :: (a -> b -> b) -> b -> Shaded x a -> b

foldr' :: (a -> b -> b) -> b -> Shaded x a -> b

foldl :: (b -> a -> b) -> b -> Shaded x a -> b

foldl' :: (b -> a -> b) -> b -> Shaded x a -> b

foldr1 :: (a -> a -> a) -> Shaded x a -> a

foldl1 :: (a -> a -> a) -> Shaded x a -> a

toList :: Shaded x a -> [a]

null :: Shaded x a -> Bool

length :: Shaded x a -> Int

elem :: Eq a => a -> Shaded x a -> Bool

maximum :: Ord a => Shaded x a -> a

minimum :: Ord a => Shaded x a -> a

sum :: Num a => Shaded x a -> a

product :: Num a => Shaded x a -> a

Traversable (Shaded x)

Methods

traverse :: Applicative f => (a -> f b) -> Shaded x a -> f (Shaded x b)

sequenceA :: Applicative f => Shaded x (f a) -> f (Shaded x a)

mapM :: Monad m => (a -> m b) -> Shaded x a -> m (Shaded x b)

sequence :: Monad m => Shaded x (m a) -> m (Shaded x a)

(WithField ℝ Manifold x, SimpleSpace (Needle x)) => Semigroup (ShadeTree x)

WRT union.

Methods

(<>) :: ShadeTree x -> ShadeTree x -> ShadeTree x

sconcat :: NonEmpty (ShadeTree x) -> ShadeTree x

stimes :: Integral b => b -> ShadeTree x -> ShadeTree x

(WithField ℝ Manifold x, SimpleSpace (Needle x)) => Monoid (ShadeTree x)

Methods

mempty :: ShadeTree x

mappend :: ShadeTree x -> ShadeTree x -> ShadeTree x

mconcat :: [ShadeTree x] -> ShadeTree x

(WithField ℝ PseudoAffine x, Show x, Show (Interior x), Show (Needle' x), Show (Metric' x)) => Show (Shaded x ())

Methods

showsPrec :: Int -> Shaded x () -> ShowS

show :: Shaded x () -> String

showList :: [Shaded x ()] -> ShowS

Generic (Shaded x y)

Associated Types

type Rep (Shaded x y) :: * -> *

Methods

from :: Shaded x y -> Rep (Shaded x y) x

to :: Rep (Shaded x y) x -> Shaded x y

(NFData x, NFData (Needle' x), NFData y) => NFData (DBranch x y)

Methods

rnf :: DBranch x y -> ()

(NFData x, NFData (Needle' x), NFData y) => NFData (Shaded x y)

Methods

rnf :: Shaded x y -> ()

type Rep (Shaded x y)

type Rep (Shaded x y)

fmapShaded :: (Semimanifold x, SimpleSpace (Needle x)) => (y -> υ) -> (x `Shaded` y) -> x `Shaded` υ

constShaded :: y -> (x `Shaded` y₀) -> x `Shaded` y

zipTreeWithList :: (x `Shaded` w) -> NonEmpty y -> x `Shaded` (w, y)

stiAsIntervalMapping :: (x ~ ℝ, y ~ ℝ) => (x `Shaded` y) -> [(x, ((y, Diff y), LinearMap ℝ x y))]

spanShading :: forall x y. (WithField ℝ Manifold x, WithField ℝ Manifold y, SimpleSpace (Needle x), SimpleSpace (Needle y)) => (Shade x -> Shade y) -> ShadeTree x -> x `Shaded` y

type DBranch x y = DBranch' x (x `Shaded` y)

data DBranch' x c

Constructors

DBranch

Fields

• boughDirection :: !(Needle' x)
• boughContents :: !(Hourglass c)

Instances

Functor (DBranch' x)

Methods

fmap :: (a -> b) -> DBranch' x a -> DBranch' x b

(<$) :: a -> DBranch' x b -> DBranch' x a

Foldable (DBranch' x)

Methods

fold :: Monoid m => DBranch' x m -> m

foldMap :: Monoid m => (a -> m) -> DBranch' x a -> m

foldr :: (a -> b -> b) -> b -> DBranch' x a -> b

foldr' :: (a -> b -> b) -> b -> DBranch' x a -> b

foldl :: (b -> a -> b) -> b -> DBranch' x a -> b

foldl' :: (b -> a -> b) -> b -> DBranch' x a -> b

foldr1 :: (a -> a -> a) -> DBranch' x a -> a

foldl1 :: (a -> a -> a) -> DBranch' x a -> a

toList :: DBranch' x a -> [a]

null :: DBranch' x a -> Bool

length :: DBranch' x a -> Int

elem :: Eq a => a -> DBranch' x a -> Bool

maximum :: Ord a => DBranch' x a -> a

minimum :: Ord a => DBranch' x a -> a

sum :: Num a => DBranch' x a -> a

product :: Num a => DBranch' x a -> a

Traversable (DBranch' x)

Methods

traverse :: Applicative f => (a -> f b) -> DBranch' x a -> f (DBranch' x b)

sequenceA :: Applicative f => DBranch' x (f a) -> f (DBranch' x a)

mapM :: Monad m => (a -> m b) -> DBranch' x a -> m (DBranch' x b)

sequence :: Monad m => DBranch' x (m a) -> m (DBranch' x a)

(WithField ℝ PseudoAffine x, Show (Needle' x), Show c) => Show (DBranch' x c)

Methods

showsPrec :: Int -> DBranch' x c -> ShowS

show :: DBranch' x c -> String

showList :: [DBranch' x c] -> ShowS

Generic (DBranch' x c)

Associated Types

type Rep (DBranch' x c) :: * -> *

Methods

from :: DBranch' x c -> Rep (DBranch' x c) x

to :: Rep (DBranch' x c) x -> DBranch' x c

(NFData x, NFData (Needle' x), NFData y) => NFData (DBranch x y)

Methods

rnf :: DBranch x y -> ()

type Rep (DBranch' x c)

type Rep (DBranch' x c) = D1 (MetaData "DBranch'" "Data.Manifold.TreeCover" "manifolds-0.4.4.0-4U7mLxDASVE34WPYCdNRgy" False) (C1 (MetaCons "DBranch" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "boughDirection") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Needle' x))) (S1 (MetaSel (Just Symbol "boughContents") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Hourglass c)))))

data Hourglass s

Hourglass as the geometric shape (two opposing ~conical volumes, sharing only a single point in the middle); has nothing to do with time.

Constructors

Hourglass

Fields

• upperBulb, lowerBulb :: !s

Instances

Functor Hourglass

Methods

fmap :: (a -> b) -> Hourglass a -> Hourglass b

(<$) :: a -> Hourglass b -> Hourglass a

Applicative Hourglass

Methods

pure :: a -> Hourglass a

(<*>) :: Hourglass (a -> b) -> Hourglass a -> Hourglass b

(*>) :: Hourglass a -> Hourglass b -> Hourglass b

(<*) :: Hourglass a -> Hourglass b -> Hourglass a

Foldable Hourglass

Methods

fold :: Monoid m => Hourglass m -> m

foldMap :: Monoid m => (a -> m) -> Hourglass a -> m

foldr :: (a -> b -> b) -> b -> Hourglass a -> b

foldr' :: (a -> b -> b) -> b -> Hourglass a -> b

foldl :: (b -> a -> b) -> b -> Hourglass a -> b

foldl' :: (b -> a -> b) -> b -> Hourglass a -> b

foldr1 :: (a -> a -> a) -> Hourglass a -> a

foldl1 :: (a -> a -> a) -> Hourglass a -> a

toList :: Hourglass a -> [a]

null :: Hourglass a -> Bool

length :: Hourglass a -> Int

elem :: Eq a => a -> Hourglass a -> Bool

maximum :: Ord a => Hourglass a -> a

minimum :: Ord a => Hourglass a -> a

sum :: Num a => Hourglass a -> a

product :: Num a => Hourglass a -> a

Traversable Hourglass

Methods

traverse :: Applicative f => (a -> f b) -> Hourglass a -> f (Hourglass b)

sequenceA :: Applicative f => Hourglass (f a) -> f (Hourglass a)

mapM :: Monad m => (a -> m b) -> Hourglass a -> m (Hourglass b)

sequence :: Monad m => Hourglass (m a) -> m (Hourglass a)

Foldable Hourglass (->) (->)

Methods

ffoldl :: (ObjectPair (->) a b, ObjectPair (->) a (Hourglass b)) => ((a, b) -> a) -> (a, Hourglass b) -> a

foldMap :: (Object (->) a, Object (->) (Hourglass a), Monoid m, Object (->) m, Object (->) m) => (a -> m) -> Hourglass a -> m

Show s => Show (Hourglass s)

Methods

showsPrec :: Int -> Hourglass s -> ShowS

show :: Hourglass s -> String

showList :: [Hourglass s] -> ShowS

Generic (Hourglass s)

Associated Types

type Rep (Hourglass s) :: * -> *

Methods

from :: Hourglass s -> Rep (Hourglass s) x

to :: Rep (Hourglass s) x -> Hourglass s

Semigroup s => Semigroup (Hourglass s)

Methods

(<>) :: Hourglass s -> Hourglass s -> Hourglass s

sconcat :: NonEmpty (Hourglass s) -> Hourglass s

stimes :: Integral b => b -> Hourglass s -> Hourglass s

(Monoid s, Semigroup s) => Monoid (Hourglass s)

Methods

mempty :: Hourglass s

mappend :: Hourglass s -> Hourglass s -> Hourglass s

mconcat :: [Hourglass s] -> Hourglass s

NFData s => NFData (Hourglass s)

Methods

rnf :: Hourglass s -> ()

type Rep (Hourglass s)

type Rep (Hourglass s) = D1 (MetaData "Hourglass" "Data.Manifold.TreeCover" "manifolds-0.4.4.0-4U7mLxDASVE34WPYCdNRgy" False) (C1 (MetaCons "Hourglass" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "upperBulb") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 s)) (S1 (MetaSel (Just Symbol "lowerBulb") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 s))))

unsafeFmapTree :: (NonEmpty (x, y) -> NonEmpty (ξ, υ)) -> (Needle' x -> Needle' ξ) -> (Shade x -> Shade ξ) -> (x `Shaded` y) -> ξ `Shaded` υ

Triangulation-builders

type TriangBuild t n x = TriangT t (S n) x (State (Map (SimplexIT t n x) (Metric x, ISimplex (S n) x)))

doTriangBuild :: KnownNat n => (forall t. TriangBuild t n x ()) -> [Simplex (S n) x]

data AutoTriang n x

breakdownAutoTriang :: forall n n' x. (KnownNat n', n ~ S n') => AutoTriang n x -> [Simplex n x]

External

type AffineManifold m = (Atlas m, Manifold m, AffineSpace m, Needle m ~ Diff m, HasTrie (ChartIndex m))

The AffineSpace class plus manifold constraints.

euclideanMetric :: EuclidSpace x => proxy x -> Metric x