Construct a TimeVector from a list.

Set the signal value, with a discontinuity. See NOTE [signal-discontinuity].

TimeVectors should be sorted by the X value. Return warnings for where that's not true.

This is a merge where the vectors to the right will win in the case of overlap.

This is a merge where the vectors to the left will win in the case of overlap.

When signals are merge_leftd, the later one overrides the first one. This is the other way: the first one will override the second.

Same as sample_at, except don't return the X.

Find the sample at or before X. Nothing if the X is before the first sample.

Find the sample before the given X.

Samples at and above the given time.

Descending samples, starting below the time.

Shift the signal in time.

Truncate a signal so it doesn't include the given X - RealTime.eta. It's just a view of the old signal, so it doesn't allocate a new signal.

Like drop_before_strict, except if there is no sample at x, keep one sample before it to preserve the value at x. If there are multiple samples at x, drop all but the last one. This is because they indicate a discontinuity, but if you don't care about the previous value, then you don't need the discontinuity.

The reverse of drop_at_after: trim a signal's head up until, but not including, the given X.

Like drop_before_strict, but also drop samples at the X.

Return samples to set the value at start and until end. This means samples start <= t < end, along with one < start if necessary to set the initial value, and the end sample if start == end.

A map that can return error msgs.

Combine two vectors with the given function. They will be resampled so they have samples at the same time.

Polymorphic variant of sig_op.

The signature is specialized to Boxed since you might as well use sig_op for Unboxed vectors.

Find samples whose sx is <= the previous X.

Given a line defined by the two points, find the y at the given x. Crashes if called on a vertical line (y0==y1). Yeah, it's inconsistent with x_at.

Given a line defined by the two points, find the x at the given y.

Binary search for the highest index of the given X. So the next value is guaranteed to be >X, if it exists. Return -1 if x is before the first element. RealTime.eta is added to x, so a sample that's almost the same will still be considered a match.

bsearch_below, but if you use it with take, it includes the first element ==x. TODO not sure how to explain it.

Search for the last index or -1 if the first sample is alreadyx.

Binary search for the index of the first element that is >x, or one past the end of the vector.

Binary search for the index of the first element ==x, or the last one <x. So it will be <=x, or one past the end of the vector. If you ues it with take, it's everything <x.

O(n) Convert a vector to a list.

O(n) Check if all elements satisfy the predicate.

Examples

>>> import qualified Data.Vector as V
>>> V.all even $ V.fromList [2, 4, 12]
True
>>> V.all even $ V.fromList [2, 4, 13]
False
>>> V.all even (V.empty :: V.Vector Int)
True

O(n) Left fold with strict accumulator.

O(1) Yield all but the first n elements without copying. The vector may contain less than n elements, in which case an empty vector is returned.

O(1) Yield the first n elements without copying. The vector may contain less than n elements, in which case it is returned unchanged.

O(1) Unsafe indexing without bounds checking.

O(1) Test whether a vector is empty.

O(1) Yield the length of the vector.