simulate_timewarp: Simulate time warp

In IncDTW: Incremental Calculation of Dynamic Time Warping

Simulate time warp

Description

Simulate a time warp for a given time series.

Usage

simulate_timewarp(x, stretch = 0, compress = 0, 
                  stretch_method = insert_linear_interp,
                  p_index = "rnorm", p_number = "rlnorm", 
                  p_index_list = NULL, p_number_list = NULL, 
                  preserve_length = FALSE, seed = NULL, ...) 


insert_const(x, ix, N, const = NULL)

insert_linear_interp(x, ix, N)

insert_norm(x, ix, N, mean = 0, sd = 1)

insert_linear_norm(x, ix, N, mean = 0, sd = 1)

Arguments

x	time series, vector or matrix
stretch	numeric parameter for stretching the time series. stretch >= 0, see details
compress	numeric parameter for compressing the time series. compress >= 0 & compress < 1, see details
stretch_method	function, either one of (insert_const, insert_linear_interp, insert_norm, insert_linear_norm), or any user defined function that needs the parameters x (univariate time series as vector), ix (index where to insert), N (number of observations to insert) and any other arguments required for that function. See Details.
p_index	string, distribution for simulating the indices where to insert simulated observations, e.g. "rnorm", "runif", etc.
p_number	string, distribution for simulating the number of observations to insert per index, e.g. "rnorm", "runif", etc.
p_index_list	list of named parameters for the distribution p_index
p_number_list	list of named parameters for the distribution p_number
preserve_length	logical, if TRUE (default = FALSE) then the length of the return time series is the same as before the warping, so the compression and stretching do not change the length of the time series, nevertheless perform local warpings
seed	set a seed for reproducible results
...	named parameters for the stretch_method
ix	index of x where after which to insert
N	number of simulated observations to insert at index ix
const	the constant to be inserted, if NULL (default), then const <- x[ix]
mean	mean for rnorm
sd	sd for rnorm

Details

The different distributions p_index and p_number also determine the behavior of the warp. A uniform distribution for p_number more likely draws high number than e.g. log-normal distributions with appropriate parameters. So, a uniform distribution more likely simulates fewer, but longer warps, that is points of time where the algorithm inserts simulations.

The algorithm stretches by randomly selecting an index between 1 and the length of the time series. Then a number of observations to be inserted is drawn out of the range 1 to the remaining number of observations to be inserted. These observations are inserted. Then the algorithm starts again with drawing an index, drawing a number of observations to be inserted, and proceeds until the requested time series length is achieved.

The algorithm for compressing works analogous, except it simply omits observations instead of linear interpolation.

The parameter stretch describes the ratio how much the time series x is stretched: e.g. if compress = 0 and ...

• stretch = 0 then length(x_new) = length(x), or

• stretch = 0.1 then length(x_new) = length(x) * 1.1, or

• stretch = 1 then length(x_new) = length(x) * 2

The parameter compress describes the ratio how much the time series x is compressed: e.g. if stretch = 0 and ...

• compress = 0 then length(x_new) = length(x), or

• compress = 0.2 then length(x_new) = length(x) * 0.8

There are four functions to chose from to insert new simulated observations. You can also define your own function and apply this one. The four functions to chose from are:

• insert a constant, either a constant defined by the user via the input parameter const, or if const = NULL, then the last observation of the time series where the insertion starts is set as const

• insert linear interpolated observations (default)

• insert a constant with gaussian noise

• insert linear interpolated observations and add gaussian noise.

For the methods with Gaussian noise the parameters mean and sd for rnorm can be set at the function call of simulate_timewarp().

Value

A time warped time series

Examples

## Not run: 
#--- Simulate a time warped version of a time series x
set.seed(123)
x <- cumsum(rnorm(100))
x_warp <- simulate_timewarp(x, stretch = 0.1, compress = 0.2, seed = 123) 
plot(x, type = "l")
lines(x_warp, col = "red")


#--- Simulate a time warp of a multivariate time series
y <- matrix(cumsum(rnorm(10^3)), ncol = 2)
y_warp <- simulate_timewarp(y, stretch = 0.1, compress = 0.2, seed = 123) 
plot(y[,1], type = "l")
lines(y_warp[,1], col = "red")


#--- Stretchings means to insert at new values at randomly 
# selected points of time. Next the new values are set as constant NA,
# and the points of time simulated uniformly:
y_warp <- simulate_timewarp(y, stretch = 0.2, p_number = "runif", p_index = "runif",
                            stretch_method = insert_const, 
                            const = NA)
matplot(y_warp, type = "l")


# insert NA and simulate the points of time by log normal
y_warp <- simulate_timewarp(y, stretch = 0.2, p_number = "rlnorm", 
                            p_number_list = list(meanlog = 0, sdlog = 1),
                            stretch_method = insert_const, 
                            const = NA)
matplot(y_warp, type = "l")


# insert linear interpolation
y_warp <- simulate_timewarp(y, stretch = 0.2, p_number = "rlnorm", 
                            stretch_method = insert_linear_interp)
matplot(y_warp, type = "l")


# insert random walk with gaussian noise
y_warp <- simulate_timewarp(y, stretch = 0.2, p_number = "rlnorm", 
                            stretch_method = insert_norm,
                            sd = 1, mean = 0)
matplot(y_warp, type = "l")


# insert constant, only 1 observation per random index
y_warp <- simulate_timewarp(y, stretch = 0.2, p_number = "runif", p_index = "runif",
                            p_number_list = list(min = 1, max = 1),   
                            stretch_method = insert_const)
matplot(y_warp, type = "l")


# insert by customized insert function
my_stretch_method <- function(x, ix, N, from, to){
   c(x[1:ix], 
     sin(seq(from = from, to = to, length.out = N)) + x[ix],
     x[(ix + 1):length(x)])
}
y_warp <- simulate_timewarp(y, stretch = 0.5, p_number = "rlnorm", 
                            stretch_method = my_stretch_method,
                            from = 0, to = 4 * pi)
matplot(y_warp, type = "l")


## End(Not run)

IncDTW documentation built on March 18, 2022, 6:43 p.m.