dsp-props 0.1.0__tar.gz

dsp_props-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.hypothesis/
+.pytest_cache/
+build/
+dist/
+*.egg-info/
+.venv/

dsp_props-0.1.0/CITATION.cff

@@ -0,0 +1,12 @@
+cff-version: 1.2.0
+message: "Si vous utilisez dsp-props, merci de le citer comme suit."
+title: "dsp-props: property-based testing for digital signal processing"
+type: software
+authors:
+  - family-names: "Basdevant"
+    given-names: "Clément"
+    orcid: "https://orcid.org/0009-0004-7496-2365"
+license: BSD-3-Clause
+repository-code: "https://github.com/clement-basdevant/dsp-props"
+version: 0.1.0
+date-released: 2026-10-14

dsp_props-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, dsp-props contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

dsp_props-0.1.0/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.5
+Name: dsp-props
+Version: 0.1.0
+Summary: Property-based testing for digital signal processing code
+Project-URL: Homepage, https://github.com/clement-basdevant/dsp-props
+Project-URL: Source, https://github.com/clement-basdevant/dsp-props
+Project-URL: Issues, https://github.com/clement-basdevant/dsp-props/issues
+Author: Clément Basdevant
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: DSP,FFT,filters,hypothesis,metamorphic testing,property-based testing,signal processing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Hypothesis
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: hypothesis>=6.80
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: scipy>=1.11; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: scipy
+Requires-Dist: scipy>=1.11; extra == 'scipy'
+Description-Content-Type: text/markdown
+
+# dsp-props
+
+**Tests de propriété pour le traitement du signal** · *Property-based testing for DSP code*
+
+Le code DSP est souvent testé en comparant sa sortie à une référence (MATLAB, SciPy) sur quelques signaux, avec une tolérance choisie à la main. `dsp-props` vérifie plutôt des **relations qui doivent toujours tenir** (linéarité, théorème du décalage, Parseval, symétrie hermitienne, inversibilité, théorème de convolution), sur des **signaux générés automatiquement** par [Hypothesis](https://hypothesis.works/) et choisis pour piéger le code : impulsions, sinusoïdes hors grille, tons proches, quasi-Nyquist, amplitudes extrêmes, longueurs 1, premières ou 2^k ± 1. Les tolérances dépendent de l'opération (erreur en O(ε log N) pour une FFT) au lieu d'un `atol` fixe.
+
+> Statut : pré-alpha, phase 1 du [schéma directeur](docs/schema-directeur.md).
+
+## Exemple
+
+```python
+import numpy as np
+import dsp_props as dp
+
+@dp.transform(inverse=np.fft.ifft, parseval=True, real_input_hermitian=True)
+def my_fft(x):
+    return np.fft.fft(x)
+
+print(dp.verify(my_fft))
+```
+
+```
+dsp-props report for my_fft
+  ok   linearity
+  ok   circular shift
+  ok   parseval
+  ok   hermitian symmetry
+  ok   inversibility
+  ok   convolution theorem
+```
+
+En cas d'échec, `verify` lève `PropertyViolation` avec, pour chaque relation violée, le contre-exemple réduit par Hypothesis.
+
+Autres déclarations :
+
+```python
+# FFT réelle : l'inverse reçoit la longueur N
+dp.transform(inverse=np.fft.irfft, kind="rdft", parseval=True)(np.fft.rfft)
+
+# Transformée linéaire quelconque (DCT, ondelettes...)
+dp.transform(kind="generic", inverse=idct_ortho, parseval=True, parseval_scale=lambda n: 1.0)(dct_ortho)
+
+# Filtre LTI : linéarité, invariance temporelle, causalité, réponse en fréquence = B(z)/A(z).
+# La tolérance suit le conditionnement de la récursion (IIRTolerance).
+dp.lti_filter(causal=True, transfer=(b, a))(lambda x: scipy.signal.lfilter(b, a, x))
+
+# Stabilité EBSB : aucune entrée bornée par 1 ne doit dépasser le gain déclaré (entrée pire cas construite)
+dp.lti_filter(max_gain=l1_de_h)(mon_filtre)
+
+# Rééchantillonneur rationnel L/M : linéarité, retard de M échantillons en entrée = retard de L en sortie,
+# longueur ceil(N L / M), gain DC, et rejet du repliement quand on décime
+dp.resampler(2, 3)(lambda x: scipy.signal.resample_poly(x, 2, 3))
+
+# Traitement par blocs : tout découpage (blocs vides et d'un échantillon compris) doit donner la même sortie
+@dp.streaming()
+class MonFiltre:
+    def process(self, bloc): ...
+
+# Fonction à état explicite, par exemple lfilter avec zi
+dp.stateful(lambda bloc, z: scipy.signal.lfilter(b, a, bloc, zi=z), init_state=np.zeros(2))
+```
+
+## En ligne de commande
+
+`dsp-props check` trouve tous les opérateurs déclarés dans un module ou un fichier et les vérifie :
+
+```
+$ dsp-props check examples/filters.py --examples 100
+FAIL examples/filters.py:buggy_fft  (4 relations, 3.4s)
+      FAIL inversibility
+           inversibility: L2 error 2.000e+00 exceeds tolerance 6.280e-15 (N=2, ref norm 1.414e+00)
+           minimal input: [1, 1]
+ok   examples/filters.py:fft  (6 relations, 6.5s)
+ok   examples/filters.py:lowpass  (4 relations, 3.1s)
+ok   examples/filters.py:resample_2_3  (5 relations, 2.8s)
+
+3/4 operators pass
+```
+
+Cibles possibles : `paquet.module`, `fichier.py`, `module:operateur`. Options : `--json`, `--markdown`, `--html`, `--examples N`, `--derandomize` (entrées reproductibles en CI). Code de sortie 1 si une relation échoue, ce qui suffit pour bloquer une CI.
+
+## Code C
+
+`dsp_props.adapters` charge une fonction C (bibliothèque partagée, via ctypes) et la déclare comme n'importe quel opérateur. Convention : `void f(const double *x, size_t n, double *y, double *etat)`.
+
+```python
+from dsp_props.adapters import build_shared, c_function, c_block_processor
+
+lib = build_shared("examples/c/biquad.c")
+dp.verify(dp.lti_filter(transfer=(b, a))(c_function(lib, "biquad", state_size=2)))
+dp.verify(dp.streaming()(c_block_processor(lib, "biquad", state_size=2)))
+```
+
+`examples/c/biquad.c` contient un biquad correct et deux variantes boguées. Celle qui oublie une variable d'état entre deux blocs passe tous les tests sur un appel unique et n'est détectée que par l'invariance au découpage en blocs.
+
+## Tolérances calibrées
+
+Une borne fixe en ε · log N ne décrit pas toutes les bibliothèques : sur N = 2…1200, la FFT de PyTorch (MKL) atteint 195 ε contre 4 ε pour NumPy, selon la factorisation de N. `dp.calibrate` mesure l'erreur réelle contre une référence en précision étendue et en déduit la tolérance :
+
+```python
+tol = dp.calibrate(torch_fft, lengths=range(1, 513))   # refuse un opérateur faux
+print(tol.summary())
+dp.transform(inverse=torch_ifft, parseval=True, tolerance=tol)(torch_fft)
+```
+
+`python benchmarks/error_profile.py` produit le profil d'erreur complet (`benchmarks/error_profile.csv`), et `python benchmarks/plot_error_profile.py` la figure ci-dessous.
+
+![Erreur relative de la FFT selon N, NumPy contre PyTorch](https://raw.githubusercontent.com/clement-basdevant/dsp-props/main/docs/figures/error_profile.png)
+
+## Valider l'outil : la suite de mutants
+
+`mutants/` contient 31 implémentations volontairement boguées, réparties en six familles :
+
+| Famille | Mutants |
+| --- | --- |
+| FFT complexe | 1/N oublié, conjugaison manquante, décalage d'un indice, normalisation erronée, calcul en float32, signe des twiddles, dernier échantillon ignoré, offset constant |
+| FFT réelle (`rfft`) | un bin de moins, inverse qui ignore N, bin de Nyquist divisé par 2, spectre conjugué, inverse sans symétrie hermitienne |
+| DCT-II orthonormée | poids du coefficient DC oublié, inverse du mauvais type, calcul en float32 |
+| Filtre IIR (ordre 4, résonant) | récursion en float32, filtfilt déclaré causal, coefficients qui changent en cours de route, état initial non nul, gain faux de 1 % |
+| Rééchantillonneur 2/3 | gain d'interpolation oublié, anti-repliement trop faible, longueur arrondie par défaut, phase qui dépend de la parité de N, filtrage en float32, état global qui fuit d'un appel à l'autre |
+| Streaming par blocs | état remis à zéro, historique décalé d'un échantillon, bloc vide qui efface l'état, blocs courts non filtrés |
+
+```
+python mutants/run_mutants.py
+...
+Mutation score: 31/31 (100%)
+```
+
+Les contre-exemples sont minuscules : pour 27 mutants sur 30 (hors `iir_wrong_gain`, détecté sur la réponse impulsionnelle), le signal réduit par Hypothesis fait au plus 3 échantillons (médiane : 2), et 27 mutants tombent dans les 3 premières entrées générées. Les exceptions sont attendues : 97 échantillons pour un filtre qui change après 64, et 192 pour les relations de gain DC et de repliement, qui exigent des signaux longs. `python mutants/run_mutants.py --json benchmarks/mutant_results.json` enregistre ces mesures.
+
+Chaque rapport donne l'entrée minimale et s'exporte :
+
+```python
+report = dp.verify(ma_fft, raise_on_failure=False)
+print(report)              # FAIL inversibility ... minimal input: [1, 1]
+report.to_json()           # pour la CI ou un tableau de résultats
+report.to_markdown()       # pour une PR ou un ticket
+```
+
+Angle mort documenté : un filtre faux mais toujours linéaire, invariant et causal (gain multiplié par 1,01) passe toutes les relations si l'on ne déclare pas sa fonction de transfert. Avec `transfer=(b, a)`, il est détecté.
+
+## Chasse aux bugs dans de vraies bibliothèques
+
+`benchmarks/campaign.py` applique les relations à SciPy, NumPy, PyTorch, librosa et torchaudio (46 cibles).
+Premier bug signalé : [scipy/scipy#26406](https://github.com/scipy/scipy/issues/26406). Résultats détaillés dans `benchmarks/RESULTS-*.md`.
+
+## Installation
+
+Une fois publié sur PyPI :
+
+```
+python -m pip install "dsp-props[scipy]"   # [scipy] pour les filtres IIR et les fonctions de transfert
+```
+
+En développement :
+
+```
+git clone https://github.com/clement-basdevant/dsp-props
+cd dsp-props
+python -m pip install -e ".[dev]"
+python -m pytest
+```
+
+## Organisation
+
+| Dossier | Contenu |
+| --- | --- |
+| `src/dsp_props/core/` | Modèles de tolérance, comparaison robuste |
+| `src/dsp_props/generators/` | Stratégies Hypothesis pour signaux |
+| `src/dsp_props/relations/` | Une relation métamorphique = une classe |
+| `mutants/` | Implémentations boguées et calcul du score de mutation |
+| `tests/` | Tests de l'outil lui-même |
+| `docs/` | Schéma directeur et documentation |
+| `papers/` | Bibliographie et brouillons d'articles |
+
+## Feuille de route
+
+1. **Fondations** : générateurs, relations de base, tests sur `numpy.fft` *(fait)*
+2. **Moteur de tolérance** : modèles d'erreur par classe d'opérateur, calibration contre précision étendue *(fait)*
+3. **Relations avancées** : causalité, stabilité, streaming par blocs, multicadence *(fait)*
+4. **Suite de mutants** : une quarantaine de mutants, essai sur `scipy.signal` *(31 mutants, campagne sur 46 cibles réelles ; à compléter)*
+5. **Shrinking et rapport** : contre-exemples minimaux, rapport HTML *(fait)*
+6. **Auto-découverte et adaptateur C** *(fait : `dsp-props check`, `dsp_props.adapters`)*
+
+## Licence
+
+BSD-3-Clause, comme NumPy et SciPy.

dsp_props-0.1.0/README.md

@@ -0,0 +1,187 @@
+# dsp-props
+
+**Tests de propriété pour le traitement du signal** · *Property-based testing for DSP code*
+
+Le code DSP est souvent testé en comparant sa sortie à une référence (MATLAB, SciPy) sur quelques signaux, avec une tolérance choisie à la main. `dsp-props` vérifie plutôt des **relations qui doivent toujours tenir** (linéarité, théorème du décalage, Parseval, symétrie hermitienne, inversibilité, théorème de convolution), sur des **signaux générés automatiquement** par [Hypothesis](https://hypothesis.works/) et choisis pour piéger le code : impulsions, sinusoïdes hors grille, tons proches, quasi-Nyquist, amplitudes extrêmes, longueurs 1, premières ou 2^k ± 1. Les tolérances dépendent de l'opération (erreur en O(ε log N) pour une FFT) au lieu d'un `atol` fixe.
+
+> Statut : pré-alpha, phase 1 du [schéma directeur](docs/schema-directeur.md).
+
+## Exemple
+
+```python
+import numpy as np
+import dsp_props as dp
+
+@dp.transform(inverse=np.fft.ifft, parseval=True, real_input_hermitian=True)
+def my_fft(x):
+    return np.fft.fft(x)
+
+print(dp.verify(my_fft))
+```
+
+```
+dsp-props report for my_fft
+  ok   linearity
+  ok   circular shift
+  ok   parseval
+  ok   hermitian symmetry
+  ok   inversibility
+  ok   convolution theorem
+```
+
+En cas d'échec, `verify` lève `PropertyViolation` avec, pour chaque relation violée, le contre-exemple réduit par Hypothesis.
+
+Autres déclarations :
+
+```python
+# FFT réelle : l'inverse reçoit la longueur N
+dp.transform(inverse=np.fft.irfft, kind="rdft", parseval=True)(np.fft.rfft)
+
+# Transformée linéaire quelconque (DCT, ondelettes...)
+dp.transform(kind="generic", inverse=idct_ortho, parseval=True, parseval_scale=lambda n: 1.0)(dct_ortho)
+
+# Filtre LTI : linéarité, invariance temporelle, causalité, réponse en fréquence = B(z)/A(z).
+# La tolérance suit le conditionnement de la récursion (IIRTolerance).
+dp.lti_filter(causal=True, transfer=(b, a))(lambda x: scipy.signal.lfilter(b, a, x))
+
+# Stabilité EBSB : aucune entrée bornée par 1 ne doit dépasser le gain déclaré (entrée pire cas construite)
+dp.lti_filter(max_gain=l1_de_h)(mon_filtre)
+
+# Rééchantillonneur rationnel L/M : linéarité, retard de M échantillons en entrée = retard de L en sortie,
+# longueur ceil(N L / M), gain DC, et rejet du repliement quand on décime
+dp.resampler(2, 3)(lambda x: scipy.signal.resample_poly(x, 2, 3))
+
+# Traitement par blocs : tout découpage (blocs vides et d'un échantillon compris) doit donner la même sortie
+@dp.streaming()
+class MonFiltre:
+    def process(self, bloc): ...
+
+# Fonction à état explicite, par exemple lfilter avec zi
+dp.stateful(lambda bloc, z: scipy.signal.lfilter(b, a, bloc, zi=z), init_state=np.zeros(2))
+```
+
+## En ligne de commande
+
+`dsp-props check` trouve tous les opérateurs déclarés dans un module ou un fichier et les vérifie :
+
+```
+$ dsp-props check examples/filters.py --examples 100
+FAIL examples/filters.py:buggy_fft  (4 relations, 3.4s)
+      FAIL inversibility
+           inversibility: L2 error 2.000e+00 exceeds tolerance 6.280e-15 (N=2, ref norm 1.414e+00)
+           minimal input: [1, 1]
+ok   examples/filters.py:fft  (6 relations, 6.5s)
+ok   examples/filters.py:lowpass  (4 relations, 3.1s)
+ok   examples/filters.py:resample_2_3  (5 relations, 2.8s)
+
+3/4 operators pass
+```
+
+Cibles possibles : `paquet.module`, `fichier.py`, `module:operateur`. Options : `--json`, `--markdown`, `--html`, `--examples N`, `--derandomize` (entrées reproductibles en CI). Code de sortie 1 si une relation échoue, ce qui suffit pour bloquer une CI.
+
+## Code C
+
+`dsp_props.adapters` charge une fonction C (bibliothèque partagée, via ctypes) et la déclare comme n'importe quel opérateur. Convention : `void f(const double *x, size_t n, double *y, double *etat)`.
+
+```python
+from dsp_props.adapters import build_shared, c_function, c_block_processor
+
+lib = build_shared("examples/c/biquad.c")
+dp.verify(dp.lti_filter(transfer=(b, a))(c_function(lib, "biquad", state_size=2)))
+dp.verify(dp.streaming()(c_block_processor(lib, "biquad", state_size=2)))
+```
+
+`examples/c/biquad.c` contient un biquad correct et deux variantes boguées. Celle qui oublie une variable d'état entre deux blocs passe tous les tests sur un appel unique et n'est détectée que par l'invariance au découpage en blocs.
+
+## Tolérances calibrées
+
+Une borne fixe en ε · log N ne décrit pas toutes les bibliothèques : sur N = 2…1200, la FFT de PyTorch (MKL) atteint 195 ε contre 4 ε pour NumPy, selon la factorisation de N. `dp.calibrate` mesure l'erreur réelle contre une référence en précision étendue et en déduit la tolérance :
+
+```python
+tol = dp.calibrate(torch_fft, lengths=range(1, 513))   # refuse un opérateur faux
+print(tol.summary())
+dp.transform(inverse=torch_ifft, parseval=True, tolerance=tol)(torch_fft)
+```
+
+`python benchmarks/error_profile.py` produit le profil d'erreur complet (`benchmarks/error_profile.csv`), et `python benchmarks/plot_error_profile.py` la figure ci-dessous.
+
+![Erreur relative de la FFT selon N, NumPy contre PyTorch](https://raw.githubusercontent.com/clement-basdevant/dsp-props/main/docs/figures/error_profile.png)
+
+## Valider l'outil : la suite de mutants
+
+`mutants/` contient 31 implémentations volontairement boguées, réparties en six familles :
+
+| Famille | Mutants |
+| --- | --- |
+| FFT complexe | 1/N oublié, conjugaison manquante, décalage d'un indice, normalisation erronée, calcul en float32, signe des twiddles, dernier échantillon ignoré, offset constant |
+| FFT réelle (`rfft`) | un bin de moins, inverse qui ignore N, bin de Nyquist divisé par 2, spectre conjugué, inverse sans symétrie hermitienne |
+| DCT-II orthonormée | poids du coefficient DC oublié, inverse du mauvais type, calcul en float32 |
+| Filtre IIR (ordre 4, résonant) | récursion en float32, filtfilt déclaré causal, coefficients qui changent en cours de route, état initial non nul, gain faux de 1 % |
+| Rééchantillonneur 2/3 | gain d'interpolation oublié, anti-repliement trop faible, longueur arrondie par défaut, phase qui dépend de la parité de N, filtrage en float32, état global qui fuit d'un appel à l'autre |
+| Streaming par blocs | état remis à zéro, historique décalé d'un échantillon, bloc vide qui efface l'état, blocs courts non filtrés |
+
+```
+python mutants/run_mutants.py
+...
+Mutation score: 31/31 (100%)
+```
+
+Les contre-exemples sont minuscules : pour 27 mutants sur 30 (hors `iir_wrong_gain`, détecté sur la réponse impulsionnelle), le signal réduit par Hypothesis fait au plus 3 échantillons (médiane : 2), et 27 mutants tombent dans les 3 premières entrées générées. Les exceptions sont attendues : 97 échantillons pour un filtre qui change après 64, et 192 pour les relations de gain DC et de repliement, qui exigent des signaux longs. `python mutants/run_mutants.py --json benchmarks/mutant_results.json` enregistre ces mesures.
+
+Chaque rapport donne l'entrée minimale et s'exporte :
+
+```python
+report = dp.verify(ma_fft, raise_on_failure=False)
+print(report)              # FAIL inversibility ... minimal input: [1, 1]
+report.to_json()           # pour la CI ou un tableau de résultats
+report.to_markdown()       # pour une PR ou un ticket
+```
+
+Angle mort documenté : un filtre faux mais toujours linéaire, invariant et causal (gain multiplié par 1,01) passe toutes les relations si l'on ne déclare pas sa fonction de transfert. Avec `transfer=(b, a)`, il est détecté.
+
+## Chasse aux bugs dans de vraies bibliothèques
+
+`benchmarks/campaign.py` applique les relations à SciPy, NumPy, PyTorch, librosa et torchaudio (46 cibles).
+Premier bug signalé : [scipy/scipy#26406](https://github.com/scipy/scipy/issues/26406). Résultats détaillés dans `benchmarks/RESULTS-*.md`.
+
+## Installation
+
+Une fois publié sur PyPI :
+
+```
+python -m pip install "dsp-props[scipy]"   # [scipy] pour les filtres IIR et les fonctions de transfert
+```
+
+En développement :
+
+```
+git clone https://github.com/clement-basdevant/dsp-props
+cd dsp-props
+python -m pip install -e ".[dev]"
+python -m pytest
+```
+
+## Organisation
+
+| Dossier | Contenu |
+| --- | --- |
+| `src/dsp_props/core/` | Modèles de tolérance, comparaison robuste |
+| `src/dsp_props/generators/` | Stratégies Hypothesis pour signaux |
+| `src/dsp_props/relations/` | Une relation métamorphique = une classe |
+| `mutants/` | Implémentations boguées et calcul du score de mutation |
+| `tests/` | Tests de l'outil lui-même |
+| `docs/` | Schéma directeur et documentation |
+| `papers/` | Bibliographie et brouillons d'articles |
+
+## Feuille de route
+
+1. **Fondations** : générateurs, relations de base, tests sur `numpy.fft` *(fait)*
+2. **Moteur de tolérance** : modèles d'erreur par classe d'opérateur, calibration contre précision étendue *(fait)*
+3. **Relations avancées** : causalité, stabilité, streaming par blocs, multicadence *(fait)*
+4. **Suite de mutants** : une quarantaine de mutants, essai sur `scipy.signal` *(31 mutants, campagne sur 46 cibles réelles ; à compléter)*
+5. **Shrinking et rapport** : contre-exemples minimaux, rapport HTML *(fait)*
+6. **Auto-découverte et adaptateur C** *(fait : `dsp-props check`, `dsp_props.adapters`)*
+
+## Licence
+
+BSD-3-Clause, comme NumPy et SciPy.

dsp_props-0.1.0/examples/c/biquad.c

@@ -0,0 +1,43 @@
+/* Biquad low-pass (Butterworth, fc = 0.2 x Nyquist), transposed direct form II.
+ *
+ * Calling convention understood by dsp_props.adapters:
+ *   void f(const double *x, size_t n, double *y, double *state)
+ * The state (2 doubles) carries the filter memory from one block to the next.
+ */
+#include <stddef.h>
+
+static const double B[3] = {0.06745527388907189, 0.13491054777814378, 0.06745527388907189};
+static const double A[3] = {1.0, -1.1429805025399011, 0.41280159809618877};
+
+void biquad(const double *x, size_t n, double *y, double *s)
+{
+    for (size_t i = 0; i < n; i++) {
+        double out = B[0] * x[i] + s[0];
+        s[0] = B[1] * x[i] - A[1] * out + s[1];
+        s[1] = B[2] * x[i] - A[2] * out;
+        y[i] = out;
+    }
+}
+
+/* Bug: the accumulator is single precision. */
+void biquad_float_acc(const double *x, size_t n, double *y, double *s)
+{
+    for (size_t i = 0; i < n; i++) {
+        float out = (float)(B[0] * x[i] + s[0]);
+        s[0] = B[1] * x[i] - A[1] * out + s[1];
+        s[1] = B[2] * x[i] - A[2] * out;
+        y[i] = out;
+    }
+}
+
+/* Bug: the second state variable is not carried across blocks (local copy). */
+void biquad_drops_state(const double *x, size_t n, double *y, double *s)
+{
+    double s1 = 0.0;
+    for (size_t i = 0; i < n; i++) {
+        double out = B[0] * x[i] + s[0];
+        s[0] = B[1] * x[i] - A[1] * out + s1;
+        s1 = B[2] * x[i] - A[2] * out;
+        y[i] = out;
+    }
+}

dsp_props-0.1.0/examples/filters.py

@@ -0,0 +1,29 @@
+"""Example operators for `dsp-props check examples/filters.py`."""
+
+import numpy as np
+from scipy import signal
+
+import dsp_props as dp
+
+B, A = signal.butter(4, 0.2)
+
+
+@dp.transform(inverse=np.fft.ifft, parseval=True, real_input_hermitian=True)
+def fft(x):
+    return np.fft.fft(x)
+
+
+@dp.lti_filter(transfer=(B, A))
+def lowpass(x):
+    return signal.lfilter(B, A, x)
+
+
+@dp.resampler(2, 3)
+def resample_2_3(x):
+    return signal.resample_poly(x, 2, 3)
+
+
+@dp.transform(inverse=np.fft.ifft)
+def buggy_fft(x):
+    """Off by one bin: dsp-props reports the smallest input that shows it."""
+    return np.roll(np.fft.fft(x), 1)

dsp_props-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dsp-props"
+dynamic = ["version"]
+description = "Property-based testing for digital signal processing code"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Clément Basdevant" }]
+keywords = ["signal processing", "DSP", "property-based testing", "metamorphic testing", "hypothesis", "FFT", "filters"]
+dependencies = ["numpy>=1.24", "hypothesis>=6.80"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Hypothesis",
+    "Framework :: Pytest",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+Homepage = "https://github.com/clement-basdevant/dsp-props"
+Source = "https://github.com/clement-basdevant/dsp-props"
+Issues = "https://github.com/clement-basdevant/dsp-props/issues"
+
+[project.scripts]
+dsp-props = "dsp_props.cli:main"
+
+[project.optional-dependencies]
+# transfer-function checks, IIR error model and the examples use scipy.signal
+scipy = ["scipy>=1.11"]
+dev = ["pytest>=7", "scipy>=1.11", "build", "twine"]
+
+[tool.hatch.version]
+path = "src/dsp_props/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "examples", "README.md", "LICENSE", "CITATION.cff", "pyproject.toml"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dsp_props"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "."]

dsp_props-0.1.0/src/dsp_props/__init__.py

@@ -0,0 +1,39 @@
+"""dsp-props: property-based testing for digital signal processing code."""
+
+from . import core, generators, relations
+from .core import calibrate
+from .api import (
+    PropertyViolation,
+    Report,
+    LTISpec,
+    MultirateSpec,
+    resampler,
+    StreamingSpec,
+    lti_filter,
+    TransformSpec,
+    stateful,
+    streaming,
+    transform,
+    verify,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "core",
+    "generators",
+    "relations",
+    "transform",
+    "calibrate",
+    "streaming",
+    "lti_filter",
+    "LTISpec",
+    "resampler",
+    "MultirateSpec",
+    "stateful",
+    "StreamingSpec",
+    "verify",
+    "Report",
+    "TransformSpec",
+    "PropertyViolation",
+]

dsp_props-0.1.0/src/dsp_props/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())