[TEMPORAL COORDINATES] add temporal coordinate. add temporal slicer test

spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py

-from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+import pandas as pd
 
+from spatio_temporal_dataset.coordinates.temporal_coordinates.abstract_temporal_coordinates import \
+    AbstractTemporalCoordinates
 
-# class TemporalCoordinates(AbstractCoordinates):
-#     pass
-#
-#
-#     @classmethod
-#     def from_nb_points(cls, nb_points, train_split_ratio: float = None, start=-1.0, end=1.0):
-#         # Sample uniformly inside the circle
-#         df = cls.df_spatial(nb_points, start, end)
-#         return cls.from_df(df, train_split_ratio)
-#
-#     @classmethod
-#     def df_spatial(cls, nb_points, start=-1.0, end=1.0):
-#         axis_coordinates = np.array(r.runif(nb_points, min=start, max=end))
-#         df = pd.DataFrame.from_dict({cls.COORDINATE_X: axis_coordinates})
-#         return df
-#
-#     @classmethod
-#     def from_nb_points(cls, nb_points, train_split_ratio: float = None, nb_time_steps=1, max_radius=1.0):
-#         assert isinstance(nb_time_steps, int) and nb_time_steps >= 1
-#         df_spatial = UniformSpatialCoordinates.df_spatial(nb_points)
-#         df_time_steps = []
-#         for t in range(nb_time_steps):
-#             df_time_step = df_spatial.copy()
-#             df_time_step[cls.COORDINATE_T] = t
-#             df_time_steps.append(df_time_step)
-#         df_time_steps = pd.concat(df_time_steps, ignore_index=True)
-#         print(df_time_steps)
-#         return cls.from_df(df=df_time_steps, train_split_ratio=train_split_ratio, slicer_class=SpatioTemporalSlicer)
+
+class TemporalCoordinates(AbstractTemporalCoordinates):
+    pass
+
+    @classmethod
+    def from_nb_temporal_steps(cls, nb_temporal_steps, train_split_ratio: float = None, start=0):
+        df = cls.df_temporal(nb_temporal_steps, start)
+        return cls.from_df(df, train_split_ratio)
+
+    @classmethod
+    def df_temporal(cls, nb_temporal_steps, start=0):
+        df = pd.DataFrame.from_dict({cls.COORDINATE_T: list(range(start, start + nb_temporal_steps))})
+        return df
\ No newline at end of file

test/test_extreme_estimator/test_estimator/test_full_estimators.py

@@ -2,7 +2,7 @@ import unittest
 from itertools import product
 
 from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
-from test.test_utils import load_test_max_stable_models, load_smooth_margin_models, load_test_1D_and_2D_coordinates, \
+from test.test_utils import load_test_max_stable_models, load_smooth_margin_models, load_test_1D_and_2D_spatial_coordinates, \
     load_test_full_estimators
 
 
@@ -13,7 +13,7 @@ class TestFullEstimators(unittest.TestCase):
 
     def setUp(self):
         super().setUp()
-        self.spatial_coordinates = load_test_1D_and_2D_coordinates(nb_points=self.nb_points)
+        self.spatial_coordinates = load_test_1D_and_2D_spatial_coordinates(nb_points=self.nb_points)
         self.max_stable_models = load_test_max_stable_models()
 
     def test_full_estimators(self):

test/test_extreme_estimator/test_estimator/test_margin_estimators.py

@@ -3,7 +3,7 @@ import unittest
 
 from extreme_estimator.estimator.margin_estimator import SmoothMarginEstimator
 from spatio_temporal_dataset.dataset.simulation_dataset import MarginDataset
-from test.test_utils import load_smooth_margin_models, load_test_1D_and_2D_coordinates
+from test.test_utils import load_smooth_margin_models, load_test_1D_and_2D_spatial_coordinates
 
 
 class TestSmoothMarginEstimator(unittest.TestCase):
@@ -13,7 +13,7 @@ class TestSmoothMarginEstimator(unittest.TestCase):
 
     def setUp(self):
         super().setUp()
-        self.coordinates = load_test_1D_and_2D_coordinates(nb_points=self.nb_points)
+        self.coordinates = load_test_1D_and_2D_spatial_coordinates(nb_points=self.nb_points)
 
     def test_smooth_margin_estimator(self):
         for coordinates in self.coordinates:

test/test_extreme_estimator/test_estimator/test_max_stable_estimators.py

 import unittest
 
-from extreme_estimator.extreme_models.max_stable_model.abstract_max_stable_model import \
-    AbstractMaxStableModelWithCovarianceFunction, CovarianceFunction
-from extreme_estimator.estimator.max_stable_estimator import MaxStableEstimator
 from spatio_temporal_dataset.dataset.simulation_dataset import MaxStableDataset
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates
-from test.test_utils import load_test_max_stable_models, load_test_1D_and_2D_coordinates, \
+from test.test_utils import load_test_max_stable_models, load_test_1D_and_2D_spatial_coordinates, \
     load_test_max_stable_estimators
 
 
@@ -16,7 +12,7 @@ class TestMaxStableEstimators(unittest.TestCase):
 
     def setUp(self):
         super().setUp()
-        self.coordinates = load_test_1D_and_2D_coordinates(nb_points=self.nb_points)
+        self.coordinates = load_test_1D_and_2D_spatial_coordinates(nb_points=self.nb_points)
         self.max_stable_models = load_test_max_stable_models()
 
     def test_max_stable_estimators(self):

test/test_spatio_temporal_dataset/test_dataset.py

@@ -3,8 +3,8 @@ import unittest
 from itertools import product
 
 from spatio_temporal_dataset.dataset.simulation_dataset import MaxStableDataset
-from test.test_utils import load_test_max_stable_models, load_test_spatial_coordinates, load_test_3D_coordinates, \
-    load_test_1D_and_2D_coordinates
+from test.test_utils import load_test_max_stable_models, load_test_spatial_coordinates, load_test_3D_spatial_coordinates, \
+    load_test_1D_and_2D_spatial_coordinates
 
 
 class TestDataset(unittest.TestCase):
@@ -13,7 +13,7 @@ class TestDataset(unittest.TestCase):
 
     def test_max_stable_dataset_R1_and_R2(self):
         max_stable_models = load_test_max_stable_models()[:]
-        coordinatess = load_test_1D_and_2D_coordinates(self.nb_points)
+        coordinatess = load_test_1D_and_2D_spatial_coordinates(self.nb_points)
         for coordinates, max_stable_model in product(coordinatess, max_stable_models):
             MaxStableDataset.from_sampling(nb_obs=self.nb_obs,
                                            max_stable_model=max_stable_model,
@@ -24,7 +24,7 @@ class TestDataset(unittest.TestCase):
         """Test to warn me when spatialExtremes handles R3"""
         with self.assertRaises(RRuntimeError):
             smith_process = load_test_max_stable_models()[0]
-            coordinates = load_test_3D_coordinates(nb_points=self.nb_points)[0]
+            coordinates = load_test_3D_spatial_coordinates(nb_points=self.nb_points)[0]
             MaxStableDataset.from_sampling(nb_obs=self.nb_obs,
                                            max_stable_model=smith_process,
                                            coordinates=coordinates)

test/test_spatio_temporal_dataset/test_slicer.py

@@ -7,7 +7,8 @@ from extreme_estimator.extreme_models.max_stable_model.max_stable_models import
 from spatio_temporal_dataset.dataset.abstract_dataset import AbstractDataset
 from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
 from spatio_temporal_dataset.slicer.split import ALL_SPLITS_EXCEPT_ALL, Split
-from test.test_utils import load_test_1D_and_2D_coordinates, load_test_spatiotemporal_coordinates
+from test.test_utils import load_test_1D_and_2D_spatial_coordinates, load_test_spatiotemporal_coordinates, \
+    load_test_temporal_coordinates
 
 
 class TestSlicerForDataset(unittest.TestCase):
@@ -17,7 +18,7 @@ class TestSlicerForDataset(unittest.TestCase):
         self.dataset = None
 
     nb_spatial_points = 2
-    nb_temporal_points = 2
+    nb_temporal_steps = 2
     nb_obs = 2
 
     @property
@@ -31,6 +32,7 @@ class TestSlicerForDataset(unittest.TestCase):
         return dataset.maxima_frech(split).shape
 
     def check_shapes(self, train_split_ratio_to_observation_shape):
+        assert self.complete_shape is not None
         for train_split_ratio, data_shape in train_split_ratio_to_observation_shape.items():
             for dataset in self.load_datasets(train_split_ratio):
                 self.assertEqual(self.complete_shape, self.get_shape(dataset, Split.all))
@@ -49,8 +51,8 @@ class TestSlicerForSpatialDataset(TestSlicerForDataset):
         return self.nb_spatial_points, self.nb_obs
 
     def load_datasets(self, train_split_ratio):
-        coordinates_list = load_test_1D_and_2D_coordinates(nb_points=self.nb_spatial_points,
-                                                           train_split_ratio=train_split_ratio)
+        coordinates_list = load_test_1D_and_2D_spatial_coordinates(nb_points=self.nb_spatial_points,
+                                                                   train_split_ratio=train_split_ratio)
         dataset_list = [FullSimulatedDataset.from_double_sampling(nb_obs=self.nb_obs,
                                                                   margin_model=ConstantMarginModel(
                                                                       coordinates=coordinates),
@@ -61,29 +63,33 @@ class TestSlicerForSpatialDataset(TestSlicerForDataset):
     def test_spatial_slicer_for_spatial_dataset(self):
         train_split_ratio_to_observation_shape = {
             None: self.complete_shape,
-            0.5: (1, 2),
+            0.5: (self.nb_spatial_points // 2, self.nb_obs),
         }
         self.check_shapes(train_split_ratio_to_observation_shape)
 
-# todo: create temporalCoordinates
-# class TestSlicerForTemporalDataset(TestSlicerForDataset):
-#
-#     def load_datasets(self, train_split_ratio):
-#         coordinates_list = load_test_1D_and_2D_coordinates(nb_points=self.nb_spatial_points,
-#                                                            train_split_ratio=train_split_ratio)
-#         dataset_list = [FullSimulatedDataset.from_double_sampling(nb_obs=self.nb_temporal_obs,
-#                                                                   margin_model=ConstantMarginModel(
-#                                                                       coordinates=coordinates),
-#                                                                   coordinates=coordinates, max_stable_model=Smith())
-#                         for coordinates in coordinates_list]
-#         return dataset_list
-#
-#     def test_temporal_slicer_for_temporal_dataset(self):
-#         ind_tuple_to_observation_shape = {
-#             None: self.complete_shape,
-#             0.5: (2, 1),
-#         }
-#         self.check_shapes(ind_tuple_to_observation_shape)
+
+class TestSlicerForTemporalDataset(TestSlicerForDataset):
+
+    @property
+    def complete_shape(self):
+        return self.nb_temporal_steps, self.nb_obs
+
+    def load_datasets(self, train_split_ratio):
+        coordinates_list = load_test_temporal_coordinates(nb_temporal_steps=self.nb_temporal_steps,
+                                                          train_split_ratio=train_split_ratio)
+        dataset_list = [FullSimulatedDataset.from_double_sampling(nb_obs=self.nb_obs,
+                                                                  margin_model=ConstantMarginModel(
+                                                                      coordinates=coordinates),
+                                                                  coordinates=coordinates, max_stable_model=Smith())
+                        for coordinates in coordinates_list]
+        return dataset_list
+
+    def test_temporal_slicer_for_temporal_dataset(self):
+        ind_tuple_to_observation_shape = {
+            None: self.complete_shape,
+            0.5: (self.nb_temporal_steps // 2, self.nb_obs),
+        }
+        self.check_shapes(ind_tuple_to_observation_shape)
 
 
 # class TestSlicerForSpatioTemporalDataset(TestSlicerForDataset):

test/test_utils.py

@@ -9,10 +9,12 @@ from extreme_estimator.extreme_models.max_stable_model.max_stable_models import
     Geometric, ExtremalT, ISchlather
 from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_3D_coordinates import \
     AlpsStation3DCoordinatesWithAnisotropy
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import \
+    CircleSpatialCoordinates
 from spatio_temporal_dataset.coordinates.spatio_temporal_coordinates.generated_spatio_temporal_coordinates import \
     UniformSpatioTemporalCoordinates
 from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import UniformSpatialCoordinates
+from spatio_temporal_dataset.coordinates.temporal_coordinates.generated_temporal_coordinates import TemporalCoordinates
 
 """
 Common objects to load for the test.
@@ -21,8 +23,9 @@ In this case, unit test (at least on the constructor) must be ensured in the tes
 """
 
 TEST_MAX_STABLE_MODEL = [Smith, BrownResnick, Schlather, Geometric, ExtremalT, ISchlather]
-TEST_1D_AND_2D_COORDINATES = [UniformSpatialCoordinates, CircleSpatialCoordinates]
-TEST_3D_COORDINATES = [AlpsStation3DCoordinatesWithAnisotropy]
+TEST_1D_AND_2D_SPATIAL_COORDINATES = [UniformSpatialCoordinates, CircleSpatialCoordinates]
+TEST_3D_SPATIAL_COORDINATES = [AlpsStation3DCoordinatesWithAnisotropy]
+TEST_TEMPORAL_COORDINATES = [TemporalCoordinates]
 TEST_SPATIO_TEMPORAL_COORDINATES = [UniformSpatioTemporalCoordinates]
 TEST_MARGIN_TYPES = [ConstantMarginModel, LinearAllParametersAllDimsMarginModel][:]
 TEST_MAX_STABLE_ESTIMATOR = [MaxStableEstimator]
@@ -59,12 +62,18 @@ def load_test_spatial_coordinates(nb_points, coordinate_types, train_split_ratio
             for coordinate_class in coordinate_types]
 
 
-def load_test_1D_and_2D_coordinates(nb_points, train_split_ratio=None):
-    return load_test_spatial_coordinates(nb_points, TEST_1D_AND_2D_COORDINATES, train_split_ratio=train_split_ratio)
+def load_test_1D_and_2D_spatial_coordinates(nb_points, train_split_ratio=None):
+    return load_test_spatial_coordinates(nb_points, TEST_1D_AND_2D_SPATIAL_COORDINATES,
+                                         train_split_ratio=train_split_ratio)
 
 
-def load_test_3D_coordinates(nb_points):
-    return load_test_spatial_coordinates(nb_points, TEST_3D_COORDINATES)
+def load_test_3D_spatial_coordinates(nb_points):
+    return load_test_spatial_coordinates(nb_points, TEST_3D_SPATIAL_COORDINATES)
+
+
+def load_test_temporal_coordinates(nb_temporal_steps, train_split_ratio=None):
+    return [coordinate_class.from_nb_temporal_steps(nb_temporal_steps, train_split_ratio) for coordinate_class in
+            TEST_TEMPORAL_COORDINATES]
 
 
 def load_test_spatiotemporal_coordinates(nb_points, train_split_ratio=None, nb_time_steps=None):