PySDKit 0.4.34__tar.gz → 0.4.35__tar.gz

{pysdkit-0.4.34 → pysdkit-0.4.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.34
+Version: 0.4.35
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
 Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
@@ -189,7 +189,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |   [`STNBMD`]() (Short-Time Narrow-Band Mode Decomposition)   | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X16002443?via%3Dihub) | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56226-short-time-narrow-band-mode-decomposition-stnbmd-toolbox) |   ✖️   |
 | [`SWD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_osd/swd.py) (Swarm Decomposition) |   [[paper]](https://doi.org/10.1016/j.sigpro.2016.09.004)    |  [[code]](https://github.com/gkaposto/Swarm-Decomposition)   |   ✔️   |
 | [`STL`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tsa/_stl.py) (Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/stl_decomposition.html) |   ✔️   |
-| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/mstl_decomposition.html) |   ✖️   |
+| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://arxiv.org/abs/2107.13462) | [[code]](https://github.com/KishManani/MSTL) |   ✔️   |
 
 ## Acknowledgements 🎖️ <a id="Acknowledgements"></a>
 

{pysdkit-0.4.34 → pysdkit-0.4.35}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySDKit
-Version: 0.4.34
+Version: 0.4.35
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Author: josefinez, Deeksha Manjunath, Yuan Feng, JacktheFowler
 Author-email: Whenxuan Wang <wwhenxuan@gmail.com>, RuiZhe Wang <3133986068@qq.com>, WenTong Zhao <23049200290@stu.xidian.edu.cn>
@@ -189,7 +189,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |   [`STNBMD`]() (Short-Time Narrow-Band Mode Decomposition)   | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X16002443?via%3Dihub) | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56226-short-time-narrow-band-mode-decomposition-stnbmd-toolbox) |   ✖️   |
 | [`SWD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_osd/swd.py) (Swarm Decomposition) |   [[paper]](https://doi.org/10.1016/j.sigpro.2016.09.004)    |  [[code]](https://github.com/gkaposto/Swarm-Decomposition)   |   ✔️   |
 | [`STL`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tsa/_stl.py) (Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/stl_decomposition.html) |   ✔️   |
-| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/mstl_decomposition.html) |   ✖️   |
+| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://arxiv.org/abs/2107.13462) | [[code]](https://github.com/KishManani/MSTL) |   ✔️   |
 
 ## Acknowledgements 🎖️ <a id="Acknowledgements"></a>
 

{pysdkit-0.4.34 → pysdkit-0.4.35}/PySDKit.egg-info/SOURCES.txt

@@ -123,6 +123,7 @@ pysdkit/tests/test_itd.py
 pysdkit/tests/test_jmd.py
 pysdkit/tests/test_lmd.py
 pysdkit/tests/test_moving_decomp.py
+pysdkit/tests/test_mstl.py
 pysdkit/tests/test_ovmd.py
 pysdkit/tests/test_rlmd.py
 pysdkit/tests/test_sjmd.py

{pysdkit-0.4.34 → pysdkit-0.4.35}/README.md

@@ -135,7 +135,7 @@ plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 |   [`STNBMD`]() (Short-Time Narrow-Band Mode Decomposition)   | [[paper]](https://www.sciencedirect.com/science/article/pii/S0022460X16002443?via%3Dihub) | [[code]](https://ww2.mathworks.cn/matlabcentral/fileexchange/56226-short-time-narrow-band-mode-decomposition-stnbmd-toolbox) |   ✖️   |
 | [`SWD`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/_osd/swd.py) (Swarm Decomposition) |   [[paper]](https://doi.org/10.1016/j.sigpro.2016.09.004)    |  [[code]](https://github.com/gkaposto/Swarm-Decomposition)   |   ✔️   |
 | [`STL`](https://github.com/wwhenxuan/PySDKit/blob/main/pysdkit/tsa/_stl.py) (Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/stl_decomposition.html) |   ✔️   |
-| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://www.nniiem.ru/file/news/2016/stl-statistical-model.pdf) | [[code]](https://www.statsmodels.org/stable/examples/notebooks/generated/mstl_decomposition.html) |   ✖️   |
+| [`MSTL`]() (Multivariate Seasonal-Trend decomposition using LOESS) | [[paper]](https://arxiv.org/abs/2107.13462) | [[code]](https://github.com/KishManani/MSTL) |   ✔️   |
 
 ## Acknowledgements 🎖️ <a id="Acknowledgements"></a>
 

{pysdkit-0.4.34 → pysdkit-0.4.35}/pysdkit/__init__.py

@@ -2,7 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.34"
+__version__ = "0.4.35"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -118,6 +118,9 @@ from .tsa import Moving_Decomp
 # Seasonal-Trend decomposition using LOESS (STL)
 from .tsa import STL
 
+# Multiple Seasonal-Trend decomposition using LOESS (MSTL)
+from .tsa import MSTL
+
 # Hilbert-Huang Transform
 from ._emd import HHT
 
@@ -182,6 +185,7 @@ Successive Jump and Mode Decomposition          |    SJMD / SMJMD
 Feature Mode Decomposition                      |    FMD
 Moving Average Decomposition                    |    Moving
 Seasonal-Trend decomposition using LOESS        |    STL
+Multiple Seasonal-Trend decomposition (LOESS)   |    MSTL
 Hilbert-Huang Transform                         |    HHT
 _______________________________________________________________
 """
@@ -235,6 +239,7 @@ __all__ = [
     "FMD",
     "Moving_Decomp",
     "STL",
+    "MSTL",
     "models",
     "data",
     "entropy",

pysdkit-0.4.35/pysdkit/tests/test_mstl.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for Multiple Seasonal-Trend decomposition using LOESS (MSTL).
+"""
+
+import unittest
+import warnings
+
+import numpy as np
+
+from pysdkit import MSTL
+from pysdkit.tsa import MSTLResult, STL
+
+
+def _multi_seasonal_series(
+    n: int = 500,
+    periods=(24, 168),
+    seed: int = 0,
+) -> tuple:
+    """Synthetic series with trend + two seasonal sine waves + noise."""
+    rng = np.random.default_rng(seed)
+    t = np.arange(n, dtype=float)
+    trend = 0.0001 * t**2 + 50.0
+    seas = [amp * np.sin(2 * np.pi * t / p) for p, amp in zip(periods, (5.0, 10.0))]
+    noise = 0.3 * rng.standard_normal(n)
+    y = trend + sum(seas) + noise
+    return y, trend, seas
+
+
+class TestMSTL(unittest.TestCase):
+    """Automated tests for MSTL."""
+
+    def setUp(self) -> None:
+        self.periods = (24, 24 * 7)
+        self.y, self.true_trend, self.true_seas = _multi_seasonal_series(
+            n=500, periods=self.periods, seed=0
+        )
+
+    def test_fit_transform_shape(self) -> None:
+        """Verify output shapes for two seasonal periods."""
+        mstl = MSTL(periods=self.periods, iterate=2)
+        result = mstl.fit_transform(self.y)
+
+        self.assertIsInstance(result, MSTLResult)
+        self.assertEqual(result.seasonal.shape, (2, self.y.size))
+        self.assertEqual(result.trend.shape, self.y.shape)
+        self.assertEqual(result.resid.shape, self.y.shape)
+        self.assertEqual(result.periods, tuple(sorted(self.periods)))
+
+    def test_reconstruction(self) -> None:
+        """observed ≈ sum(seasonals) + trend + resid on the transformed scale."""
+        result = MSTL(periods=self.periods).fit_transform(self.y)
+        reconstructed = result.seasonal.sum(axis=0) + result.trend + result.resid
+        self.assertTrue(np.allclose(result.observed, reconstructed, atol=1e-8))
+
+    def test_default_call(self) -> None:
+        """__call__ should match fit_transform."""
+        mstl = MSTL(periods=self.periods)
+        a = mstl(self.y)
+        b = mstl.fit_transform(self.y)
+        self.assertTrue(np.allclose(a.trend, b.trend))
+        self.assertTrue(np.allclose(a.seasonal, b.seasonal))
+        self.assertTrue(np.allclose(a.resid, b.resid))
+
+    def test_str(self) -> None:
+        self.assertIn("MSTL", str(MSTL(periods=24)))
+
+    def test_single_period_matches_stl_identity(self) -> None:
+        """With one period, MSTL should still reconstruct exactly."""
+        period = 24
+        y, _, _ = _multi_seasonal_series(n=240, periods=(period, 48), seed=1)
+        # Keep only daily-like oscillation for a cleaner single-period case
+        t = np.arange(y.size, dtype=float)
+        y = 0.01 * t + 3 * np.sin(2 * np.pi * t / period) + 0.1 * np.random.default_rng(0).standard_normal(y.size)
+
+        result = MSTL(periods=period, iterate=5).fit_transform(y)
+        self.assertEqual(result.seasonal.ndim, 1)
+        self.assertEqual(result.seasonal.shape, y.shape)
+        reconstructed = result.seasonal + result.trend + result.resid
+        self.assertTrue(np.allclose(result.observed, reconstructed, atol=1e-8))
+
+    def test_default_windows(self) -> None:
+        """Paper default windows are 7 + 4*i."""
+        mstl = MSTL(periods=(24, 168))
+        _, windows = mstl._prepare_periods_windows(nobs=500)
+        self.assertEqual(windows, (11, 15))
+
+    def test_periods_sorted_ascending(self) -> None:
+        """Longer periods should not be extracted before shorter ones."""
+        result = MSTL(periods=(168, 24)).fit_transform(self.y)
+        self.assertEqual(result.periods, (24, 168))
+
+    def test_custom_windows(self) -> None:
+        result = MSTL(periods=(24, 168), windows=(11, 15)).fit_transform(self.y)
+        reconstructed = result.seasonal.sum(0) + result.trend + result.resid
+        self.assertTrue(np.allclose(result.observed, reconstructed, atol=1e-8))
+
+    def test_recovers_seasonal_energy(self) -> None:
+        """Extracted seasonals should correlate with the planted components."""
+        result = MSTL(periods=self.periods, iterate=2, stl_kwargs={"seasonal_deg": 0}).fit_transform(
+            self.y
+        )
+        # periods are sorted ascending -> seasonal[0] ~ daily, seasonal[1] ~ weekly
+        corr_daily = np.corrcoef(result.seasonal[0], self.true_seas[0])[0, 1]
+        corr_weekly = np.corrcoef(result.seasonal[1], self.true_seas[1])[0, 1]
+        self.assertGreater(corr_daily, 0.8, msg=f"daily corr={corr_daily}")
+        self.assertGreater(corr_weekly, 0.8, msg=f"weekly corr={corr_weekly}")
+
+        corr_trend = np.corrcoef(result.trend, self.true_trend)[0, 1]
+        self.assertGreater(corr_trend, 0.9, msg=f"trend corr={corr_trend}")
+
+    def test_boxcox_auto(self) -> None:
+        """Box-Cox('auto') should run on positive data and reconstruct."""
+        y = self.y - self.y.min() + 1.0
+        result = MSTL(periods=self.periods, lmbda="auto", iterate=1).fit_transform(y)
+        self.assertIsNotNone(result.lmbda)
+        reconstructed = result.seasonal.sum(0) + result.trend + result.resid
+        self.assertTrue(np.allclose(result.observed, reconstructed, atol=1e-8))
+
+    def test_boxcox_rejects_nonpositive(self) -> None:
+        y = self.y.copy()
+        y[0] = -1.0
+        with self.assertRaises(ValueError):
+            MSTL(periods=24, lmbda=0.0).fit_transform(y)
+
+    def test_invalid_periods(self) -> None:
+        with self.assertRaises(ValueError):
+            MSTL(periods=1)
+        with self.assertRaises(ValueError):
+            MSTL(periods=(24, 24), windows=(11,))
+
+    def test_invalid_windows(self) -> None:
+        with self.assertRaises(ValueError):
+            MSTL(periods=(24, 168), windows=(10, 15))  # even window
+
+    def test_long_period_warning(self) -> None:
+        y = np.random.default_rng(0).standard_normal(50)
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            with self.assertRaises(ValueError):
+                # both periods >= n/2 -> nothing left
+                MSTL(periods=(40, 45)).fit_transform(y)
+            self.assertTrue(any(issubclass(w.category, UserWarning) for w in caught))
+
+    def test_stl_kwargs_robust(self) -> None:
+        y = self.y.copy()
+        y[100] += 20.0
+        result = MSTL(
+            periods=self.periods, iterate=1, stl_kwargs={"robust": True}
+        ).fit_transform(y)
+        self.assertTrue(np.all(np.isfinite(result.resid)))
+        self.assertEqual(result.weights.shape, y.shape)
+
+    def test_uses_pysdkit_stl(self) -> None:
+        """MSTL must be built on the local STL class (no statsmodels dependency)."""
+        self.assertIs(MSTL.__init__.__globals__.get("STL", STL), STL)
+
+
+if __name__ == "__main__":
+    unittest.main()

{pysdkit-0.4.34 → pysdkit-0.4.35}/pysdkit/tests/test_stl.py

@@ -1,57 +1,68 @@
 # -*- coding: utf-8 -*-
+"""
+Unit tests for Seasonal-Trend decomposition using LOESS (STL).
+"""
+
 import unittest
+
 import numpy as np
+
 from pysdkit import STL
 from pysdkit.tsa import STLResult
 from pysdkit.data import generate_time_series
 
 
 class TestSTL(unittest.TestCase):
-    """Test whether STL decomposition runs normally"""
+    """Test whether STL decomposition runs normally."""
 
     def setUp(self) -> None:
-        """Create time series data for testing"""
+        """Create time series data for testing."""
         np.random.seed(42)
-        # Generate a base time series
-        self.period = 12  # seasonal period
+        self.period = 12
         self.data = generate_time_series(
-            duration=120,
+            duration=240,
             periodicities=np.array([self.period]),
             num_harmonics=np.array([2]),
             std=np.array([0.5]),
+            seed=42,
         )
-        # Add a linear trend
         self.trend = np.linspace(0, 10, len(self.data))
-        self.data += self.trend
+        self.data = self.data + self.trend
 
     def test_fit_transform(self) -> None:
-        """Verify that time series decomposition runs normally"""
-        # Create an algorithm instance object
+        """Verify reconstruction identity observed = seasonal + trend + resid."""
         stl = STL(period=self.period)
         result = stl.fit_transform(self.data)
 
-        # Verify the return type
-        self.assertIsInstance(result, STLResult, "Wrong return result type")
-
-        # Verify component relationship: observed = seasonal + trend + resid
+        self.assertIsInstance(result, STLResult)
         reconstructed = result.seasonal + result.trend + result.resid
         self.assertTrue(
             np.allclose(result.observed, reconstructed, atol=1e-10),
             "Reconstructed series after decomposition does not match",
         )
+        self.assertEqual(len(result.observed), len(self.data))
+        self.assertTrue(np.all(np.isfinite(result.seasonal)))
+        self.assertTrue(np.all(np.isfinite(result.trend)))
+        self.assertTrue(np.all(np.isfinite(result.resid)))
 
     def test_default_call(self) -> None:
-        """Verify that the call method can run normally"""
-        # Create an algorithm instance object
+        """Verify that __call__ matches fit_transform."""
         stl = STL(period=self.period)
-        result = stl(self.data)
+        a = stl(self.data)
+        b = stl.fit_transform(self.data)
 
-        # Verify basic output
-        self.assertIsInstance(result, STLResult, "Wrong return result type")
-        self.assertEqual(len(result.observed), len(self.data), "Data length mismatch")
+        self.assertIsInstance(a, STLResult)
+        self.assertEqual(len(a.observed), len(self.data))
+        self.assertTrue(np.allclose(a.seasonal, b.seasonal))
+        self.assertTrue(np.allclose(a.trend, b.trend))
+        self.assertTrue(np.allclose(a.resid, b.resid))
+
+    def test_str(self) -> None:
+        """Verify the human-readable algorithm name."""
+        self.assertIn("STL", str(STL(period=12)))
 
     def test_robust_mode(self) -> None:
-        """Verify that robust and non-robust modes both run and reconstruct."""
+        """Verify that robust and non-robust modes both reconstruct."""
         data_with_outliers = self.data.copy()
         outlier_indices = [10, 30, 50, 70, 90]
         data_with_outliers[outlier_indices] += 10.0
@@ -64,39 +75,32 @@ class TestSTL(unittest.TestCase):
                 np.allclose(result.observed, reconstructed, atol=1e-10),
                 f"Reconstruction failed for robust={robust}",
             )
-            self.assertEqual(len(result.resid), len(data_with_outliers))
-            # Outlier residuals should remain finite in both modes
             self.assertTrue(np.all(np.isfinite(result.resid[outlier_indices])))
+            self.assertEqual(result.weights.shape, result.observed.shape)
 
     def test_seasonal_component(self) -> None:
-        """Verify periodicity of the seasonal component"""
+        """Verify that the seasonal component shows the expected periodicity."""
         stl = STL(period=self.period, seasonal=7)
         result = stl(self.data)
 
-        # Verify seasonal component periodicity
         seasonal = result.seasonal
         autocorr = np.correlate(seasonal, seasonal, mode="full")
         autocorr = autocorr[len(autocorr) // 2 :]
+        autocorr = autocorr / (autocorr[0] + 1e-12)
 
-        # Peaks should appear at period points
-        self.assertGreater(
-            autocorr[0], autocorr[1], "Wrong autocorrelation peak in seasonal component"
-        )
+        self.assertGreater(autocorr[0], autocorr[1])
         self.assertGreater(
             autocorr[self.period],
-            autocorr[self.period - 1],
+            autocorr[self.period // 2],
             "Seasonal component periodicity is not evident",
         )
 
     def test_trend_component(self) -> None:
-        """Verify smoothness of the trend component"""
+        """Verify smoothness / correlation of the recovered trend."""
         stl = STL(period=self.period, trend=25)
         result = stl(self.data)
 
-        # Compute first differences of the trend component
         trend_diff = np.diff(result.trend)
-
-        # Trend component should be smoother than the raw data
         data_diff = np.diff(self.data)
         self.assertLess(
             np.std(trend_diff),
@@ -104,50 +108,53 @@ class TestSTL(unittest.TestCase):
             "Trend component is not smooth enough",
         )
 
-        # Trend component should correlate with the added linear trend
         corr = np.corrcoef(result.trend, self.trend)[0, 1]
         self.assertGreater(
-            corr, 0.9, "Trend component correlation with expected trend is insufficient"
+            corr,
+            0.9,
+            "Trend component correlation with expected trend is insufficient",
         )
 
     def test_parameter_validation(self) -> None:
-        """Verify parameter validation logic"""
-        # Invalid period
+        """Verify parameter validation logic."""
         with self.assertRaises(ValueError):
             STL(period=1)
 
-        # Invalid seasonal parameter
+        # seasonal must be odd and >= 3
+        with self.assertRaises(ValueError):
+            STL(period=12, seasonal=4)
         with self.assertRaises(ValueError):
-            STL(period=12, seasonal=4)  # must be >= 7 and odd
+            STL(period=12, seasonal=2)
 
-        # Insufficient data length
+        # trend must be odd and > period
+        with self.assertRaises(ValueError):
+            STL(period=12, trend=12)
+        with self.assertRaises(ValueError):
+            STL(period=12, trend=11)
+
+        # insufficient length
         stl = STL(period=12)
         with self.assertRaises(ValueError):
-            stl.fit_transform(np.random.rand(10))  # 10 < 2*12
+            stl.fit_transform(np.random.rand(10))
 
     def test_different_iterations(self) -> None:
         """Verify that different iteration counts still yield valid decompositions."""
         configs = [
-            STL(period=self.period),
-            STL(period=self.period),
-            STL(period=self.period, robust=True),
+            (STL(period=self.period), dict()),
+            (STL(period=self.period), dict(inner_iter=5)),
+            (STL(period=self.period, robust=True), dict(outer_iter=5)),
         ]
-        calls = [
-            lambda stl: stl(self.data),
-            lambda stl: stl.fit_transform(self.data, inner_iter=5),
-            lambda stl: stl.fit_transform(self.data, outer_iter=15),
-        ]
-
-        for stl, call in zip(configs, calls):
-            result = call(stl)
+        for stl, kwargs in configs:
+            result = stl.fit_transform(self.data, **kwargs)
             reconstructed = result.seasonal + result.trend + result.resid
-            self.assertTrue(
-                np.allclose(result.observed, reconstructed, atol=1e-10),
-                "Reconstructed series after decomposition does not match",
-            )
-            self.assertEqual(len(result.observed), len(self.data))
+            self.assertTrue(np.allclose(result.observed, reconstructed, atol=1e-10))
             self.assertTrue(np.all(np.isfinite(result.resid)))
 
+    def test_mean_seasonal_near_zero(self) -> None:
+        """Seasonal component should be approximately zero-mean after low-pass removal."""
+        result = STL(period=self.period, seasonal=13).fit_transform(self.data)
+        self.assertLess(abs(np.mean(result.seasonal)), 1.0)
+
 
 if __name__ == "__main__":
     unittest.main()

{pysdkit-0.4.34 → pysdkit-0.4.35}/pysdkit/tsa/__init__.py

@@ -6,10 +6,19 @@ Created on 2025/02/10 13:25:06
 This module is used to store some valuable signal processing methods in time series analysis (TSA)
 """
 
-__all__ = ["Moving_Decomp", "dtw_distance", "STLResult", "STL"]
+__all__ = [
+    "Moving_Decomp",
+    "dtw_distance",
+    "STLResult",
+    "STL",
+    "MSTLResult",
+    "MSTL",
+]
 
 from ._moving_decomp import Moving_Decomp
 
 from ._dtw import dtw_distance
 
 from ._stl import STL, STLResult
+
+from ._mstl import MSTL, MSTLResult