bend-visgraph

Releases (3)

• 2.0.0.0 indexed
• 1.0.1.0 unindexed
• 1.0.0.0 unindexed

Definitions (237)

src/series.bend

• def increases
• def xs_check
• def xsThe x coordinates `p` of a series of `n` values: ts2vg takes one x per value, each above the one before.

visgraph.bend

• type Visibility
• type Direction
• type Weight
• type XsThe x coordinate of each value: its index, or the value at the same index of an array.
• type EdgesThe edges, as a rope: ECon adds an edge and EJoin joins two ropes, so the two halves of a split join in one step.
• type OptionsThe options of ts2vg's graph classes: the visibility, how its edges point, their weight, the weights to keep (above `min_weight` and below `max_weight`; neg_inf() and inf() keep every weight), and how many points an edge may cross.
• type SeriesThe `n` values `ys` of a time series, indexed from 0, and their x: the index, or `At{xs}` with the x of each value, increasing.
• type GraphA built graph: its `n` nodes, how its edges point, and its edges.
• type AdjacencyThe graph as compressed rows: the neighbors of node i are `targets[offsets[i]]` up to `targets[offsets[i + 1]]`, increasing, and the weights of their edges sit at the same positions.
• def nan
• def inf
• def neg_inf
• def is_nan
• def pick
• def pick_u32
• def sq_distance
• def known_slope
• def weight
• def put
• def add_edge
• def add_rightA visible point right of the pivot a: the edge (a, b).
• def add_left_dirA visible point left of the pivot a: the edge (a, b) for top_to_bottom, else (b, a).
• def add_left
• def abs_tol
• def rel_tol
• def scalemax(|xa|, |ya|), which a sweep computes once.
• def tolts2vg's tolerance for the points a and b.
• def greater
• def clearsgreater(s, best, tol(scale_a, xb, yb)), with the tolerance computed only when s is above best: the tolerance is positive, so otherwise it fails anyway.
• type StackThe stack holds the points no later point has beaten yet.
• def keyWhat a later point must beat to pop y.
• type PoppedThe work only balances the split, so F32 rounding does no harm.
• def pops
• def flush
• type Colslefts and rights count the points each point's left and right sweeps visit.
• type Arrived
• def lpops
• def arrive
• type UnboundedLatest first.
• type BlockA block of points runs the stack on its own points.
• type Local
• def local
• def block_pass
• type Merged
• def push_with_key
• def push_opening_nans
• def pops_from
• def set_left
• def in_order
• def bound_unbounded
• def onto
• def push_block_stack
• def merge_blockThe merge replays the stack over every point before the block.
• type WalkedBend matches only parameters, so a read's result must arrive as one: a sweep reads y and x at `ahead`, where the next sweep starts, and hands them over.
• def at_index
• def natural_right
• def natural_left
• def horizontal_right
• def horizontal_left
• def right_sweepEach sweep, with x as the index (`index`) or read from `xs`.
• def left_sweep
• type Out
• def points
• def edges_of
• def swept
• def bounded
• def stacked
• def slotsAn array with room for `n` slots, indexed from 0.
• def no_xsA stand-in for `xs` when x is the index, which no sweep reads.
• def built
• def visibilityThe graph of the `n` values `ys` at `xs`, on one thread, as one block.
• def added
• def atomic_bump
• def degrees.intoThe degrees of the nodes of `es`, added into `d`; parallel.bend counts them on every thread.
• type PtsThe points, in a list the parallel ranges share.
• def penetrable.pointsThe points of `ys` and `xs` from index `i` down to 0, onto `acc`; `yr` and `xr` hold y and x at `i`, and x is the index if `index` says so.
• type TopsThe `limit + 1` largest slopes (or heights) a sweep has accepted, as ts2vg's max_slopes; the sweep accepts a point above the smallest of them.
• type LowThe position and value of the first smallest top.
• def tops_new
• def pick_low
• def low_from
• def lowest
• def Low.v
• def set_at
• def blocked_naturalHow many tops a natural edge with slope `s` does not clear, as ts2vg's num_penetrations weight.
• def blocked_horizontal
• def add_knownts2vg's add_edge with a known weight: NaN means the weight function computes it.
• def add_orientedThe edge from a to b, or from b to a for top_to_bottom when b is higher.
• def is_down
• def is_count
• def natural_edge
• def horizontal_edge
• def natural_sweepThe sweep of point a over the points right of it: ts2vg's inner loop.
• def horizontal_sweepThe same for the horizontal sweep, which stops once the smallest top is above a: no later point can be seen.
• def sweep
• def sweepsThe sweeps of the first `count` points of `pts`, one rope each: ts2vg's outer loop.
• def drop