Merge branch 'master' of https://github.com/GUDHI/gudhi-devel into extended_persistence

11 files changed, 312 insertions, 87 deletions

diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 42cf4246..7be14bce 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -1319,6 +1319,8 @@ class Simplex_tree {
    * \post Some simplex tree functions require the filtration to be valid. `make_filtration_non_decreasing()`
    * function is not launching `initialize_filtration()` but returns the filtration modification information. If the
    * complex has changed , please call `initialize_filtration()` to recompute it.
+   * 
+   * If a simplex has a `NaN` filtration value, it is considered lower than any other defined filtration value.
    */
   bool make_filtration_non_decreasing() {
     bool modified = false;
@@ -1349,7 +1351,9 @@ class Simplex_tree {
                                                               });
 
       Filtration_value max_filt_border_value = filtration(*max_border);
-      if (simplex.second.filtration() < max_filt_border_value) {
+      // Replacing if(f<max) with if(!(f>=max)) would mean that if f is NaN, we replace it with the max of the children.
+      // That seems more useful than keeping NaN.
+      if (!(simplex.second.filtration() >= max_filt_border_value)) {
         // Store the filtration modification information
         modified = true;
         simplex.second.assign_filtration(max_filt_border_value);
diff --git a/src/Simplex_tree/test/CMakeLists.txt b/src/Simplex_tree/test/CMakeLists.txt
index 8b9163f5..cf2b0153 100644
--- a/src/Simplex_tree/test/CMakeLists.txt
+++ b/src/Simplex_tree/test/CMakeLists.txt
@@ -28,3 +28,9 @@ if (TBB_FOUND)
   target_link_libraries(Simplex_tree_ctor_and_move_test_unit ${TBB_LIBRARIES})
 endif()
 gudhi_add_boost_test(Simplex_tree_ctor_and_move_test_unit)
+
+add_executable ( Simplex_tree_make_filtration_non_decreasing_test_unit simplex_tree_make_filtration_non_decreasing_unit_test.cpp )
+if (TBB_FOUND)
+  target_link_libraries(Simplex_tree_make_filtration_non_decreasing_test_unit ${TBB_LIBRARIES})
+endif()
+gudhi_add_boost_test(Simplex_tree_make_filtration_non_decreasing_test_unit)
diff --git a/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
new file mode 100644
index 00000000..4697ec05
--- /dev/null
+++ b/src/Simplex_tree/test/simplex_tree_make_filtration_non_decreasing_unit_test.cpp
@@ -0,0 +1,148 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#include <iostream>
+#include <limits>  // for NaN
+#include <cmath>  // for isNaN
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "simplex_tree_make_filtration_non_decreasing"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+//  ^
+// /!\ Nothing else from Simplex_tree shall be included to test includes are well defined.
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+typedef boost::mpl::list<Simplex_tree<>, Simplex_tree<Simplex_tree_options_fast_persistence>> list_of_tested_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::cout << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+
+  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
+  // to 1.0
+  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+  
+  // Inserted simplex:
+  //    1   6
+  //    o---o
+  //   /X\7/
+  //  o---o---o---o
+  //  2   0   3\X/4
+  //            o
+  //            5
+  
+  std::cout << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  
+  // Copy original simplex tree
+  typeST st_copy = st;
+
+  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({0,1,6,7}), 0.8);
+  st.assign_filtration(st.find({0,1,6}), 0.9);
+  st.assign_filtration(st.find({0,6}), 0.6);
+  st.assign_filtration(st.find({3,4,5}), 1.2);
+  st.assign_filtration(st.find({3,4}), 1.1);
+  st.assign_filtration(st.find({4,5}), 1.99);
+  
+  std::cout << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_copy);
+
+  // Other simplex tree
+  typeST st_other;
+  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
+  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
+  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
+  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
+
+  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
+  st.assign_filtration(st.find({2}), 3.0);
+  // By modifying just the simplex {2}
+  // {0,1,2}, {1,2} and {0,2} will be modified
+  
+  std::cout << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other);
+
+  // Modify specific values for st still to be non-decreasing
+  st.assign_filtration(st.find({0,1,2}), 10.0);
+  st.assign_filtration(st.find({0,2}), 9.0);
+  st.assign_filtration(st.find({0,1,6,7}), 50.0);
+  st.assign_filtration(st.find({0,1,6}), 49.0);
+  st.assign_filtration(st.find({0,1,7}), 48.0);
+  // Other copy simplex tree
+  typeST st_other_copy = st;
+  
+  std::cout << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
+  BOOST_CHECK(!st.make_filtration_non_decreasing());
+  BOOST_CHECK(st == st_other_copy);
+  
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(make_filtration_non_decreasing_on_nan_values, typeST, list_of_tested_variants) {
+  typeST st;
+
+  st.insert_simplex_and_subfaces({2, 1, 0}, std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 0},    std::numeric_limits<double>::quiet_NaN());
+  st.insert_simplex_and_subfaces({3, 4, 5}, std::numeric_limits<double>::quiet_NaN());
+  
+  /* Inserted simplex:     */
+  /*    1                  */
+  /*    o                  */
+  /*   /X\                 */
+  /*  o---o---o---o        */
+  /*  2   0   3\X/4        */
+  /*            o          */
+  /*            5          */
+
+  std::cout << "SPECIFIC CASE:" << std::endl;
+  std::cout << "Insertion with NaN values does not ensure the filtration values are non decreasing" << std::endl;
+  st.make_filtration_non_decreasing();
+
+  std::cout << "Check all filtration values are NaN" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(std::isnan(st.filtration(f_simplex)));
+  }
+
+  st.assign_filtration(st.find({0}), 0.);
+  st.assign_filtration(st.find({1}), 0.);
+  st.assign_filtration(st.find({2}), 0.);
+  st.assign_filtration(st.find({3}), 0.);
+  st.assign_filtration(st.find({4}), 0.);
+  st.assign_filtration(st.find({5}), 0.);
+
+  std::cout << "Check make_filtration_non_decreasing is modifying the simplicial complex" << std::endl;
+  BOOST_CHECK(st.make_filtration_non_decreasing());
+  
+  std::cout << "Check all filtration values are now defined" << std::endl;
+  for (auto f_simplex : st.complex_simplex_range()) {
+    BOOST_CHECK(!std::isnan(st.filtration(f_simplex)));
+  }
+}
\ No newline at end of file
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 58bfa8db..e739ad0a 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -791,90 +791,6 @@ BOOST_AUTO_TEST_CASE(non_contiguous) {
   BOOST_CHECK(++i == std::end(b));
 }
 
-BOOST_AUTO_TEST_CASE(make_filtration_non_decreasing) {
-  std::cout << "********************************************************************" << std::endl;
-  std::cout << "MAKE FILTRATION NON DECREASING" << std::endl;
-  typedef Simplex_tree<> typeST;
-  typeST st;
-
-  st.insert_simplex_and_subfaces({2, 1, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  
-  /* Inserted simplex:     */
-  /*    1                  */
-  /*    o                  */
-  /*   /X\                 */
-  /*  o---o---o---o        */
-  /*  2   0   3\X/4        */
-  /*            o          */
-  /*            5          */
-
-  std::cout << "Check default insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-
-  // Because of non decreasing property of simplex tree, { 0 } , { 1 } and { 0, 1 } are going to be set from value 2.0
-  // to 1.0
-  st.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-  
-  // Inserted simplex:
-  //    1   6
-  //    o---o
-  //   /X\7/
-  //  o---o---o---o
-  //  2   0   3\X/4
-  //            o
-  //            5
-  
-  std::cout << "Check default second insertion ensures the filtration values are non decreasing" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  
-  // Copy original simplex tree
-  typeST st_copy = st;
-
-  // Modify specific values for st to become like st_copy thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({0,1,6,7}), 0.8);
-  st.assign_filtration(st.find({0,1,6}), 0.9);
-  st.assign_filtration(st.find({0,6}), 0.6);
-  st.assign_filtration(st.find({3,4,5}), 1.2);
-  st.assign_filtration(st.find({3,4}), 1.1);
-  st.assign_filtration(st.find({4,5}), 1.99);
-  
-  std::cout << "Check the simplex_tree is rolled back in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_copy);
-
-  // Other simplex tree
-  typeST st_other;
-  st_other.insert_simplex_and_subfaces({2, 1, 0}, 3.0);  // This one is different from st
-  st_other.insert_simplex_and_subfaces({3, 0}, 2.0);
-  st_other.insert_simplex_and_subfaces({3, 4, 5}, 2.0);
-  st_other.insert_simplex_and_subfaces({0, 1, 6, 7}, 1.0);
-
-  // Modify specific values for st to become like st_other thanks to make_filtration_non_decreasing
-  st.assign_filtration(st.find({2}), 3.0);
-  // By modifying just the simplex {2}
-  // {0,1,2}, {1,2} and {0,2} will be modified
-  
-  std::cout << "Check the simplex_tree is repaired in case of decreasing filtration values" << std::endl;
-  BOOST_CHECK(st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other);
-
-  // Modify specific values for st still to be non-decreasing
-  st.assign_filtration(st.find({0,1,2}), 10.0);
-  st.assign_filtration(st.find({0,2}), 9.0);
-  st.assign_filtration(st.find({0,1,6,7}), 50.0);
-  st.assign_filtration(st.find({0,1,6}), 49.0);
-  st.assign_filtration(st.find({0,1,7}), 48.0);
-  // Other copy simplex tree
-  typeST st_other_copy = st;
-  
-  std::cout << "Check the simplex_tree is not modified in case of non-decreasing filtration values" << std::endl;
-  BOOST_CHECK(!st.make_filtration_non_decreasing());
-  BOOST_CHECK(st == st_other_copy);
-  
-}
-
 
 typedef boost::mpl::list<boost::adjacency_list<boost::setS, boost::vecS, boost::directedS,
                                                boost::property<vertex_filtration_t, double>,
diff --git a/src/cmake/modules/GUDHI_third_party_libraries.cmake b/src/cmake/modules/GUDHI_third_party_libraries.cmake
index 6db2c76b..2d010483 100644
--- a/src/cmake/modules/GUDHI_third_party_libraries.cmake
+++ b/src/cmake/modules/GUDHI_third_party_libraries.cmake
@@ -68,7 +68,7 @@ if(CGAL_FOUND)
 endif()
 
 # For those who dislike bundled dependencies, this indicates where to find a preinstalled Hera.
-set(HERA_WASSERSTEIN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/ext/hera/geom_matching/wasserstein/include CACHE PATH "Directory where one can find Hera's wasserstein.h")
+set(HERA_WASSERSTEIN_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/ext/hera/wasserstein/include CACHE PATH "Directory where one can find Hera's wasserstein.h")
 
 option(WITH_GUDHI_USE_TBB "Build with Intel TBB parallelization" ON)
 
diff --git a/src/cmake/modules/GUDHI_user_version_target.cmake b/src/cmake/modules/GUDHI_user_version_target.cmake
index 5047252f..257d1939 100644
--- a/src/cmake/modules/GUDHI_user_version_target.cmake
+++ b/src/cmake/modules/GUDHI_user_version_target.cmake
@@ -55,7 +55,7 @@ add_custom_command(TARGET user_version PRE_BUILD COMMAND ${CMAKE_COMMAND} -E
                    copy_directory ${CMAKE_SOURCE_DIR}/src/GudhUI ${GUDHI_USER_VERSION_DIR}/GudhUI)
 
 add_custom_command(TARGET user_version PRE_BUILD COMMAND ${CMAKE_COMMAND} -E
-                   copy_directory ${CMAKE_SOURCE_DIR}/ext/hera/geom_matching/wasserstein/include ${GUDHI_USER_VERSION_DIR}/ext/hera/geom_matching/wasserstein/include)
+                   copy_directory ${CMAKE_SOURCE_DIR}/ext/hera/wasserstein/include ${GUDHI_USER_VERSION_DIR}/ext/hera/wasserstein/include)
 
 set(GUDHI_DIRECTORIES "doc;example;concept;utilities")
 
diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt
index 20e72a5f..22af3ec9 100644
--- a/src/python/CMakeLists.txt
+++ b/src/python/CMakeLists.txt
@@ -56,6 +56,7 @@ if(PYTHONINTERP_FOUND)
     # Modules that should not be auto-imported in __init__.py
     set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'representations', ")
     set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'wasserstein', ")
+    set(GUDHI_PYTHON_MODULES_EXTRA "${GUDHI_PYTHON_MODULES_EXTRA}'point_cloud', ")
 
     add_gudhi_debug_info("Python version ${PYTHON_VERSION_STRING}")
     add_gudhi_debug_info("Cython version ${CYTHON_VERSION}")
@@ -226,6 +227,7 @@ if(PYTHONINTERP_FOUND)
     file(COPY "gudhi/persistence_graphical_tools.py" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
     file(COPY "gudhi/representations" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi/")
     file(COPY "gudhi/wasserstein.py" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
+    file(COPY "gudhi/point_cloud" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gudhi")
 
     add_custom_command(
         OUTPUT gudhi.so
@@ -404,6 +406,9 @@ if(PYTHONINTERP_FOUND)
       add_gudhi_py_test(test_representations)
     endif()
 
+    # Time Delay
+    add_gudhi_py_test(test_time_delay)
+
     # Documentation generation is available through sphinx - requires all modules
     if(SPHINX_PATH)
       if(MATPLOTLIB_FOUND)
diff --git a/src/python/doc/point_cloud.rst b/src/python/doc/point_cloud.rst
index d668428a..c0d4b303 100644
--- a/src/python/doc/point_cloud.rst
+++ b/src/python/doc/point_cloud.rst
@@ -20,3 +20,11 @@ Subsampling
    :members:
    :special-members:
    :show-inheritance:
+
+TimeDelayEmbedding
+------------------
+
+.. autoclass:: gudhi.point_cloud.timedelay.TimeDelayEmbedding
+   :members:
+   :special-members: __call__
+
diff --git a/src/python/gudhi/point_cloud/__init__.py b/src/python/gudhi/point_cloud/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/python/gudhi/point_cloud/__init__.py
diff --git a/src/python/gudhi/point_cloud/timedelay.py b/src/python/gudhi/point_cloud/timedelay.py
new file mode 100644
index 00000000..f01df442
--- /dev/null
+++ b/src/python/gudhi/point_cloud/timedelay.py
@@ -0,0 +1,95 @@
+# This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+# See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+# Author(s):       Martin Royer, Yuichi Ike, Masatoshi Takenouchi
+#
+# Copyright (C) 2020 Inria, Copyright (C) 2020 Fujitsu Laboratories Ltd.
+# Modification(s):
+#   - YYYY/MM Author: Description of the modification
+
+import numpy as np
+
+
+class TimeDelayEmbedding:
+    """Point cloud transformation class.
+    Embeds time-series data in the R^d according to [Takens' Embedding Theorem]
+    (https://en.wikipedia.org/wiki/Takens%27s_theorem) and obtains the 
+    coordinates of each point.
+
+    Parameters
+    ----------
+    dim : int, optional (default=3)
+        `d` of R^d to be embedded.
+    delay : int, optional (default=1)
+        Time-Delay embedding.
+    skip : int, optional (default=1)
+        How often to skip embedded points.
+
+    Example
+    -------
+
+    Given delay=3 and skip=2, a point cloud which is obtained by embedding
+    a scalar time-series into R^3 is as follows::
+
+        time-series = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        point cloud = [[1, 4, 7],
+                       [3, 6, 9]]
+
+    Given delay=1 and skip=1, a point cloud which is obtained by embedding
+    a 2D vector time-series data into R^4 is as follows::
+
+        time-series = [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
+        point cloud = [[0, 1, 2, 3],
+                       [2, 3, 4, 5],
+                       [4, 5, 6, 7],
+                       [6, 7, 8, 9]]
+    """
+
+    def __init__(self, dim=3, delay=1, skip=1):
+        self._dim = dim
+        self._delay = delay
+        self._skip = skip
+
+    def __call__(self, ts):
+        """Transform method for single time-series data.
+
+        Parameters
+        ----------
+        ts : Iterable[float] or Iterable[Iterable[float]]
+            A single time-series data, with scalar or vector values.
+
+        Returns
+        -------
+        point cloud : n x dim numpy arrays
+            Makes point cloud from a single time-series data.
+        """
+        return self._transform(np.array(ts))
+
+    def fit(self, ts, y=None):
+        return self
+    
+    def _transform(self, ts):
+        """Guts of transform method."""
+        if ts.ndim == 1:
+            repeat = self._dim
+        else:
+            assert self._dim % ts.shape[1] == 0
+            repeat = self._dim // ts.shape[1]
+        end = len(ts) - self._delay * (repeat - 1)
+        short = np.arange(0, end, self._skip)
+        vertical = np.arange(0, repeat * self._delay, self._delay)
+        return ts[np.add.outer(short, vertical)].reshape(len(short), -1)
+
+    def transform(self, ts):
+        """Transform method for multiple time-series data.
+
+        Parameters
+        ----------
+        ts : Iterable[Iterable[float]] or Iterable[Iterable[Iterable[float]]]
+            Multiple time-series data, with scalar or vector values.
+
+        Returns
+        -------
+        point clouds : list of n x dim numpy arrays
+            Makes point cloud from each time-series data.
+        """
+        return [self._transform(np.array(s)) for s in ts]
diff --git a/src/python/test/test_time_delay.py b/src/python/test/test_time_delay.py
new file mode 100755
index 00000000..1ead9bca
--- /dev/null
+++ b/src/python/test/test_time_delay.py
@@ -0,0 +1,43 @@
+from gudhi.point_cloud.timedelay import TimeDelayEmbedding
+import numpy as np
+
+
+def test_normal():
+    # Sample array
+    ts = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    # Normal case.
+    prep = TimeDelayEmbedding()
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 2, 3])).all()
+    assert (pointclouds[1] == np.array([2, 3, 4])).all()
+    assert (pointclouds[2] == np.array([3, 4, 5])).all()
+    assert (pointclouds[3] == np.array([4, 5, 6])).all()
+    assert (pointclouds[4] == np.array([5, 6, 7])).all()
+    assert (pointclouds[5] == np.array([6, 7, 8])).all()
+    assert (pointclouds[6] == np.array([7, 8, 9])).all()
+    assert (pointclouds[7] == np.array([8, 9, 10])).all()
+    # Delay = 3
+    prep = TimeDelayEmbedding(delay=3)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 4, 7])).all()
+    assert (pointclouds[1] == np.array([2, 5, 8])).all()
+    assert (pointclouds[2] == np.array([3, 6, 9])).all()
+    assert (pointclouds[3] == np.array([4, 7, 10])).all()
+    # Skip = 3
+    prep = TimeDelayEmbedding(skip=3)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 2, 3])).all()
+    assert (pointclouds[1] == np.array([4, 5, 6])).all()
+    assert (pointclouds[2] == np.array([7, 8, 9])).all()
+    # Delay = 2 / Skip = 2
+    prep = TimeDelayEmbedding(delay=2, skip=2)
+    pointclouds = prep(ts)
+    assert (pointclouds[0] == np.array([1, 3, 5])).all()
+    assert (pointclouds[1] == np.array([3, 5, 7])).all()
+    assert (pointclouds[2] == np.array([5, 7, 9])).all()
+
+    # Vector series
+    ts = np.arange(0, 10).reshape(-1, 2)
+    prep = TimeDelayEmbedding(dim=4)
+    prep.fit([ts])
+    assert (prep.transform([ts])[0] == [[0, 1, 2, 3], [2, 3, 4, 5], [4, 5, 6, 7], [6, 7, 8, 9]]).all()