Reparametrize raisedcosine

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
   tox:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest] #[ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest] #[ubuntu-latest, macos-latest, windows-latest]
         python-version: ['3.10'] #['3.8', '3.9', '3.10']
     runs-on: ${{ matrix.os }}
     steps:

src/nemos/basis.py

@@ -505,7 +505,7 @@ def _check_n_basis_min(self) -> None:
 
 
 class MSplineBasis(SplineBasis):
-    """M-spline[$^1$](references) 1-dimensional basis functions.
+    """M-spline[$^1$](#references) 1-dimensional basis functions.
 
     Parameters
     ----------
@@ -576,7 +576,7 @@ def evaluate_on_grid(self, n_samples: int) -> Tuple[NDArray, NDArray]:
 
 class BSplineBasis(SplineBasis):
     """
-    B-spline[$^1$](references) 1-dimensional basis functions.
+    B-spline[$^1$](#references) 1-dimensional basis functions.
 
     Parameters
     ----------
@@ -772,7 +772,7 @@ def evaluate_on_grid(self, n_samples: int) -> Tuple[NDArray, NDArray]:
 class RaisedCosineBasisLinear(Basis):
     """Represent linearly-spaced raised cosine basis functions.
 
-    This implementation is based on the cosine bumps used by Pillow et al.[$^1$](references)
+    This implementation is based on the cosine bumps used by Pillow et al.[$^1$](#references)
     to uniformly tile the internal points of the domain.
 
     Parameters
@@ -793,19 +793,14 @@ class RaisedCosineBasisLinear(Basis):
     def __init__(self, n_basis_funcs: int, width: float = 2.0) -> None:
         super().__init__(n_basis_funcs)
         self._n_input_dimensionality = 1
-        self.width = width
+        self._check_width(width)
+        self._width = width
 
     @property
     def width(self):
         """Return width of the raised cosine."""
         return self._width
 
-    @width.setter
-    def width(self, width: float):
-        """Check and set width of the raised cosine."""
-        self._check_width(width)
-        self._width = width
-
     @staticmethod
     def _check_width(width: float):
         """Validate the width value.
@@ -852,8 +847,11 @@ def evaluate(self, sample_pts: ArrayLike) -> NDArray:
         if any(sample_pts < 0) or any(sample_pts > 1):
             raise ValueError("Sample points for RaisedCosine basis must lie in [0,1]!")
 
-        peaks = np.linspace(0, 1, self.n_basis_funcs)
+        peaks = self._compute_peaks()
         delta = peaks[1] - peaks[0]
+        # generate a set of shifted cosines, and constrain them to be non-zero
+        # over a single period, then enforce the codomain to be [0,1], by adding 1
+        # and then multiply by 0.5
         basis_funcs = 0.5 * (
             np.cos(
                 np.clip(
@@ -867,6 +865,16 @@ def evaluate(self, sample_pts: ArrayLike) -> NDArray:
 
         return basis_funcs
 
+    def _compute_peaks(self):
+        """
+        Compute the location of raised cosine peaks.
+
+        Returns
+        -------
+            Peak locations of each basis element.
+        """
+        return np.linspace(0, 1, self.n_basis_funcs)
+
     def evaluate_on_grid(self, n_samples: int) -> Tuple[NDArray, NDArray]:
         """Evaluate the basis set on a grid of equi-spaced sample points.
 
@@ -939,46 +947,67 @@ def __init__(
         super().__init__(n_basis_funcs, width=width)
         self.enforce_decay_to_zero = enforce_decay_to_zero
         if time_scaling is None:
-            self.time_scaling = 50.0
+            self._time_scaling = 50.0
         else:
-            self.time_scaling = time_scaling
+            self._check_time_scaling(time_scaling)
+            self._time_scaling = time_scaling
 
     @property
     def time_scaling(self):
         return self._time_scaling
 
-    @time_scaling.setter
-    def time_scaling(self, time_scaling):
+    @staticmethod
+    def _check_time_scaling(time_scaling):
         if time_scaling <= 0:
             raise ValueError(
                 f"Only strictly positive time_scaling are allowed, {time_scaling} provided instead."
             )
-        self._time_scaling = time_scaling
 
     def _transform_samples(self, sample_pts: NDArray) -> NDArray:
         """
         Map the sample domain to log-space.
 
         Parameters
         ----------
-        sample_pts : NDArray
+        sample_pts :
             Sample points used for evaluating the splines,
             shape (n_samples, ).
 
         Returns
         -------
-        NDArray
             Transformed version of the sample points that matches the Raised Cosine basis domain,
             shape (n_samples, ).
         """
         # This log-stretching of the sample axis has the following effect:
-        # - as the time_scaling tends to 0, the points will be linearly spaced.
-        # - as the time_scaling tends to inf, basis will be dense around 0.
+        # - as the time_scaling tends to 0, the points will be linearly spaced across the whole domain.
+        # - as the time_scaling tends to inf, basis will be small and dense around 0 and
+        # progressively larger and less dense towards 1.
         log_spaced_pts = np.log(self.time_scaling * sample_pts + 1) / np.log(
             self.time_scaling + 1
         )
         return log_spaced_pts
 
+    def _compute_peaks(self):
+        """
+        Peak location of each log-spaced cosine basis element
+
+        Compute the peak location for the log-spaced raised cosine basis.
+        Enforcing that the last basis decays to zero is equivalent to
+        setting the last peak to a value smaller than 1.
+
+        Returns
+        -------
+            Peak locations of each basis element.
+
+        """
+        if self.enforce_decay_to_zero:
+            # compute the last peak location such that the last
+            # basis element decays to zero at the last sample.
+            last_peak = 1 - self.width / (self.n_basis_funcs + self.width - 1)
+        else:
+            last_peak = 1
+        return np.linspace(0, last_peak, self.n_basis_funcs)
+
     def evaluate(self, sample_pts: ArrayLike) -> NDArray:
         """Generate log-spaced raised cosine basis with given samples.
 
@@ -998,24 +1027,7 @@ def evaluate(self, sample_pts: ArrayLike) -> NDArray:
             If the sample provided do not lie in [0,1].
         """
         (sample_pts,) = self._check_evaluate_input(sample_pts)
-        if not self.enforce_decay_to_zero:
-            # keep the last basis, i.e. do not enforce decay to zero
-            # for the filter.
-            eval_basis = super().evaluate(self._transform_samples(sample_pts))
-        else:
-            # temporarily add n_trim basis element
-            # guaranteeing that the last basis element decays to 0 for any width.
-            n_trim = int(np.ceil(self.width))
-            self.n_basis_funcs += n_trim
-            # wrap the evaluation in a try -> finally to make sure that the original
-            # basis function number is preserved even if an exception is raised.
-            try:
-                eval_basis = super().evaluate(self._transform_samples(sample_pts))
-                eval_basis = eval_basis[..., :-n_trim]
-            finally:
-                self.n_basis_funcs -= n_trim
-
-        return eval_basis
+        return super().evaluate(self._transform_samples(sample_pts))
 
 
 class OrthExponentialBasis(Basis):

tests/test_basis.py

@@ -255,18 +255,8 @@ def test_decay_to_zero_basis_number_match(self, width):
     @pytest.mark.parametrize(
         "time_scaling ,expectation",
         [
-            (
-                -1,
-                pytest.raises(
-                    ValueError, match="Only strictly positive time_scaling are allowed"
-                ),
-            ),
-            (
-                0,
-                pytest.raises(
-                    ValueError, match="Only strictly positive time_scaling are allowed"
-                ),
-            ),
+            (-1, pytest.raises(ValueError, match="Only strictly positive time_scaling are allowed")),
+            (0, pytest.raises(ValueError, match="Only strictly positive time_scaling are allowed")),
             (0.1, does_not_raise()),
             (10, does_not_raise()),
         ],