Data.Manifold.Web.Internal

Documentation

type WebNodeId = Int

type WebNodeIdOffset = Int

data Neighbourhood x y

Constructors

Neighbourhood

Fields

• _dataAtNode :: y
• _neighbours :: Vector WebNodeIdOffset
• _localScalarProduct :: Metric x
• _webBoundaryAtNode :: Maybe (Needle' x)

Instances

Functor (Neighbourhood x)

Methods

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

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

Foldable (Neighbourhood x)

Methods

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

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

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

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

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

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

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

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

toList :: Neighbourhood x a -> [a]

null :: Neighbourhood x a -> Bool

length :: Neighbourhood x a -> Int

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

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

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

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

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

Traversable (Neighbourhood x)

Methods

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

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

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

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

(WithField ℝ PseudoAffine x, SimpleSpace (Needle x), Show (Needle' x), Show y) => Show (Neighbourhood x y)

Methods

showsPrec :: Int -> Neighbourhood x y -> ShowS

show :: Neighbourhood x y -> String

showList :: [Neighbourhood x y] -> ShowS

Generic (Neighbourhood x y)

Associated Types

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

Methods

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

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

(NFData x, NFData (Metric x), NFData (Needle' x), NFData y) => NFData (Neighbourhood x y)

Methods

rnf :: Neighbourhood x y -> ()

type Rep (Neighbourhood x y)

type Rep (Neighbourhood x y) = D1 * (MetaData "Neighbourhood" "Data.Manifold.Web.Internal" "manifolds-0.5.0.1-BXWDyndrqVvASnHIWZyxjI" False) (C1 * (MetaCons "Neighbourhood" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "_dataAtNode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * y)) (S1 * (MetaSel (Just Symbol "_neighbours") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Vector WebNodeIdOffset)))) ((:*:) * (S1 * (MetaSel (Just Symbol "_localScalarProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Metric x))) (S1 * (MetaSel (Just Symbol "_webBoundaryAtNode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Needle' x)))))))

webBoundaryAtNode :: forall x y. Lens' (Neighbourhood x y) (Maybe (Needle' x))

neighbours :: forall x y. Lens' (Neighbourhood x y) (Vector WebNodeIdOffset)

localScalarProduct :: forall x y. Lens' (Neighbourhood x y) (Metric x)

dataAtNode :: forall x y y. Lens (Neighbourhood x y) (Neighbourhood x y) y y

data WebLocally x y

Constructors

LocalWebInfo

Fields

• _thisNodeCoord :: x
• _thisNodeData :: y
• _thisNodeId :: WebNodeId
• _nodeNeighbours :: [(WebNodeId, (Needle x, WebLocally x y))]
• _nodeLocalScalarProduct :: Metric x
• _webBoundingPlane :: Maybe (Needle' x)

Instances

Functor (WebLocally x)

Methods

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

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

WithField ℝ Manifold x => Comonad (WebLocally x)

fmap from the co-Kleisli category of WebLocally.

Methods

extract :: WebLocally x a -> a

duplicate :: WebLocally x a -> WebLocally x (WebLocally x a)

extend :: (WebLocally x a -> b) -> WebLocally x a -> WebLocally x b

Generic (WebLocally x y)

Associated Types

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

Methods

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

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

type Rep (WebLocally x y)

type Rep (WebLocally x y) = D1 * (MetaData "WebLocally" "Data.Manifold.Web.Internal" "manifolds-0.5.0.1-BXWDyndrqVvASnHIWZyxjI" False) (C1 * (MetaCons "LocalWebInfo" PrefixI True) ((:*:) * ((:*:) * (S1 * (MetaSel (Just Symbol "_thisNodeCoord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * x)) ((:*:) * (S1 * (MetaSel (Just Symbol "_thisNodeData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * y)) (S1 * (MetaSel (Just Symbol "_thisNodeId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * WebNodeId)))) ((:*:) * (S1 * (MetaSel (Just Symbol "_nodeNeighbours") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [(WebNodeId, (Needle x, WebLocally x y))])) ((:*:) * (S1 * (MetaSel (Just Symbol "_nodeLocalScalarProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Metric x))) (S1 * (MetaSel (Just Symbol "_webBoundingPlane") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Needle' x))))))))

webBoundingPlane :: forall x y. Lens' (WebLocally x y) (Maybe (Needle' x))

thisNodeId :: forall x y. Lens' (WebLocally x y) WebNodeId

thisNodeData :: forall x y. Lens' (WebLocally x y) y

thisNodeCoord :: forall x y. Lens' (WebLocally x y) x

nodeNeighbours :: forall x y. Lens' (WebLocally x y) [(WebNodeId, (Needle x, WebLocally x y))]

nodeLocalScalarProduct :: forall x y. Lens' (WebLocally x y) (Metric x)

data NeighbourhoodVector x

Constructors

NeighbourhoodVector

Fields

• _nvectId :: Int
• _theNVect :: Needle x
• _nvectNormal :: Needle' x
• _nvectLength :: Scalar (Needle x)
• _otherNeighboursOverlap :: Scalar (Needle x)

theNVect :: forall x. Lens' (NeighbourhoodVector x) (Needle x)

otherNeighboursOverlap :: forall x. Lens' (NeighbourhoodVector x) (Scalar (Needle x))

nvectNormal :: forall x. Lens' (NeighbourhoodVector x) (Needle' x)

nvectLength :: forall x. Lens' (NeighbourhoodVector x) (Scalar (Needle x))

nvectId :: forall x. Lens' (NeighbourhoodVector x) Int

data PropagationInconsistency x υ

Constructors

PropagationInconsistency

Fields

• _inconsistentPropagatedData :: [(x, υ)]
• _inconsistentAPrioriData :: υ

PropagationInconsistencies [PropagationInconsistency x υ]

Instances

(Show υ, Show x) => Show (PropagationInconsistency x υ)

Methods

showsPrec :: Int -> PropagationInconsistency x υ -> ShowS

show :: PropagationInconsistency x υ -> String

showList :: [PropagationInconsistency x υ] -> ShowS

Monoid (PropagationInconsistency x υ)

Methods

mempty :: PropagationInconsistency x υ

mappend :: PropagationInconsistency x υ -> PropagationInconsistency x υ -> PropagationInconsistency x υ

mconcat :: [PropagationInconsistency x υ] -> PropagationInconsistency x υ

inconsistentPropagatedData :: forall x υ. Traversal' (PropagationInconsistency x υ) [(x, υ)]

inconsistentAPrioriData :: forall x υ. Traversal' (PropagationInconsistency x υ) υ

newtype PointsWeb :: * -> * -> * where

A PointsWeb is almost, but not quite a mesh. It is a stongly connected† directed graph, backed by a tree for fast nearest-neighbour lookup of points.

†In general, there can be disconnected components, but every connected component is strongly connected.

Constructors

PointsWeb :: {..} -> PointsWeb x y

Fields

• webNodeRsc :: x `Shaded` Neighbourhood x y

Instances

Functor (PointsWeb a)

Methods

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

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

Foldable (PointsWeb a)

Methods

fold :: Monoid m => PointsWeb a m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PointsWeb a a -> a

foldl1 :: (a -> a -> a) -> PointsWeb a a -> a

toList :: PointsWeb a a -> [a]

null :: PointsWeb a a -> Bool

length :: PointsWeb a a -> Int

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

maximum :: Ord a => PointsWeb a a -> a

minimum :: Ord a => PointsWeb a a -> a

sum :: Num a => PointsWeb a a -> a

product :: Num a => PointsWeb a a -> a

Traversable (PointsWeb a)

Methods

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

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

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

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

Foldable (PointsWeb x) ((->) LiftedRep LiftedRep) ((->) LiftedRep LiftedRep)

Methods

ffoldl :: (ObjectPair (LiftedRep -> LiftedRep) a b, ObjectPair (LiftedRep -> LiftedRep) a (PointsWeb x b)) => (LiftedRep -> LiftedRep) (a, b) a -> (LiftedRep -> LiftedRep) (a, PointsWeb x b) a

foldMap :: (Object (LiftedRep -> LiftedRep) a, Object (LiftedRep -> LiftedRep) (PointsWeb x a), Monoid m, Object (LiftedRep -> LiftedRep) m, Object (LiftedRep -> LiftedRep) m) => (LiftedRep -> LiftedRep) a m -> (LiftedRep -> LiftedRep) (PointsWeb x a) m

Generic (PointsWeb a b)

Associated Types

type Rep (PointsWeb a b) :: * -> *

Methods

from :: PointsWeb a b -> Rep (PointsWeb a b) x

to :: Rep (PointsWeb a b) x -> PointsWeb a b

(NFData x, NFData (Metric x), NFData (Needle' x), NFData y) => NFData (PointsWeb x y)

Methods

rnf :: PointsWeb x y -> ()

type Rep (PointsWeb a b)

type Rep (PointsWeb a b) = D1 * (MetaData "PointsWeb" "Data.Manifold.Web.Internal" "manifolds-0.5.0.1-BXWDyndrqVvASnHIWZyxjI" True) (C1 * (MetaCons "PointsWeb" PrefixI True) (S1 * (MetaSel (Just Symbol "webNodeRsc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Shaded a (Neighbourhood a b)))))

data WebChunk x y

Constructors

WebChunk

Fields

• _thisChunk :: PointsWeb x y
• _layersAroundChunk :: [(x `Shaded` Neighbourhood x y, WebNodeId)]

thisChunk :: forall x y. Lens' (WebChunk x y) (PointsWeb x y)

layersAroundChunk :: forall x y. Lens' (WebChunk x y) [(Shaded x (Neighbourhood x y), WebNodeId)]

data NodeInWeb x y

Constructors

NodeInWeb

Fields

• _thisNodeOnly :: (x, Neighbourhood x y)
• _layersAroundNode :: [(x `Shaded` Neighbourhood x y, WebNodeId)]

thisNodeOnly :: forall x y. Lens' (NodeInWeb x y) (x, Neighbourhood x y)

layersAroundNode :: forall x y. Lens' (NodeInWeb x y) [(Shaded x (Neighbourhood x y), WebNodeId)]

data PathStep x y

Constructors

PathStep

Fields

• _pathStepStart :: WebLocally x y
• _pathStepEnd :: WebLocally x y

pathStepStart :: forall x y. Lens' (PathStep x y) (WebLocally x y)

pathStepEnd :: forall x y. Lens' (PathStep x y) (WebLocally x y)

type MetricChoice x = Shade x -> Metric x

traverseInnermostChunks :: forall f x y z. Applicative f => (WebChunk x y -> f (PointsWeb x z)) -> PointsWeb x y -> f (PointsWeb x z)

traverseNodesInEnvi :: forall f x y z. Applicative f => (NodeInWeb x y -> f (Neighbourhood x z)) -> PointsWeb x y -> f (PointsWeb x z)

fmapNodesInEnvi :: (NodeInWeb x y -> Neighbourhood x z) -> PointsWeb x y -> PointsWeb x z

ixedFoci :: [a] -> [((Int, a), [a])]

indexWeb :: PointsWeb x y -> WebNodeId -> Maybe (x, y)

unsafeIndexWebData :: PointsWeb x y -> WebNodeId -> y

jumpNodeOffset :: WebNodeIdOffset -> NodeInWeb x y -> NodeInWeb x y

webAroundChunk :: WebChunk x y -> PointsWeb x y

zoomoutWebChunk :: WebNodeIdOffset -> WebChunk x y -> (WebChunk x y, WebNodeId)

pickNodeInWeb :: PointsWeb x y -> WebNodeId -> NodeInWeb x y

webLocalInfo :: forall x y. WithField ℝ Manifold x => PointsWeb x y -> PointsWeb x (WebLocally x y)

localFmapWeb :: WithField ℝ Manifold x => (WebLocally x y -> z) -> PointsWeb x y -> PointsWeb x z

tweakWebGeometry :: (WithField ℝ Manifold x, SimpleSpace (Needle x)) => MetricChoice x -> (WebLocally x y -> [WebNodeId]) -> PointsWeb x y -> PointsWeb x y

bidirectionaliseWebLinks :: forall x y. PointsWeb x y -> PointsWeb x y

pumpHalfspace

Arguments

:: (SimpleSpace v, Scalar v ~ ℝ)

=> Norm v

-> v

A vector v for which we want dv.^v ≥ 0.

-> (DualVector v, [v])

A plane dv₀ and some vectors ws with dv₀.^w ≥ 0, which should also fulfill dv.^w ≥ 0.

-> Maybe (DualVector v)

The plane dv fulfilling these properties, if possible.

smallPseudorandSeq :: [ℝ]

data LinkingBadness r

Constructors

LinkingBadness

Fields

• gatherDirectionsBadness :: !r

  Prefer picking neighbours at right angles to the currently-explored-boundary. This is needed while we still have to link to points in different spatial directions.

• closeSystemBadness :: !r

  Prefer points directly opposed to the current boundary. This is useful when the system of directions is already complete and we want a nicely symmetric “ball” of neighbours around each point.

Instances

Functor LinkingBadness

Methods

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

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

linkingUndesirability

Arguments

:: ℝ

Absolute-square distance (euclidean norm squared)

-> ℝ

Directional distance (distance from wall containing all already known neighbours)

-> LinkingBadness ℝ

“Badness” of this point as the next neighbour to link to. In gatherDirections mode this is large if the point is far away, but also if it is right normal to the wall. The reason we punish this is that adding two points directly opposed to each other would lead to an ill-defined wall orientation, i.e. wrong normals on the web boundary.

bestNeighbours :: forall i v. (SimpleSpace v, Scalar v ~ ℝ) => Norm v -> [(i, v)] -> ([i], Maybe (DualVector v))

bestNeighbours' :: forall i v. (SimpleSpace v, Scalar v ~ ℝ) => Norm v -> [(i, v)] -> ([(i, v)], Maybe (DualVector v))

gatherGoodNeighbours :: forall i v. (SimpleSpace v, Scalar v ~ ℝ) => Norm v -> Variance v -> DualVector v -> [v] -> [(i, v)] -> [(i, v)] -> ([(i, v)], Maybe (DualVector v))

extractSmallestOn :: Ord b => (a -> Maybe b) -> [a] -> Maybe (a, [a])

type WNIPath = [WebNodeId]

type NodeSet = IntSet

pathsTowards :: forall x y. (WithField ℝ Manifold x, HasCallStack) => WebNodeId -> PointsWeb x y -> [[y]]

traversePathInIWeb :: forall φ x y. (WithField ℝ Manifold x, Monad φ, HasCallStack) => [WebNodeId] -> (PathStep x y -> φ y) -> PointsWeb x (WebLocally x y) -> φ (PointsWeb x (WebLocally x y))

traversePathsTowards

Arguments

:: (WithField ℝ Manifold x, Monad φ, Monad f, HasCallStack)

=> WebNodeId

The node towards which the paths should converge.

-> (PathStep x y -> φ y)

The action which to traverse along each path.

-> (forall υ. WebLocally x y -> φ υ -> f υ)

Initialisation/evaluation for each path-traversal.

-> PointsWeb x y

-> f (PointsWeb x y)