chemotools 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

chemotools/augmentation/__init__.py

@@ -1,5 +1,6 @@
 from ._add_noise import AddNoise
 from ._baseline_shift import BaselineShift
+from ._fractional_shift import FractionalShift
 from ._index_shift import IndexShift
 from ._spectrum_scale import SpectrumScale
 
@@ -7,6 +8,7 @@ from ._spectrum_scale import SpectrumScale
 __all__ = [
     "AddNoise",
     "BaselineShift",
+    "FractionalShift",
     "IndexShift",
     "SpectrumScale",
 ]

chemotools/augmentation/_add_noise.py

@@ -6,72 +6,95 @@ from sklearn.utils.validation import check_is_fitted, validate_data
 
 
 class AddNoise(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
-    """
-    Add normal noise to the input data.
+    """Add noise to input data from various probability distributions.
+
+    This transformer adds random noise from specified probability distributions
+    to the input data. Supported distributions include Gaussian, Poisson, and
+    exponential.
+
+    Parameters
+    ----------
+    distribution : {'gaussian', 'poisson', 'exponential'}, default='gaussian'
+        The probability distribution to sample noise from.
+    scale : float, default=0.0
+        Scale parameter for the noise distribution:
+        - For gaussian: standard deviation
+        - For poisson: multiplication factor for sampled values
+        - For exponential: scale parameter (1/λ)
+    random_state : int, optional
+        Random seed for reproducibility.
+
+    Attributes
+    ----------
+    n_features_in_ : int
+        Number of features in the training data.
     """
 
     def __init__(
         self,
-        noise_distribution: Literal["gaussian", "poisson", "exponential"] = "gaussian",
+        distribution: Literal["gaussian", "poisson", "exponential"] = "gaussian",
         scale: float = 0.0,
         random_state: Optional[int] = None,
     ):
-        self.noise_distribution = noise_distribution
+        self.distribution = distribution
         self.scale = scale
         self.random_state = random_state
 
     def fit(self, X: np.ndarray, y=None) -> "AddNoise":
-        """
-        Fit the transformer to the input data.
+        """Fit the transformer to the input data.
 
         Parameters
         ----------
-        X : np.ndarray of shape (n_samples, n_features)
-            The input data to fit the transformer to.
-
+        X : array-like of shape (n_samples, n_features)
+            Training data.
         y : None
-            Ignored.
+            Ignored. Present for API consistency.
 
         Returns
         -------
-        self : NormalNoise
-            The fitted transformer.
+        self : AddNoise
+            Fitted transformer.
+
+        Raises
+        ------
+        ValueError
+            If X is not a 2D array or contains non-finite values.
         """
+
         # Check that X is a 2D array and has only finite values
         X = validate_data(
             self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
         )
 
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
-
         # Instantiate the random number generator
         self._rng = np.random.default_rng(self.random_state)
 
         return self
 
     def transform(self, X: np.ndarray, y=None) -> np.ndarray:
-        """
-        Transform the input data by adding random normal noise.
+        """Transform the input data by adding random noise.
 
         Parameters
         ----------
-        X : np.ndarray of shape (n_samples, n_features)
-            The input data to transform.
-
+        X : array-like of shape (n_samples, n_features)
+            Input data to transform.
         y : None
-            Ignored.
+            Ignored. Present for API consistency.
 
         Returns
         -------
-        X_ : np.ndarray of shape (n_samples, n_features)
-            The transformed data.
+        X_noisy : ndarray of shape (n_samples, n_features)
+            Transformed data with added noise.
+
+        Raises
+        ------
+        ValueError
+            If X has different number of features than the training data,
+            or if an invalid noise distribution is specified.
         """
+
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
         X_ = validate_data(
@@ -84,31 +107,29 @@ class AddNoise(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
             dtype=np.float64,
         )
 
-        # Check that the number of features is the same as the fitted data
-        if X_.shape[1] != self.n_features_in_:
+        # Select the noise function based on the selected distribution
+        noise_func = {
+            "gaussian": self._add_gaussian_noise,
+            "poisson": self._add_poisson_noise,
+            "exponential": self._add_exponential_noise,
+        }.get(self.distribution)
+
+        if noise_func is None:
             raise ValueError(
-                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
+                f"Invalid noise distribution: {self.distribution}. "
+                "Expected one of: gaussian, poisson, exponential"
             )
 
-        # Calculate the standard normal variate
-        for i, x in enumerate(X_):
-            match self.noise_distribution:
-                case "gaussian":
-                    X_[i] = self._add_gaussian_noise(x)
-                case "poisson":
-                    X_[i] = self._add_poisson_noise(x)
-                case "exponential":
-                    X_[i] = self._add_exponential_noise(x)
-                case _:
-                    raise ValueError("Invalid noise distribution")
-
-        return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+        return noise_func(X_)
 
-    def _add_gaussian_noise(self, x) -> np.ndarray:
-        return x + self._rng.normal(0, self.scale, size=x.shape)
+    def _add_gaussian_noise(self, X: np.ndarray) -> np.ndarray:
+        """Add Gaussian noise to the input array."""
+        return X + self._rng.normal(0, self.scale, size=X.shape)
 
-    def _add_poisson_noise(self, x) -> np.ndarray:
-        return self._rng.poisson(x, size=x.shape) * self.scale
+    def _add_poisson_noise(self, X: np.ndarray) -> np.ndarray:
+        """Add Poisson noise to the input array."""
+        return X + self._rng.poisson(X, size=X.shape) * self.scale
 
-    def _add_exponential_noise(self, x) -> np.ndarray:
-        return x + self._rng.exponential(self.scale, size=x.shape)
+    def _add_exponential_noise(self, X: np.ndarray) -> np.ndarray:
+        """Add exponential noise to the input array."""
+        return X + self._rng.exponential(self.scale, size=X.shape)

chemotools/augmentation/_fractional_shift.py

@@ -0,0 +1,203 @@
+from typing import Literal, Optional
+
+import numpy as np
+from scipy.interpolate import CubicSpline
+from scipy import stats
+from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
+from sklearn.utils.validation import check_is_fitted, validate_data
+
+
+class FractionalShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
+    """
+    Shift the spectrum by a fractional amount, allowing shifts below one index.
+
+    Parameters
+    ----------
+    shift : float, default=0.0
+        Maximum amount by which the data is randomly shifted.
+        The actual shift is a random float between -shift and shift.
+
+    padding_mode : {'zeros', 'constant', 'wrap', 'extend', 'mirror', 'linear'}, default='linear'
+        Specifies how to handle padding when shifting the data:
+            - 'zeros': Pads with zeros.
+            - 'constant': Pads with a constant value defined by `pad_value`.
+            - 'wrap': Circular shift (wraps around).
+            - 'extend': Extends using edge values.
+            - 'mirror': Mirrors the signal.
+            - 'linear': Uses linear regression on 5 points to extrapolate values.
+
+    pad_value : float, default=0.0
+        The value used for padding when `padding_mode='constant'`.
+
+    random_state : int, optional, default=None
+        The random seed for reproducibility.
+    """
+
+    def __init__(
+        self,
+        shift: float = 0.0,
+        padding_mode: Literal[
+            "zeros", "constant", "extend", "mirror", "linear"
+        ] = "linear",
+        pad_value: float = 0.0,
+        random_state: Optional[int] = None,
+    ):
+        self.shift = shift
+        self.padding_mode = padding_mode
+        self.pad_value = pad_value
+        self.random_state = random_state
+
+    def fit(self, X: np.ndarray, y=None) -> "FractionalShift":
+        """
+        Fit the transformer to the input data.
+
+        Parameters
+        ----------
+        X : np.ndarray of shape (n_samples, n_features)
+            The input data to fit the transformer to.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        self : FractionalShift
+            The fitted transformer.
+        """
+        X = validate_data(
+            self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
+        )
+        self._rng = np.random.default_rng(self.random_state)
+        return self
+
+    def transform(self, X: np.ndarray, y=None) -> np.ndarray:
+        """
+        Transform the input data by shifting the spectrum.
+
+        Parameters
+        ----------
+        X : np.ndarray of shape (n_samples, n_features)
+            The input data to transform.
+
+        y : None
+            Ignored.
+
+        Returns
+        -------
+        X_ : np.ndarray of shape (n_samples, n_features)
+            The transformed data with the applied shifts.
+        """
+        check_is_fitted(self, "n_features_in_")
+        X_ = validate_data(
+            self,
+            X,
+            y="no_validation",
+            ensure_2d=True,
+            copy=True,
+            reset=False,
+            dtype=np.float64,
+        )
+
+        for i, x in enumerate(X_):
+            X_[i] = self._shift_signal(x)
+
+        return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+
+    def _shift_signal(self, x: np.ndarray) -> np.ndarray:
+        """
+        Shifts a signal by a fractional amount using cubic spline interpolation.
+
+        Parameters
+        ----------
+        x : np.ndarray of shape (n_features,)
+            The input signal to shift.
+
+        Returns
+        -------
+        shifted_signal : np.ndarray of shape (n_features,)
+            The shifted signal.
+        """
+        shift = self._rng.uniform(-self.shift, self.shift)
+        n = len(x)
+        indices = np.arange(n)
+        shifted_indices = indices + shift
+
+        # Create cubic spline interpolator
+        spline = CubicSpline(indices, x, bc_type="not-a-knot")
+        shifted_signal = spline(shifted_indices)
+
+        # Determine padding direction and length
+        if shift >= 0:
+            pad_length = len(shifted_indices[shifted_indices >= n - 1])
+            pad_left = False
+        else:
+            pad_length = len(shifted_indices[shifted_indices < 0])
+            pad_left = True
+
+        # Handle padding based on mode
+        if self.padding_mode == "zeros":
+            shifted_signal[shifted_indices < 0] = 0
+            shifted_signal[shifted_indices >= n - 1] = 0
+
+        elif self.padding_mode == "constant":
+            shifted_signal[shifted_indices < 0] = self.pad_value
+            shifted_signal[shifted_indices >= n - 1] = self.pad_value
+
+        elif self.padding_mode == "mirror":
+            if pad_left:
+                pad_values = x[pad_length - 1 :: -1]
+                shifted_signal[shifted_indices < 0] = pad_values[:pad_length]
+            else:
+                pad_values = x[:-1][::-1]
+                shifted_signal[shifted_indices >= n - 1] = pad_values[:pad_length]
+
+        elif self.padding_mode == "extend":
+            if pad_left:
+                shifted_signal[shifted_indices < 0] = x[0]
+            else:
+                shifted_signal[shifted_indices >= n - 1] = x[-1]
+
+        elif self.padding_mode == "linear":
+            if pad_left:
+                # Use first 5 points for regression
+                if len(x) < 5:
+                    points = x[: len(x)]  # Use all points if less than 5
+                else:
+                    points = x[:5]
+                x_coords = np.arange(len(points))
+
+                # Reshape arrays for linregress
+                x_coords = x_coords.reshape(-1)
+                points = points.reshape(-1)
+
+                # Perform regression
+                slope, intercept, _, _, _ = stats.linregress(x_coords, points)
+
+                # Generate new points using linear regression
+                new_x = np.arange(-pad_length, 0)
+                extrapolated = slope * new_x + intercept
+                shifted_signal[shifted_indices < 0] = extrapolated
+            else:
+                # Use last 5 points for regression
+                if len(x) < 5:
+                    points = x[-len(x) :]  # Use all points if less than 5
+                else:
+                    points = x[-5:]
+                x_coords = np.arange(len(points))
+
+                # Reshape arrays for linregress
+                x_coords = x_coords.reshape(-1)
+                points = points.reshape(-1)
+
+                # Perform regression
+                slope, intercept, _, _, _ = stats.linregress(x_coords, points)
+
+                # Generate new points using linear regression
+                new_x = np.arange(len(points), len(points) + pad_length)
+                extrapolated = slope * new_x + intercept
+                shifted_signal[shifted_indices >= n] = extrapolated
+
+        else:
+            raise ValueError(f"Unknown padding mode: {self.padding_mode}")
+
+        return shifted_signal

chemotools/augmentation/_index_shift.py

@@ -1,23 +1,37 @@
 from typing import Literal, Optional
 
 import numpy as np
-from numpy.polynomial import polynomial as poly
+from scipy.signal import convolve
+from scipy import stats
 from sklearn.base import BaseEstimator, TransformerMixin, OneToOneFeatureMixin
 from sklearn.utils.validation import check_is_fitted, validate_data
 
 
 class IndexShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     """
-    Shift the spectrum a given number of indices between - shift and + shift drawn
+    Shift the spectrum a given number of indices between -shift and +shift drawn
     from a discrete uniform distribution.
 
     Parameters
     ----------
-    shift : float, default=0.0
-        Shifts the data by a random integer between -shift and shift.
+    shift : int, default=0
+        Maximum number of indices by which the data is randomly shifted.
+        The actual shift is a random integer between -shift and shift (inclusive).
 
-    random_state : int, default=None
-        The random state to use for the random number generator.
+    padding_mode : {'zeros', 'constant', 'wrap', 'extend', 'mirror', 'linear'}, default='linear'
+        Specifies how to handle padding when shifting the data:
+            - 'zeros': Pads with zeros.
+            - 'constant': Pads with a constant value defined by `pad_value`.
+            - 'wrap': Circular shift (wraps around).
+            - 'extend': Extends using edge values.
+            - 'mirror': Mirrors the signal.
+            - 'linear': Uses linear regression to extrapolate values.
+
+    pad_value : float, default=0.0
+        The value used for padding when `padding_mode='constant'`.
+
+    random_state : int, optional, default=None
+        The random seed for reproducibility.
 
     Attributes
     ----------
@@ -27,23 +41,22 @@ class IndexShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
     _is_fitted : bool
         Whether the transformer has been fitted to data.
 
-    Methods
-    -------
-    fit(X, y=None)
-        Fit the transformer to the input data.
-
-    transform(X, y=0, copy=True)
-        Transform the input data by shifting the spectrum.
+    _rng : numpy.random.Generator
+        Random number generator instance used for shifting.
     """
 
     def __init__(
         self,
         shift: int = 0,
-        fill_method: Literal["constant", "linear", "quadratic"] = "constant",
+        padding_mode: Literal[
+            "zeros", "constant", "wrap", "extend", "mirror", "linear"
+        ] = "linear",
+        pad_value: float = 0.0,
         random_state: Optional[int] = None,
     ):
         self.shift = shift
-        self.fill_method = fill_method
+        self.padding_mode = padding_mode
+        self.pad_value = pad_value
         self.random_state = random_state
 
     def fit(self, X: np.ndarray, y=None) -> "IndexShift":
@@ -68,12 +81,6 @@ class IndexShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
             self, X, y="no_validation", ensure_2d=True, reset=True, dtype=np.float64
         )
 
-        # Set the number of features
-        self.n_features_in_ = X.shape[1]
-
-        # Set the fitted attribute to True
-        self._is_fitted = True
-
         # Instantiate the random number generator
         self._rng = np.random.default_rng(self.random_state)
 
@@ -94,10 +101,10 @@ class IndexShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
         Returns
         -------
         X_ : np.ndarray of shape (n_samples, n_features)
-            The transformed data.
+            The transformed data with the applied shifts.
         """
         # Check that the estimator is fitted
-        check_is_fitted(self, "_is_fitted")
+        check_is_fitted(self, "n_features_in_")
 
         # Check that X is a 2D array and has only finite values
         X_ = validate_data(
@@ -110,90 +117,98 @@ class IndexShift(TransformerMixin, OneToOneFeatureMixin, BaseEstimator):
             dtype=np.float64,
         )
 
-        # Check that the number of features is the same as the fitted data
-        if X_.shape[1] != self.n_features_in_:
-            raise ValueError(
-                f"Expected {self.n_features_in_} features but got {X_.shape[1]}"
-            )
-
         # Calculate the standard normal variate
         for i, x in enumerate(X_):
-            X_[i] = self._shift_vector(x)
+            X_[i] = self._shift_signal(x)
 
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
-    def _shift_spectrum(self, x) -> np.ndarray:
-        shift_amount = self._rng.integers(-self.shift, self.shift, endpoint=True)
-        return np.roll(x, shift_amount)
-
-    def _shift_vector(
-        self,
-        x: np.ndarray,
-    ) -> np.ndarray:
+    def _shift_signal(self, x: np.ndarray):
         """
-        Shift vector with option to fill missing values.
-
-        Args:
-            arr: Input numpy array
-            shift: Number of positions to shift
-            fill_method: Method to fill missing values
-                'constant': fill with first/last value
-                'linear': fill using linear regression
-                'quadratic': fill using quadratic regression
-
-        Returns:
-            Shifted numpy array
-        """
-        shift = self._rng.integers(-self.shift, self.shift, endpoint=True)
-
-        result = np.roll(x, shift)
-
-        if self.fill_method == "constant":
-            if shift > 0:
-                result[:shift] = x[0]
-            elif shift < 0:
-                result[shift:] = x[-1]
-
-        elif self.fill_method == "linear":
-            if shift > 0:
-                x_ = np.arange(5)
-                coeffs = poly.polyfit(x_, x[:5], 1)
+        Shifts a discrete signal using convolution with a Dirac delta kernel.
 
-                extrapolate_x = np.arange(-shift, 0)
-                extrapolated_values = poly.polyval(extrapolate_x, coeffs)
-
-                result[:shift] = extrapolated_values
-
-            elif shift < 0:
-                x_ = np.arange(5)
-                coeffs = poly.polyfit(x_, x[-5:], 1)
-
-                extrapolate_x = np.arange(len(x_), len(x_) - shift)
-                extrapolated_values = poly.polyval(extrapolate_x, coeffs)
-
-                result[shift:] = extrapolated_values
-
-        elif self.fill_method == "quadratic":
-            if shift > 0:
-                # Use first 3 values for quadratic regression
-                x_ = np.arange(5)
-                coeffs = poly.polyfit(x_, x[:5], 2)
-
-                # Extrapolate to fill shifted region
-                extrapolate_x = np.arange(-shift, 0)
-                extrapolated_values = poly.polyval(extrapolate_x, coeffs)
-
-                result[:shift] = extrapolated_values
-
-            elif shift < 0:
-                # Use last 3 values for quadratic regression
-                x_ = np.arange(5)
-                coeffs = poly.polyfit(x_, x[-5:], 2)
-
-                # Extrapolate to fill shifted region
-                extrapolate_x = np.arange(len(x_), len(x_) - shift)
-                extrapolated_values = poly.polyval(extrapolate_x, coeffs)
+        Parameters
+        ----------
+        x : np.ndarray of shape (n_features,)
+            The input signal to shift.
 
-                result[shift:] = extrapolated_values
+        Returns
+        -------
+        result : np.ndarray of shape (n_features,)
+            The shifted signal.
+        """
+        shift = self._rng.integers(-self.shift, self.shift, endpoint=True)
 
-        return result
+        if self.padding_mode == "wrap":
+            return np.roll(x, shift)
+
+        # Create Dirac delta kernel with proper dimensions
+
+        if shift >= 0:
+            kernel = np.zeros(shift + 1)
+            kernel[-1] = 1
+        else:
+            kernel = np.zeros(-shift + 1)
+            kernel[0] = 1
+
+        # Convolve signal with kernel
+        shifted = convolve(x, kernel, mode="full")
+
+        if shift >= 0:
+            result = shifted[: len(x)] if x.ndim == 1 else shifted[: x.shape[0]]
+            pad_length = shift
+            pad_left = True
+        else:
+            result = shifted[-len(x) :] if x.ndim == 1 else shifted[-x.shape[0] :]
+            pad_length = -shift
+            pad_left = False
+
+        if self.padding_mode == "zeros":
+            return result
+
+        elif self.padding_mode == "constant":
+            mask = np.abs(result) < 1e-10
+            result[mask] = self.pad_value
+            return result
+
+        elif self.padding_mode == "mirror":
+            if pad_left:
+                pad_values = x[pad_length - 1 :: -1]
+                result[:pad_length] = pad_values[-pad_length:]
+            else:
+                pad_values = x[:-1][::-1]
+                result[-pad_length:] = pad_values[:pad_length]
+
+            return result
+
+        elif self.padding_mode == "extend":
+            if pad_left:
+                result[:pad_length] = x[0]
+            else:
+                result[-pad_length:] = x[-1]
+            return result
+
+        elif self.padding_mode == "linear":
+            # Get points for linear regression
+            if pad_left:
+                points = x[: pad_length + 1]  # Take first pad_length+1 points
+                x_coords = np.arange(len(points))
+                slope, intercept, _, _, _ = stats.linregress(x_coords, points)
+
+                # Generate new points using linear regression
+                new_x = np.arange(-pad_length, 0)
+                extrapolated = slope * new_x + intercept
+                result[:pad_length] = extrapolated
+            else:
+                points = x[-pad_length - 1 :]  # Take last pad_length+1 points
+                x_coords = np.arange(len(points))
+                slope, intercept, _, _, _ = stats.linregress(x_coords, points)
+
+                # Generate new points using linear regression
+                new_x = np.arange(len(points), len(points) + pad_length)
+                extrapolated = slope * new_x + intercept
+                result[-pad_length:] = extrapolated
+            return result
+
+        else:
+            raise ValueError(f"Unknown padding mode: {self.padding_mode}")

{chemotools-0.1.8.dist-info → chemotools-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: chemotools
-Version: 0.1.8
+Version: 0.1.9
 Summary: chemotools: A Python Package that Integrates Chemometrics and scikit-learn
 License: MIT
 Author: Pau Cabaneros

{chemotools-0.1.8.dist-info → chemotools-0.1.9.dist-info}/RECORD

@@ -1,8 +1,9 @@
 chemotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chemotools/augmentation/__init__.py,sha256=_DiyO7M0xztix8Ea_esxe0xjEYHTneJVJZ52bu5WFpg,248
-chemotools/augmentation/_add_noise.py,sha256=4SQFiU9Snl0Dz5EfvRjimpndlNGdXxW2ya3YplHL2fg,3502
+chemotools/augmentation/__init__.py,sha256=iRltqvskLJAhwxxlTtGPWJfR5XiwvQfqbv4QdUMF9BU,318
+chemotools/augmentation/_add_noise.py,sha256=fkTJfIYtZXezcjy6Vz8asIhpBoVp4oaIifppK9vZpM8,4362
 chemotools/augmentation/_baseline_shift.py,sha256=kIlYvmKS9pu9vh_-eZ7PSHPuH_58V9mgYbSJt6Gq3BA,3476
-chemotools/augmentation/_index_shift.py,sha256=w1maDHGLAKSiGAQ8c9yYHofs_PJnxeN0nB1RU-pINcE,6042
+chemotools/augmentation/_fractional_shift.py,sha256=dJ0Vuc-U02HhjKkOwc48qnOksZYgbHwL2ko7tWCZTQU,6916
+chemotools/augmentation/_index_shift.py,sha256=BTtadweDvvMtiF8t7ldwsE6Kl6FmKLCkVJjSzSWyIDs,6904
 chemotools/augmentation/_spectrum_scale.py,sha256=hMsmzXpssbI7tGm_YnQn9wjbByso3CgVxd3Hs8kfLS8,3442
 chemotools/baseline/__init__.py,sha256=VzoblGg8Hx_FkTc_n7a-ZjGvtKP8JE_NwJKWenGFQkM,584
 chemotools/baseline/_air_pls.py,sha256=eotXuIEsus7Z-c17oLx8UbiwOHM7DzQJ6rruHnwCGPQ,5067
@@ -43,7 +44,7 @@ chemotools/smooth/_median_filter.py,sha256=9ndTJCwrZirWlvDNldiigMddy79KIGq9OwwYN
 chemotools/smooth/_savitzky_golay_filter.py,sha256=27iFUWxdL9_7oZabR0R5L0ZTpBmYfVUjx2XCTukihBE,3509
 chemotools/smooth/_whittaker_smooth.py,sha256=lpLAyf4GdyDW4ulT1nyEoK6xQEl2cVUKquawQdGWbHU,3571
 chemotools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chemotools-0.1.8.dist-info/LICENSE,sha256=qtyOy2wDQVX9hxp58h3T-6Lmfv-mSCHoSRkcLUdM9bg,1070
-chemotools-0.1.8.dist-info/METADATA,sha256=gK71zOTZyaFxCqjxXGGKfQi4TvN43AXhBIaWdMWVJh4,5239
-chemotools-0.1.8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-chemotools-0.1.8.dist-info/RECORD,,
+chemotools-0.1.9.dist-info/LICENSE,sha256=qtyOy2wDQVX9hxp58h3T-6Lmfv-mSCHoSRkcLUdM9bg,1070
+chemotools-0.1.9.dist-info/METADATA,sha256=9sih25qSOTJX36gib96hxm-e86TorD040r_WNFzbc9U,5239
+chemotools-0.1.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+chemotools-0.1.9.dist-info/RECORD,,