fluxprune: keeping the points that matter

fluxprune keeps a subset of a series' points, read as straight lines between them: the first and last points (to stitch blocks), the minimum and maximum, then whichever points lower the time-weighted RMSE of the lines most, until a point no longer buys enough. prune(times, values) works with its defaults; three settings change what it keeps:

• error_per_point (θ): the exchange rate between error and points, and the one to choose first: the RMSE relative to the block's range you would accept at some number of points, divided by that number. The default is 0.1% at a tenth of the input's points.
• max_points: a hard cap.
• max_error: the largest error of any scan, in the signal's units. It only adds points.

The first two sections show them on each signal; the rest is how it works and how it was chosen.

Data: 19 synthetic signals × 5 days of 1 s scans, cut into 1 h storage blocks of 3,600 points (tslab/prune/signals.py; the studies of ranking and stopping rules use the first 12). Relative errors are relative to each block's range (max − min). Regenerate with uv run python make_prune_report.py in experimental/.

Choosing θ and max_points

error_per_point (θ) is an exchange rate: prune adds points in order of how much they lower the time-weighted RMSE and stops when a point no longer buys θ of it, the RMSE relative to the block's range and read above the block's own white noise (the noise floor). Choose it first, as the RMSE you would accept at some number of points divided by that number: θ = Y / X reads "Y at X points". X is not a target: a block that needs fewer stops sooner, and a harder one goes on at a worse error. The default is 0.1% of the range at a tenth of the input's points, θ = 0.001 / (n / 10): 2.8·10⁻⁶ for an hour of 1 s scans. max_points is a hard cap on top; it drops the rmse pass's least significant points. Three settings:

• default: no cap (the same as θ = 2.8·10⁻⁶ on these blocks);
• default, max_points 360: a cap at a tenth of the scans;
• coarse: θ = 0.0014, half the range at 360 points or 5% at 36.

One hour of eight signals (day 0, 09:00; the pyrometer's busiest hour, of which minutes 10-30 are shown); each panel gives the points kept in the hour, whether the cap bound, the RMSE over the hour's range and the largest error of any scan, in the signal's units.

All 19 signals (described below), 1 h blocks of all 5 days: mean points per hour (the most in one block) and the share of blocks where the cap bound; below, the mean RMSE over the block's range · the largest error of any block, in the signal's units. The default keeps 162 points per hour on average (median 77), and 22% of the blocks want more than 360: the noisy and fast-moving signals, which the cap holds at 360 for a larger RMSE. The coarse θ keeps 24 on average and lets the RMSE grow to several per cent where a signal is busy, which mostly costs the largest error: max_error bounds that.

The pyrometer against its noise-free curve: points per hour in hours with spikes and in quiet ones, points on a spike per hour, how far the kept lines' top is below each spike's (°C, mean and worst), and the RMSE against the curve under the noise (°C). A time-weighted RMSE counts a narrow spike as cheap (a 600 °C spike 4 s wide adds about 30 °C to an hour's RMSE), so the coarse θ cuts its tops; the default keeps them.

Adding max_error

max_error bounds the largest distance of any scan from the kept lines, in the signal's own units. It only adds points: after the rmse pass, every line that strays further is split (the max_error pass). It covers what an RMSE averages away: a narrow spike, a glitch, a quiet block whose range is its own dither. Choose it against the sensor's noise σ (Pruned.noise estimates it): lines through noisy scans can't stay closer than a few σ without keeping most of them. On white noise at θ = 0.0014, max_error = 1σ keeps 1681, 2σ keeps 381, 3σ keeps 34, 5σ keeps 12 points per hour of 3,600; below σ prune warns. With max_points as well, the cap goes to max_error first and the rmse pass gets the rest; if max_error can't be met within the cap it is relaxed to about the tightest bound the cap allows (max_error_met false). Four settings on top of the coarse θ, with a max_error per signal (columns σ, loose and fine below):

• coarse: θ = 0.0014 alone;
• loose max_error: about what an operator would notice;
• fine max_error: about twice the sensor's noise, or the resolution that matters for a signal without noise;
• fine max_error, max_points 360: the same with the cap as a safety net.

All signals, 1 h blocks of all days, as above; σ is the median noise estimate (0 where the times have no cadence or the signal no noise). A loose max_error adds points only where the coarse lines missed something: the pyrometer's spikes, the furnace's dropouts, the grid frequency's swings. A fine one, at about 2σ, is expensive wherever there is noise: hundreds of points per hour that mostly trace it (temperature 511, white noise 381; the pyrometer's quiet hours, below, go from about ten to over a hundred). The cap holds them at 360 by relaxing the bound, in the worst block to 1.05× the one asked (white-noise) to 1.42× (grid-frequency). At 3σ or more the same signals need far fewer.

The pyrometer, as above.

The signals

The first eighteen are the corpus of the ranking and stopping-rule studies; the six after them are for what errors are relative to (small variations on a large offset), and the pyrometer for the noise floor.

The noise floor

Lines through noisy samples leave about the noise's σ against them however many points are kept, until nearly all are, so the rmse pass on a quiet, noisy block keeps buying points that trace the noise: its range is a few σ, and relative to that the noise looks like signal. With the noise floor (the default) it stops on √(e² − σ²) instead of e, an estimate of the error against the signal under the noise. σ is estimated in one O(n) pass: each scan's distance from the chord of its two neighbours, divided by √(1 + w² + (1 − w)²) (w its position between them in time), median, × 1.4826 (fluxprune/_noise.py). Nothing is smoothed and the ranking is the same; only where it stops moves. Per signal, 1 h blocks of all days: the median σ over the range, and at θ = 0.0015 (the old default) and at the default (θ = 0.001 / (n / 10): 2.8e-6 for 3,600 scans) the points per hour without → with the floor and, below, the mean RMSE over the range (against the scans).

Archives

Every noise estimate assumes the times were chosen independently of the values; an archive's weren't (swinging door or a deadband keeps a point because of its value), and on a smooth tag its points pass tests of white noise as well as raw scans do, with σ read at about the CompDev. So the floor runs only on a cadence: at least 90% of the intervals one scan (fluxcode's own test, fluxcode._noise.cadence). The tags' swinging-door archives in 1 h blocks of all days: points per hour in, the share of blocks with a floor, and the default prune's points per hour · RMSE over the range against the 1 s scans, as is and with noise_floor=False, and the archive's own RMSE (the tank level and the valve archive 2-5 points per hour: nothing to prune).

Against the signal under the noise instead: on white noise (σ = 1, 120 hours) the kept lines' RMSE from zero is 0.27σ on average with the floor and 1.00σ without; in the worst hour 0.48σ and 1.03σ (with few points left, the lines from the required minimum and maximum lean further).

Lower θ

Points per hour (day 0) without → with the floor as θ falls. Without it a lower θ buys noise, so the count follows the noise; with it the noise-dominated signals level off at what their content needs, and only signals with structure at finer scales keep more.

A pyrometer

The case that asked for it: a pyrometer at a furnace's exit conveyor reads its noisy floor most of the time and a narrow spike (a / (b + t²), about 10 s wide) as each hot item passes, 1,264 spikes in 5 days, with quiet hours between production runs (tslab/prune/signals.py, pyrometer). Against its noise-free curve: points per hour in hours with spikes and in quiet ones, points on a spike (3σ above the floor) per hour, how far the kept lines' top is below each spike's (°C, mean and worst), and the RMSE against the curve under the noise (°C) in busy and quiet hours. The floor takes the quiet hours from tracing noise to a handful of points; it changes nothing on the spikes, which a time-weighted RMSE counts as cheap: a 600 °C spike 4 s wide adds only about 30 °C to an hour's RMSE. A lower θ (the default) or a max_error of a few σ keeps them.

How it works, and how it was chosen

The studies behind the defaults: how good the ranking is, which stopping rule, what errors are relative to, how max_error is met, refit, archives as input, and speed. Some use rules and settings that are only experiments (tslab/prune/rules.py).

Ranking quality at a fixed count

Every method picks the same number of points per 1 h block (day 0, every 4th hour, so 6 blocks per signal); cells are the geometric mean of the block's RMSE over fluxprune's (refined). fluxprune and top-down keep the required points within k; swinging door's CompDev is searched for k points (the nearest count at or above k); LTTB and min/max buckets are the plotting downsamplers; Visvalingam-Whyatt (cartography's line simplification) is bottom-up by triangle area, and + refine adds fluxprune's two refinement passes to its points.

12 points per hour

36 points per hour

108 points per hour

Against the optimum

On the same whole blocks (3,600 points), the optimal choice of k points that include the required ones (dynamic programming, O(n²k): about 2 s a block, an oracle, not a method); each greedy method's RMSE over the optimum's, geometric mean.

Error curves

What a rule sees: the relative RMSE of keeping k points (the ranking, before refinement), one hour of each signal. Smooth signals fall as k⁻² (sine), random walks as k⁻½ (temperature, pH), and white noise hardly at all until most points are kept; a step or ramp signal falls off a cliff and then sits on its noise. The dashed line is 0.5% for scale.

How many points: the stopping rules

Each rule's one parameter is set so that all 1,440 blocks together keep 36 points per hour on average (1% of the scans), except knee, which can't be calibrated (its total is what its α gives). Cells are the mean points kept per hour and, below, the geometric mean RMSE of the blocks. The corpus columns are the mean points per block, the mean and median block RMSE, and the most points one block got.

Sublinear?

Each rule's points per block against the tolerance rule's at the same budget (the tolerance rule follows complexity linearly by definition), every block of the corpus, and the slope of a log-log fit: 0 is a fixed count, 1 the tolerance, ½ the plain geometric mean. All slopes: count 0.00, tolerance 1.00, balance 0.61, marginal 0.47, marginal (RMSE) 0.36, amortized 0.37, amortized, no floor 0.70, tolerance+noise 0.82, balance+noise 0.38.

Other budgets

The same calibration at other averages: mean / median block RMSE and, below, the most points one block got.

Sampling rate and block length

A rule that adapts to the data, not to how it was stored, should keep about as many points of an hour sampled every 10 s as of the same hour sampled every second (ratio 1 when the signal is captured at both rates; noise can't be), and about as many in one 12 h block as in twelve 1 h blocks (count and balance scale K with the block's hours). Median over day 0's hours of k at 10 s over k at 1 s:

k of a 12 h block over the sum of k of its twelve 1 h blocks (day 0, mean of the two halves):

Relative to what?

Errors so far are relative to each block's range, so a block's precision follows its own range whatever the units or the offset: an hour of furnace that moves 4 °F around 2,115 °F gets the same relative precision as an hour of a valve that moves 0-100%. The alternatives are the block's largest absolute value, the geometric mean of the two, and a known span per series (here each signal's range over all its days, as a historian's per-tag span would give, but which a store that knows nothing of the series lacks). The ranking doesn't depend on the scale, only the rules' thresholds do. Six more signals where it matters: furnace, furnace-dropout, grid-frequency, ambient-C, ambient-K, level-quiet.

Each rule and scale calibrated to 36 points per hour over all 2,160 blocks of the 18 signals (5 days each). Cells are the mean points kept per hour and, below, the mean RMSE relative to the signal's span: a measure that doesn't depend on the units, the offset or the block, so the scales can be compared (the furnace with dropouts is measured off its dropouts). The last row is the least mean RMSE over span possible for the total, which needs the span.

Block length: k of a 12 h block over the sum of k of its twelve 1 h blocks (all days), with θ / hours for the amortized rule. A ratio below 1 is partly right: twelve blocks keep twelve sets of required points, and a longer block can spend its points where they matter most.

max_error and max_points against swinging door

The rmse pass at θ = 0.0015 (the old default: coarse, so that the guards do the work) alone, then with max_error set to an engineer's value per signal (the historian tags' CompDev, otherwise about what matters), then with a safety cap of max_points = 360 per hour (10% of the scans) as well. The max_error pass splits each line between the rmse pass's points that strays further, by farthest reach (below). Swinging door at CompDev = max_error / 2 has the same guarantee: its doors pivot about the archived point, so at CompDev = max_error (last column) its line strays up to twice that. Cells: mean points per hour · the largest error of any block over max_error · mean RMSE over the signal's span; below, the share of blocks the cap bound (rmse_met or max_error_met false).

The max_error pass

How max_error is met. Each line between the rmse pass's points that strays further than max_error is split from its left end. Every scan after an anchor bounds the slope of a line from the anchor that passes within max_error of it, from below and above. Swinging door's rule ends the line at the first scan its chord can't reach. Farthest reach, fluxprune's, scans on while the bounds still overlap (some line could still pass every scan so far), notes the last scan whose own chord satisfies them, and when they cross makes that scan the next anchor: with noise, a scan after one the chord can't reach is often reachable again. Fewest points is the exact minimum (dynamic programming over every feasible chord). Cells: points per hour · RMSE over the span; the rmse pass's points the same in each column; below, the max_error pass's time per 1 h block.

Refit: values that aren't samples

prune(refit=True) keeps the same times but replaces the values with those whose lines fit the input best in time-weighted L2 (a tridiagonal system over the kept points, O(n)), the first, last, minimum and maximum points (and the points around gaps) keeping their samples. Per signal, over 1 h blocks of all days with any error left: the geometric mean of the RMSE and the largest error with refit over without, at the rmse pass's points; and with max_error = the signal's guard value, the share of blocks where it still holds after the refit (it isn't checked again).

Swinging-door archives as input

The same rules with the same parameters on what each tag's swinging-door historian archived (tslab/common/historian.py: exception + swinging-door filters at the tag's CompDev), in 1 h blocks: points per hour in and kept (share of the archive), and below, the geometric-mean RMSE against the archive's own straight lines (relative to the block's range).

Speed

Apple M3, one thread, best of 3, 1 s scans. rank is the O(n log n) pass; prune adds picking k (O(n)) and the two O(n) refinement passes, shown as the time it adds to rank; max_error (1% of the range) adds the max_error pass on top of that, and refit the least-squares values, both also against rank. bench/prune.py has the same per call for more signals.

Findings

1. Ranking: bottom-up, then refine. Removing the cheapest point repeatedly (exact time-weighted L2, a heap, O(n log n)) gives a nested ranking of every point and the whole error curve in one pass, but greedy merging is myopic: about 30% above the optimum. Two O(n) passes that slide each kept point to its best spot between its neighbours bring it to 4-6% above the optimum on whole 1 h blocks at 12, 36 and 108 points (worst 1.4×), for +10-30% of the ranking's time. Top-down splitting (Douglas-Peucker's order, and that of perceptually important points) is better than plain bottom-up on step-like signals and much worse on others (up to 74× the optimum on the compressor). Visvalingam-Whyatt (bottom-up by triangle area) is 1.6-1.8× fluxprune's RMSE, and 1.03-1.07× with the same refinement passes: the passes do most of the work, and exact L2 is still the better order to start from. SWAB (Keogh et al. 2001) is bottom-up in a sliding window, for streams; on whole blocks it is plain bottom-up. At the same number of points, swinging door's RMSE is 1.3-1.5× fluxprune's, LTTB's 2-2.5×, and min/max buckets' and even spacing's 2-4×: the plotting downsamplers keep shape for the eye, not the interpolation.
2. The error curve tells the signal apart from the noise. Smooth signals fall as k⁻², random walks as k⁻½, noise stays flat until most points are kept. The curve at k = n/2 measures the white noise: it is 0.29σ for white noise at every block size (tslab/prune/rules.py, noise), regular or irregular times.
3. Fixed count spends the same on a valve that two points describe exactly as on white noise, and fixed tolerance is the opposite: calibrated to the same total it hands noise blocks everything (white noise 194 points/h against 36 average, a block up to 432) and its ε ends at 13% of the range for all the others: the worst mean error of all rules. Neither alone is a rate control for mixed data.
4. The geometric mean of the two (balance, √(K·k_ε)) is a real compromise (slope ~0.6 against the tolerance's counts) and bounded by √(K·n), but noise is still the most "complex" thing it sees: white noise gets 4× the average. Raising ε to the block's own noise level (balance+noise) fixes that and reaches nearly the least mean RMSE possible for the total at 36/h (3.4% vs 3.3%) with the smallest largest block of the adaptive rules (132); at large budgets it stops early on purpose (it won't trace noise), so its mean levels off. Its weakness is the noise estimate: correlated noise (flow: τ 5 s at 1 s scans) partly reads as signal, so the count depends on the sampling rate there (×0.25).
5. The marginal rules (stop when a point gains less than λ) give the least mean error for the total by construction (e + λk) but depend on the sampling rate: a noise point's gain scales as 1/n, so the same λ keeps 13-25× more noise points at 10 s than at 1 s. The user's prediction holds: on noise they either give up at once or never.
6. The amortized rule (stop at the first k where the error left is under θ per point added) is the best one-knob rule here: on its own error curve (no floor) within 4-21% of the least mean RMSE at every budget, largest block 2.4-3.7× the average, and the most stable under a change of sampling rate (×0.80-1.00 for every signal). It stops where the error curve meets the line θ·k: in effect error and points traded at a fixed rate, so it grows with complexity sublinearly (k ∝ c^⅓ for a smooth signal's k⁻² curve, ∝ σ for noise). It is error_per_point in the API.
7. The noise floor (the default): the same rule on √(e² − σ²), σ the block's white noise from each scan's distance to its neighbours' chord (median, one O(n) pass), so it stops buying points that only trace the noise. At θ = 0.0015 it keeps a fraction of the points on noise-dominated blocks (white noise 95 → 11 per hour, motor current 67 → 12, the quiet level 77 → 19, vibration 47 → 18) and the same on smooth and quantized ones, for 0-10% more RMSE against the scans (mostly the noise the dropped points traced). Calibrated to 36/h it reaches the least mean RMSE possible for the total (3.3%, as marginal (RMSE)) with half the median (0.95% against 1.7%), where the rule without it is at 3.6%; at 324/h it levels off (2.8% against 1.9%), since it won't trace noise. A lower θ no longer buys noise: at θ = 1.5·10⁻⁶ white noise keeps 17 points per hour (3,142 without), while smooth signals keep refining. The pyrometer (narrow spikes on a noisy floor, quiet hours between production runs) shows both sides: at θ = 0.0015 its quiet hours go from 94 points to 11, closer to the curve under the noise (0.56 °C RMSE against 0.66); its spikes, which a time-weighted RMSE counts as cheap, are kept by a lower θ (the default: 236 points per busy hour and 22 per quiet one, every peak within 7 °C) or by max_error = 10σ (162, the same peaks), not by the floor. At the default θ the floor is what makes the low rate usable: without it the noise-dominated signals keep most of their scans (white noise 2,941 of 3,600 per hour, motor current 2,705, the pyrometer's quiet hours 2,933), with it 18, 22 and 22. Its costs: correlated noise reads partly as signal at the sampling rate (flow, τ 5 s: at 10 s scans the same noise reads as noise and keeps 0.14× as many points; temperature and pH 0.66-0.69×), so it is less stable under a change of sampling rate than the rule without it; and on pure noise the lines from the required minimum and maximum lean on the few points left (the worst of 120 hours of white noise 0.48σ from the zero under it, against 0.38σ without the floor; 0.26σ against 0.33σ on average). Every noise estimate assumes the times were chosen independently of the values, which an archive's weren't: on the tags' swinging-door archives the estimate read about the CompDev (temperature 3× its scans' noise) and passed tests of white noise (residuals near zero, their lag-1 correlation) as well as the scans, and the floor doubled the error against the scans (temperature 3.3% of the range against 1.9%). No test on the values tells them apart, so the floor runs only on a cadence (at least 90% of the intervals one scan, fluxcode's own test): the archives get none, and keep what they kept without it. Scoring the ranking against a smoothed copy of the scans was tried and dropped: a line through noisy samples is no closer to a smooth curve, so it keeps as many points on noise, needs a window, and shaves narrow peaks.
8. Knee detection (stop when doubling the points stops paying) is unusable: periodic signals have plateaus at small k (12 h of a sine: 4 points) and random walks never stop (temperature: 3,061 of 3,600).
9. Block length. Every rule but the fixed count keeps fewer points in one 12 h block than in twelve 1 h blocks, for two reasons. A parameter per block is spread over a longer block: with θ / hours for the amortized rule (as K · hours for a count) its geometric mean over the 18 signals is 0.30 (0.03-0.90, the low end the quiet level and the dropouts, whose range a single event sets, and white noise, which the noise floor holds at about the same count however long the block). And a longer block has a wider range: with a known span per series instead, the same rule reaches 0.55. The rest is as it should be: twelve blocks keep twelve sets of required points, and one block can place its points where they matter most.
10. Relative to what? Of the scales that need no knowledge of the series, the block's own range is the best: with the amortized rule at 36/h, the mean error over each signal's span is 1.2%, against 1.0% with known spans and 1.0% the least possible. It gives small variations on a large offset the precision they need by itself: the furnace (4 °F an hour around 2,115) and the grid frequency keep 29 and 100 points per hour, where known spans give 23 and 126. The largest |value| depends on where zero is: the same ambient temperature keeps 74 points per hour in °C and 14 in kelvin, and it starves exactly the signals that have little range for their offset (furnace and grid frequency: 9 and 8 per hour, at 1.2% and 4.7% of their span, against 0.32% and 1.5%). √(range · max|x|) halves both effects but keeps them (64 against 26 points for °C and K, grid 2.7% of span), and it helps block length less than a known span (0.40 against 0.55). The range has two costs: a quiet block makes its own dither look like signal (the quiet level keeps 37 points per hour tracing one 0.01 step, against 6 with its span; 77 without the noise floor), and a glitch that sets the range takes its block's precision (furnace with dropouts: 1.1% of span against 0.32%). A known span fixes both, and so does an absolute max_error guard (next).
11. Swinging-door archives as input prune further, depending on what the archive kept: a tag whose CompDev is below its noise (flow, motor current: 1,300-3,000 archived points per hour) drops to 0.6-6% of the archive at the same settings, a smooth tag (temperature, pH: ~330/h) to 2-11%, and an archive that already has two points per hour stays as it is.
12. max_error only adds points: the max_error pass splits each line between the rmse pass's points that strays further than max_error from the scans by farthest reach: from each anchor, the line to the farthest scan it can reach while every scan between stays within max_error. Swinging door's rule (the line ends at the first scan the chord can't reach) keeps 1.1-5× as many points on the noisy signals (vibration 176 against 36 per hour, batch 73 against 23, temperature 766 against 509), the exact minimum 4% fewer overall at about 38× the time (13 against 490 µs per block, up to 8.4 ms). At the same guarantee as swinging door (CompDev = max_error / 2, since at CompDev = max_error its line strays up to 1.6-2× that), fluxprune keeps fewer points on 12 of the 18 signals (batch 23 against 228 per hour, vibration 36 against 422, temperature 509 against 1,136, grid frequency 282 against 597) and as many on two; more only where the rmse pass already wanted more than the guard needs (the quiet level's dither: 19 against 2). A max_error below a signal's noise keeps most of the scans, as swinging door does (motor current: 3,160 per hour): at max_error = σ about half the scans, at 0.6σ two thirds, at 2.5σ an eighth, so prune() warns below σ (the noise floor's estimate). max_points (here 360 per hour) caps that. The budget goes in a fixed order: the required points; then max_error, if it can be met within the cap, with the rmse pass taking what is left (its least significant points give way first, by a bisection on their number); and if it can't, max_error relaxed to about the tightest bound the cap allows (a bisection over the max_error pass), with no points from the rmse pass. The max_error pass always comes last, since adding a point can make the error worse. The cap bound only on the five noise-dominated signals; in their worst block the bound reached is 1.2× max_error for temperature, 1.3× for pH, 2.1× for white noise, 2.7× for flow and 11× for motor current, whose noise is five times max_error. Measured and not adopted: splitting the worst segment at its worst point when the cap binds (1.3-1.7× larger errors: it anchors on noise spikes); the max_error pass first and ranking again with its points fixed (the same RMSE at the same number of points, 3-5× slower); a secant search for the relaxed bound (9.4 max_error passes on average against 12.8, but up to 28 against 14); trying every number of the rmse pass's points instead of bisecting (0.4% lower RMSE on average).
13. Refit (refit=True): least-squares values at the same kept times, the required points pinned to their samples, lower the RMSE by about a tenth overall, almost all of it on smooth or step-like signals (sine, compressor, batch: 0.5-0.8×) where a chord cuts a curve's corner; on noisy ones by 1-3%. It costs one O(n) tridiagonal solve. The values are then no longer readings, and it doesn't mix with max_error: a least-squares line through noise moves away from the scans that set the bound, so max_error still holds in only 41% of the blocks (none on the noisy signals, all on the smooth or quiet ones). It stays an option to measure on real data. Choosing the times and the values together (a free-knot fit, or Imai and Iri's 1986 fewest-segments algorithm for max_error with corners off the samples) could gain more and wasn't tried.

The API. prune(t, x) returns the kept times and values, the RMSE and largest error they leave, and rmse_met, max_error_met and max_points_met. The rmse pass is the default (error_per_point: an exchange rate, best chosen as the RMSE one would accept at a number of points divided by that number, θ = Y / X; the error relative to each block's range and read above its white noise, noise_floor=True). Its default is 0.1% at a tenth of the input's points, θ = 0.001 / (n / 10) (2.8·10⁻⁶ for 1 h of 1 s scans; ~4% of the scans on this corpus, the median block 2%): scaled by the length, it keeps about the same density in long blocks, but fewer points per hour at a slower sampling rate. Two optional guards bound it: max_points, a hard cap, and max_error, the largest error of any scan in value units, which also takes care of quiet blocks, glitches and the block length for a configured signal. θ = 0 with max_points keeps the best max_points; θ = ∞ with max_error runs the max_error pass alone. A run of non-finite values keeps its first point and the finite points around it (a forward hold), past max_points if need be. The other rules on this page (count, tolerance, balance, ε raised to the noise, marginal, knee) are experiments in tslab/prune/rules.py.