method: Either standard or pruning, specifies the algorithm used. The default is pruning.

metric: One of canberra, chebyshev, entropy, euclidean, and taxicab, specifies the metric used when computing the optimal path. The default is taxicab.

radius: Either a non-negative integer or infinity, specifies the index radius used when computing the optimal path. The default is infinity.

unwarpedplotoptions: Additional plot options to be passed when creating the plot(s) of the original signals. The default is [].

unwarpedplotimaginaryoptions: Additional plot options to be passed when creating the plot of the imaginary parts of the original signals when they are complex. Note unwarpedplotoptions is applied first, followed by unwarpedplotimaginaryoptions. The default is [].

unwarpedplotrealoptions: Additional plot options to be passed when creating the plot of the real parts of the original signals when they are complex. Note unwarpedplotoptions is applied first, followed by unwarpedplotrealoptions. The default is [].

warpedplotoptions: Additional plot options to be passed when creating the plot(s) of the time-warped signals. The default is [].

warpedplotimaginaryoptions: Additional plot options to be passed when creating the plot of the imaginary parts of the time-warped signals when they are complex. Note warpedplotoptions is applied first, followed by warpedplotimaginaryoptions. The default is [].

warpedplotrealoptions: Additional plot options to be passed when creating the plot of the real parts of the time-warped signals when they are complex. Note warpedplotoptions is applied first, followed by warpedplotrealoptions. The default is [].

warpingpathplotoptions: Additional plot options to be passed when creating the plot of the time-warping path. The default is [].

warpingvectorsplotoptions: Additional plot options to be passed when creating the plot of the time-warping Vectors. The default is [].

output: The type of output. Let $X$ and $Y$ be, respectively, signal1 and signal2, and let  $m$ and $n$ be their respective sizes. The supported options are:

costmatrix: Matrix, of datatype float[8], with element $C_{i,j}$ representing the cost (with respect to metric) of matching $X_i$ with $Y_j$.

cost: The cost of matching $X_m$ to $Y_n$, that is, $C_{m,n}$, where $C$ is the cost Matrix.

rmse: The root-mean-square (RMS) error between $U$ (the time-warped version of $X$) and $V$ (the time-warped version of $Y$).

signal1: Vector, of size $m$ and datatype float[8] or complex[8], containing the first original signal $X$.

signal2: Vector, of size $n$ and datatype float[8] or complex[8], containing the second original signal $Y$.

size: The size $k$ of the time-warped signals.

unwarpedplot: Plot of the original signals.

warpedplot: Plot of the time-warped signals.

warpedsignal1: Vector, of size $k$ and datatype float[8] or complex[8], containing the first time-warped signal $U$.

warpedsignal2: Vector, of size $k$ and datatype float[8] or complex[8], containing the second time-warped signal $V$.

warpingpathplot: Plots of the path which time-warps $X$ to $U$ and $Y$ to $V$ and the time-warping Vectors $G$ and $H$.

warpingvector1: Vector, of size $k$ and datatype integer[4], containing the indices $G$ of $X$ (with repeats) which are used to create $U$.

warpingvector2: Vector, of size $k$ and datatype integer[4], containing the indices $H$ of $Y$ (with repeats) which are used to create $V$.

record: Returns a record with the previous options.

list of any of the above options: Returns an expression sequence with the corresponding outputs, in the same order.

The default is [warpedsignal1,warpedsignal2].

The DynamicTimeWarping command takes two signals $X$ and $Y$, of respective size $m$ and $n$, and determines the time-warped signals $U$ and $V$, both of some common size $k$, which are closest with respect to the given metric.

To match signals, the DynamicTimeWarping command inserts zero or more successive copies of every sample for each signal in such a way that the time-warped signals have the same length and the error between them (as measured by metric) is as small as possible. Note that if two signals are identical except for the number of copies of successive samples, then they can be matched exactly. More precisely, the command "warps" $X$ into $U$ and $Y$ into $V$ by computing Vectors of indices $G$ and $H$, both of the same length $k$ which satisfy $G_1=1$, $G_k=m$, $H_1=1$, $H_k=n$, and $G_{i+1}-G_i\in \left\{0\,1\right\}$ and $H_{i+1}-H_i\in \left\{0\,1\right\}$ for each $i$.

For the signals $X$ and $Y$, both require two or more elements each, and all the elements must be defined and finite.

For the algorithm to work, the signals need to agree at their endpoints, that is, $X_1=Y_1$ and $X_m=Y_n$. If the passed signal do not already match at their endpoints, the values there are averaged, that is, $X_1$ and $Y_1$ are replaced with $\frac{X_1}{2}+\frac{Y_1}{2}$, and $X_m$ and $Y_n$ are replaced with $\frac{X_m}{2}+\frac{Y_n}{2}$.

When method=standard, the regular algorithm for Dynamic Time Warping (DTW), based on techniques of Dynamic Programming, is used:

Construct the $m$-by-$n$ cost Matrix $C$, with element $C_{i,j}$ representing the cost of matching $X_i$ with $Y_j$. First, set each element to infinity. Then, recursively take $C_{i,j}=d\left(X_i\&comma;Y_j\right)+\mathrm{\mu }$, where $d\left(x\&comma;y\right)$ is the given metric, and $\mathrm{\mu }=0$ when $i=1$ and $j=1$, $\mathrm{\mu }=C_{i-1,1}$ when $1<i$ and $j=1$, $\mathrm{\mu }=C_{1,j-1}$ when $i=1$ and $1<j$, and $\mathrm{\mu }=\min \left(C_{i-1,j-1}\&comma;C_{i-1,j}\&comma;C_{i,j-1}\right)$ when $1<i$ and $1<j$. The value of $C_{m,n}$ is the optimal cost of the best match between $X$ and $Y$.

Construct the time-warping vectors $G$ and $H$, which store the indices for the optimal path. Starting at the end, namely $\left[m\&comma;n\right]$, for each index $\left[i\&comma;j\right]$, take $\left[p\&comma;q\right]$ to be the index pair which gives the smallest value in $\left[C_{i-1,j-1}\&comma;C_{i,j-1}\&comma;C_{i-1,j}\right]$, and append $p$ to $G$ and $q$ to $H$. Continue this process recursively until index pair $\left[1\&comma;1\right]$ is reached.

Compute the time-warped signals, U=X[G] and V=Y[H].

When method=pruning, the Pruning Method is employed, which is a variation of the above method whereby index pairs are pruned (skipped) during construction of the cost Matrix when the values are too large for the pairs to be a part of the optimal path. This method is exact, in the sense that the optimal path found is the same as for the standard method, and tends to execute a fair bit faster than the standard method. Note that when this method is used, the cost Matrix will (likely) still have elements that are infinity, corresponding to index pairs that have been pruned.

Let $\mathrm{\rho }$ be the larger of $\left|m-n\right|$ and the value of radius. For a given index $i$, $C_{i,j}$ is computed only for indices $j$ that satisfy $\left|i-j\right|\le \mathrm{\rho }$. The $\left|m-n\right|$ component of $\mathrm{\rho }$ is needed to ensure that the index pair $\left[m\&comma;n\right]$ can be reached. The method is inexact, in the sense that the optimal path found is (likely) not the same as for the standard method, with a larger total cost for the optimal path. Note that when this method is used with a lower value of $\mathrm{\rho }$, the cost Matrix will (likely) still have elements that are infinity, corresponding to index pairs that fall outside of the window.

The metric option is used by the optimizer to determine the optimal match for the two signals. Consider two Vectors $A$ and $B$, both of size $p$. For the error between them, we have a few options. See below.

For metric=canberra:

For metric=chebyshev:

For metric=entropy, which requires that $A$ and $B$ both have real and positive elements:

For metric=euclidean:

For metric=taxicab:

Maple attempts to coerce signal1 and signal2 to 1-D Vectors that are either both of float[8] datatype or both of complex[8] datatype, and an error is thrown if this is not possible. For this reason, it is most efficient for the passed input to use the appropriate datatypes.

The inputs signal1 and signal2 cannot have an indexing function, and must use rectangular storage.

The DynamicTimeWarping command is not thread safe.

$\mathrm{with}\left(\mathrm{SignalProcessing}\right)\&colon;$

Silva, Diego F., and Gustavo E.A.P.A. Batista. "Speeding up all-pairwise dynamic time warping matrix calculation". Proceedings of the 2016 SIAM International Conference on Data Mining, pp. 837-845. Society for Industrial and Applied Mathematics, 2016.

Starting with Maple 2023, external C code is used for the auxiliary procedures that were formerly implemented in Maple and could be compiled by passing the compiled option. The compiled option is now deprecated, but it is still accepted for backwards compatibility.

The SignalProcessing[DynamicTimeWarping] command was introduced in Maple 2022.

For more information on Maple 2022 changes, see Updates in Maple 2022.

The SignalProcessing[DynamicTimeWarping] command was updated in Maple 2023.