IntervalSets.Interval Method

IntervalSets.Interval(x::AbstractTimeSeries)

Returns an interval representing the range of the AbstractTimeSeries x.

Examples

julia> using IntervalSets;
julia> t = 1:100;
julia> x = rand(100);
julia> ts = TimeSeries(t, x);
julia> IntervalSets.Interval(ts) == (1..100)

source

TimeseriesTools.UnitPower Type

UnitPower <: AbstractNormalization

A normalization that sets the total power of a signal to unity.

Fields

• dims: The dimensions to normalize over.

• p: Computed normalization parameters.

• 𝑝: A function that returns the power from a given time series.

• 𝑓: The normalization method

• 𝑓⁻¹: The inverse normalization method.

source

Base.cat Method

Base.cat(D::DimensionalData.Dimension, args...; kwargs...)

Concatenate the arrays given in args..., and give the resulting extra axis dimensions D. Note that unlike Base.cat without the first Dim argument, this increments all existing dimensions greater than dims by one (so N n×n arrays concatenated at dims=1 will result in an N×n×n array). args... can be a splatted collection of ToolsArrays, but this will give the same behaviour as if args... is a single vector of ToolsArrays; the latter is much more performant.

source

Base.step Method

step(x::RegularTimeSeries)

Returns the step size (time increment) of a regularly sampled RegularTimeSeries.

Examples

julia> t = 1:100;
julia> x = rand(100);
julia> rts = TimeSeries(t, x);
julia> step(rts) == 1

source

TimeseriesTools.align Method

align(x::AbstractDimArray, ts, dt; dims = 1)

Align a DimArray x to each of a set of dimension values ts, selecting a window given by dt centered at each element of ts. dt can be a two-element vector/tuple, or an interval. The dims argument specifies the dimension along which the alignment is performed. Each element of the resulting DimArray is an aligned portion of the original x.

source

TimeseriesTools.buffer Method

buffer(x::RegularTimeSeries, n::Integer, p::Integer; kwargs...)

Buffer a time series x with a given window length and overlap between successive buffers.

Arguments

• x: The regular time series to be buffered.

• n: The number of samples in each buffer.

• p: The number of samples of overlap betweeen the buffers.

  • 0 indicates no overlap

  • +2 indicates 2 samples of overlap between successive buffers

  • -2 indicates 2 samples of gap between buffers

See also: window, delayembed, coarsegrain

source

TimeseriesTools.centralderiv! Method

centralderiv!(x::RegularTimeSeries; kwargs...)

Compute the central derivative of a regular time series x, in-place. See centraldiff! for available keyword arguments.

source

TimeseriesTools.centralderiv Method

centralderiv(x::AbstractTimeSeries)

Compute the central derivative of a time series x. See centraldiff for available keyword arguments. Also c.f. centralderiv!.

source

TimeseriesTools.centraldiff! Method

centraldiff!(x::RegularTimeSeries; dims=𝑡, grad=-)

Compute the central difference of a regular time series x, in-place. The first and last elements are set to the forward and backward difference, respectively. The dimension to perform differencing over can be specified as dims, and the differencing function can be specified as grad (defaulting to the euclidean distance, -)

source

TimeseriesTools.centraldiff Method

centraldiff(x::RegularTimeSeries; dims=𝑡, grad=-)

Compute the central difference of a regular time series x. The first and last elements are set to the forward and backward difference, respectively. The dimension to perform differencing over can be specified as dims, and the differencing function can be specified as grad (defaulting to the euclidean distance, -) See centraldiff!.

source

TimeseriesTools.coarsegrain Method

coarsegrain(X::AbstractArray; dims = nothing, newdim=ndims(X)+1)

Coarse-grain an array by taking every second element over the given dimensions dims and concatenating them in the dimension newdim. dims are coarse-grained in sequence, from last to first. If dims is not specified, we iterate over all dimensions that are not newdim. If the array has an odd number of slices in any dims, the last slice is discarded. This is more flexibile than the conventional, mean-based definition of coarse graining: it can be used to generate coarse-grained distributions from an array. To recover this conventional mean-based coarse-graining:

    C = coarsegrain(X)
    mean(C, dims=ndims(C))

source

TimeseriesTools.delayembed Function

delayembed(x::UnivariateRegular, n::Integer, τ::Integer, p::Integer=1; kwargs...)

Delay embed a univariate time series x with a given dimension n, delay τ, and skip length of p

Arguments

• x: The regular time series to be delay embedded.

• n: The embedding dimension, i.e., the number of samples in each embedded vector.

• τ: The number of original sampling periods between each sample in the embedded vectors.

• p: The number of samples to skip between each successive embedded vector.

See also: buffer, window

source

TimeseriesTools.duration Method

duration(x::AbstractTimeSeries)

Returns the duration of the AbstractTimeSeries x.

Examples

julia> t = 1:100;
julia> x = rand(100);
julia> ts = TimeSeries(t, x);
julia> TimeseriesTools.duration(ts) == 99

source

TimeseriesTools.rectifytime Method

rectifytime(X::IrregularTimeSeries; tol = 6, zero = false)

Rectifies the time values of an IrregularTimeSeries. Checks if the time step of the input time series is approximately constant. If it is, the function rounds the time step and constructs a RegularTimeSeries with range time indices. If the time step is not approximately constant, a warning is issued and the rectification is skipped.

Arguments

• X::IrregularTimeSeries: The input time series.

• tol::Int: The number of significant figures for rounding the time step. Default is 6.

• zero::Bool: If true, the rectified time values will start from zero. Default is false.

source

TimeseriesTools.samplingperiod Method

samplingperiod(x::RegularTimeSeries)

Returns the sampling period (step size) of a regularly sampled RegularTimeSeries.

Examples

julia> t = 1:100;
julia> x = rand(100);
julia> rts = TimeSeries(t, x);
julia> samplingperiod(rts) == 1

source

TimeseriesTools.samplingrate Method

samplingrate(x::RegularTimeSeries)

Returns the sampling rate (inverse of the step size) of a regularly sampled RegularTimeSeries.

Examples

julia> t = 1:100;
julia> x = rand(100);
julia> rts = TimeSeries(t, x);
julia> samplingrate(rts) == 1

source

TimeseriesTools.stitch Method

stitch(x, args...)

Stitch multiple time series together by concatenatign along the time dimension generating new contiguous time indices. The time series must be of the same type (UnivariateRegular, MultivariateRegular, or AbstractArray), and the sampling period and dimensions of the data arrays must match. If the arguments are `MultivariateRegular, they must have the same dimensions (except for the time dimension).

Arguments

• X: The first time series.

• args...: Additional time series.

Returns

• A new time series containing the concatenated data.

source

TimeseriesTools.times Method

times(x::AbstractTimeSeries)

Returns the time indices of the AbstractTimeSeries x.

Examples

julia> t = 1:100;
julia> x = rand(100);
julia> ts = TimeSeries(t, x);
julia> times(ts) == t

source

TimeseriesTools.window Function

window(x::RegularTimeSeries, n::Integer, p::Integer; kwargs...)

Window a time series x with a given window length and step between successive windows.

Arguments

• x: The regular time series to be windows.

• n: The number of samples in each window.

• p: The number of samples to slide each successive window.

See also: buffer, delayembed, coarsegrain

source