pyFDN 0.3.0__tar.gz → 0.4.1__tar.gz

{pyfdn-0.3.0 → pyfdn-0.4.1}/CONTRIBUTING.rst

@@ -150,11 +150,11 @@ documentation sources, and tests:
   time-domain graph. ``process_fdn`` uses ``MatrixFIR`` for polynomial feedback
   matrices; ``SOSBank`` implements per-delay-line filter cascades used for
   frequency-dependent absorption.
-* ``src/pyFDN/graphicEQ/`` contains graphic-EQ and absorption-filter design,
-  while ``src/pyFDN/translate/`` converts between delay state-space, transfer
+* ``src/pyFDN/eq/`` contains every EQ and absorption-filter design, while
+  ``src/pyFDN/translate/`` converts between delay state-space, transfer
   function, pole-residue, impulse-response, and FLAMO representations.
-* ``src/pyFDN/train/`` contains the trainable FDN construction, objectives,
-  and optimization loop. ``src/pyFDN/auxiliary/`` holds shared analysis,
+* ``src/pyFDN/train/`` contains the trainable FDN construction, the composable
+  losses in ``train/losses/``, and the optimization loop. ``src/pyFDN/auxiliary/`` holds shared analysis,
   plotting, audio, delay, and numerical helpers.
 * ``examples/`` contains executable Marimo notebooks. Metadata at the top of
   each ``example_*.py`` file drives the generated documentation gallery.

pyfdn-0.4.1/HISTORY.rst

@@ -0,0 +1,101 @@
+=======
+History
+=======
+
+0.4.1 (2026-08-24)
+------------------
+
+* **Breaking:** rename the ``Fs`` parameter to ``fs`` everywhere it is still
+  spelled with a capital -- ``dss_to_flamo``, ``dss_to_pr``, ``delay_module``
+  and ``SDN``. Every other sampling-rate argument in the package was already
+  ``fs``, and the odd one out forced callers to remember which spelling each
+  function wanted. ``SDN`` also renames its ``fs`` attribute and the ``"fs"``
+  key of the dictionary ``SDN.compute()`` returns.
+
+0.4.0 (2026-08-23)
+------------------
+
+* **Breaking:** replace ``train_fdn``'s ``mode`` string, and the ``target``,
+  ``criteria``, ``sparsity_alpha`` and ``mss_nfft`` arguments that went with
+  it, with a composed loss object. An objective is now written out --
+  ``FlatMagnitude() + 0.2 * Sparsity(param(model, "feedback"))`` -- and every
+  loss is a function of the impulse response, carried as a ``Response``, so
+  losses own their reference data and one objective can fit two different
+  references. ``pyFDN.train.objectives`` and ``build_objective`` are gone.
+* **Breaking:** collect every EQ design in ``pyFDN.eq`` (formerly
+  ``pyFDN.graphicEQ``) behind one ``EQDesign`` interface, with ``GraphicEQ``,
+  ``FirstOrderShelf`` and ``OnePole`` sharing a single implementation across
+  the numpy and torch backends.
+* **Breaking:** remove ``absorption_filters`` and ``absorption_to_rt``; the FIR
+  absorption path they served has no callers left.
+* **Breaking:** name the three filter hooks ``post_delay``, ``post_matrix`` and
+  ``post_output`` everywhere -- on ``FDNBuild``, in the FLAMO graph, in the
+  plots and in the JSON schema -- and add the slot for the third. The build
+  schema is version 2; version 1 files no longer load.
+* Fix colorless training on a lossless FDN, whose poles sit on the unit circle
+  and leave ``|H|`` unbounded. ``build_fdn`` now defaults ``alias_decay_db``
+  from ``rt`` (``LOSSLESS_ALIAS_DECAY_DB`` when ``rt`` is None) and
+  ``trainable_from_build`` threads it into every module, so a magnitude
+  objective sees a bounded response.
+* Train the decay: ``DecayFilter`` parametrizes the in-loop absorption filter
+  by reverberation time per band, so the loop stays contractive for every value
+  the parameter can take, and takes either one RT curve for the network or one
+  per delay line. ``OutputEQ`` trains the output filter outside the recursion,
+  the only part of an FDN that shapes the spectral envelope without touching
+  the decay. Both are passed as the ``post_delay`` and ``post_output`` hooks of
+  ``trainable_from_build``.
+* Add the losses that go with it: ``AsymmetricFlatMagnitude``,
+  ``FlatSpectrogram``, ``MatchEnergyDecay``, ``MatchCumulativeEnergy``,
+  ``MatchMagnitude``, ``MatchSpectrogram``, ``MatchMelSpectrogram``,
+  ``MatchImpulseResponse``, ``Energy``, ``Sparsity``, ``L1`` and ``L2``.
+* Resolve trainable parameters by name: ``param(model, "feedback")`` fails
+  where you write it with the list of available names, and ``params(model)``
+  enumerates them.
+* Export the FLAMO graph builders (``assemble_fdn_core``, ``wrap_fdn_shell``,
+  ``gain_module``, ``delay_module``, ``matrix_module``, ``fir_matrix_module``,
+  ``sos_filter_module``, ``hook_module``, ``DecayFilter``, ``OutputEQ``) from
+  the top-level namespace.
+* Make ``build_to_impz`` apply all three hooks, so it no longer rejects builds
+  that carry an output EQ, and make ``extract_build`` refuse a hook it cannot
+  bake rather than silently dropping it.
+* Add an example notebook that fits every parameter of an FDN, decay included,
+  to a measured concert-hall RIR, and document the loss rationale and
+  measurements in ``docs/training_losses.rst``.
+* Fix stereo orientation in ``labeled_audio``, which decoded a stereo render as
+  thousands of channels.
+* Check packaging metadata in CI and fail the documentation build on notebook
+  cell errors.
+
+0.3.0 (2026-08-17)
+------------------
+
+* **Breaking:** replace the ``pyFDN.dsp`` subpackage with ``pyFDN.td``. The
+  top-level ``FeedbackDelay``, ``FIRMatrixFilter`` and ``SOSFilterBank``
+  exports are gone; use ``pyFDN.td`` operators instead.
+* **Breaking:** ship the packaged colorless-FDN presets as JSON rather than
+  MATLAB ``.mat`` files.
+* Add ``pyFDN.td``, a time-domain block-based processing graph built on NumPy
+  alone (no torch, no FFT), with the ``Series``, ``Parallel`` and
+  ``Recursion`` connectors and stateful ``Gain``, ``Delay``, ``SOSBank``,
+  ``MatrixFIR``, ``MatrixConvolver`` and ``TimeVaryingMatrix`` operators.
+* Add ``load_fdn_build``, ``save_fdn_build``, ``fdn_build_from_dict`` and
+  ``fdn_build_to_dict`` for reading and writing FDN builds as JSON.
+* Add an FDN-to-FAUST example that compiles a pyFDN design with adac, and a
+  reverberation-enhancement example.
+* Improve the example gallery and stop tracking generated documentation in the
+  repository.
+* Test on Python 3.14 in CI and the documentation build.
+
+0.2.0 (2026-08-10)
+------------------
+
+* Package compact audio examples and predefined colorless-FDN coefficients so
+  browser-hosted tutorials work without repository-relative files.
+* Add public APIs for packaged audio, FDN presets, and paper references.
+* Add generated documentation galleries and wheel-content checks.
+* Keep decay-estimation dependencies optional for a smaller core installation.
+
+0.1.0 (2025-07-02)
+------------------
+
+* First release on PyPI.

{pyfdn-0.3.0 → pyfdn-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyFDN
-Version: 0.3.0
+Version: 0.4.1
 Summary: Python library for Feedback Delay Networks
 Author: Sebastian J. Schlecht, Facundo Franchino, Jeremy Bai
 Maintainer: Facundo Franchino, Sebastian J. Schlecht
@@ -148,17 +148,17 @@ All main functions are accessible directly from the top-level ``pyFDN`` namespac
     feedback = pyFDN.random_orthogonal(len(delays))
 
     # one-pole absorption filters targeting RT of 1.2 s at DC and 0.9 s at Nyquist
-    absorption = pyFDN.one_pole_absorption(1.2, 0.9, delays, fs)
+    absorption = pyFDN.decay_to_one_pole(1.2, 0.9, delays, fs)
 
     # convert delay state-space to standard state-space (A_ss, b, c, d)
     A_ss, b, c, d = pyFDN.dss_to_ss(delays, feedback)
 
 Alternatively, import specific functions directly::
 
-    from pyFDN import random_orthogonal, one_pole_absorption, lin_to_db
+    from pyFDN import decay_to_one_pole, lin_to_db, random_orthogonal
 
     feedback = random_orthogonal(4)
-    absorption = one_pole_absorption(1.2, 0.9, [100, 150, 200, 250], 48_000)
+    absorption = decay_to_one_pole(1.2, 0.9, [100, 150, 200, 250], 48_000)
 
 
 Development

{pyfdn-0.3.0 → pyfdn-0.4.1}/README.rst

@@ -78,17 +78,17 @@ All main functions are accessible directly from the top-level ``pyFDN`` namespac
     feedback = pyFDN.random_orthogonal(len(delays))
 
     # one-pole absorption filters targeting RT of 1.2 s at DC and 0.9 s at Nyquist
-    absorption = pyFDN.one_pole_absorption(1.2, 0.9, delays, fs)
+    absorption = pyFDN.decay_to_one_pole(1.2, 0.9, delays, fs)
 
     # convert delay state-space to standard state-space (A_ss, b, c, d)
     A_ss, b, c, d = pyFDN.dss_to_ss(delays, feedback)
 
 Alternatively, import specific functions directly::
 
-    from pyFDN import random_orthogonal, one_pole_absorption, lin_to_db
+    from pyFDN import decay_to_one_pole, lin_to_db, random_orthogonal
 
     feedback = random_orthogonal(4)
-    absorption = one_pole_absorption(1.2, 0.9, [100, 150, 200, 250], 48_000)
+    absorption = decay_to_one_pole(1.2, 0.9, [100, 150, 200, 250], 48_000)
 
 
 Development
@@ -112,4 +112,4 @@ Helpful links
 * `List of papers on Feedback Delay Networks <https://github.com/gdalsanto/delay-network-reverbs>`_ .
 * `Multislope Estimation library <https://github.com/artificial-audio/multislope>`_ .
 * `FLAMO (An Open-Source Library for Frequency-Domain Differentiable Audio Processing) <https://github.com/gdalsanto/flamo>`_ .
-* `ADAC (Automatic Differentiable Audio Compilation) library <https://github.com/cucuwritescode/adac>`_ .
+* `ADAC (Automatic Differentiable Audio Compilation) library <https://github.com/cucuwritescode/adac>`_ .

{pyfdn-0.3.0 → pyfdn-0.4.1}/docs/api_reference.rst

@@ -83,14 +83,9 @@ Acoustics & Absorption
    :toctree: generated/
    :nosignatures:
 
-   pyFDN.absorption_filters
-   pyFDN.first_order_absorption
-   pyFDN.first_order_shelving_eq
-   pyFDN.one_pole_absorption
    pyFDN.sos_gain_per_sample_curves
    pyFDN.echo_density
    pyFDN.edc
-   pyFDN.absorption_to_rt
    pyFDN.estimate_initial_level_bands
    pyFDN.estimate_rt_bands
    pyFDN.octave_bands
@@ -100,19 +95,35 @@ Acoustics & Absorption
    pyFDN.slope_amplitude_to_level
    pyFDN.slope_to_rt
 
-Graphic EQ
-----------
+EQ Design (``pyFDN.eq``)
+-------------------------
+
+Explicit functions map either decay targets or gain targets onto a named
+filter design. The same functions run in NumPy or Torch; the trainable
+:class:`pyFDN.DecayFilter` and :class:`pyFDN.OutputEQ` modules use these
+mappings inside a training loop. ``EQDesign`` is the literal choice of
+``"graphic_eq"``, ``"first_order_shelf"``, or ``"one_pole"`` used by those
+modules.
 
 .. autosummary::
    :toctree: generated/
    :nosignatures:
 
-   pyFDN.design_geq
-   pyFDN.graphic_eq
-   pyFDN.absorption_geq
+   pyFDN.EQDesign
+   pyFDN.decay_to_geq
+   pyFDN.decay_to_first_order_shelf
+   pyFDN.decay_to_one_pole
+   pyFDN.gain_to_geq
+   pyFDN.gain_to_bounded_geq
+   pyFDN.gain_to_first_order_shelf
+   pyFDN.gain_to_one_pole
+   pyFDN.geq_design_matrix
+   pyFDN.lowshelf_biquad
+   pyFDN.highshelf_biquad
+   pyFDN.peaking_biquad
+   pyFDN.first_order_shelf_biquad
+   pyFDN.one_pole_biquad
    pyFDN.probe_sos
-   pyFDN.shelving_filter
-   pyFDN.bandpass_filter
 
 Time-Domain Graph (``pyFDN.td``)
 --------------------------------
@@ -151,6 +162,29 @@ Delay Utilities
    pyFDN.flamo_time_response
    pyFDN.flamo_freq_response
 
+Building a FLAMO Graph
+----------------------
+
+An FDN as FLAMO modules, assembled from numpy values. The three filter hooks --
+``post_delay`` inside the loop, ``post_matrix`` on the feedback path,
+``post_output`` on the wet signal -- are the same three
+:func:`pyFDN.process_fdn` takes, in the same positions and under the same names.
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   pyFDN.assemble_fdn_core
+   pyFDN.wrap_fdn_shell
+   pyFDN.gain_module
+   pyFDN.delay_module
+   pyFDN.matrix_module
+   pyFDN.fir_matrix_module
+   pyFDN.sos_filter_module
+   pyFDN.hook_module
+   pyFDN.DecayFilter
+   pyFDN.OutputEQ
+
 Polynomial & Matrix Maths
 --------------------------
 
@@ -265,6 +299,38 @@ Training
    pyFDN.Trainable
    pyFDN.train_fdn
    pyFDN.TrainLog
+   pyFDN.LOSSLESS_ALIAS_DECAY_DB
+
+Training Objectives
+-------------------
+
+An objective is a weighted sum of losses, composed with ``+`` and ``*``. Losses
+on the impulse response read a :class:`pyFDN.Response`; losses on a model
+parameter take a :class:`pyFDN.ParamRef` from :func:`pyFDN.param`.
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   pyFDN.Response
+   pyFDN.model_response
+   pyFDN.param
+   pyFDN.params
+   pyFDN.ParamRef
+   pyFDN.Loss
+   pyFDN.FlatMagnitude
+   pyFDN.AsymmetricFlatMagnitude
+   pyFDN.FlatSpectrogram
+   pyFDN.MatchMagnitude
+   pyFDN.MatchSpectrogram
+   pyFDN.MatchMelSpectrogram
+   pyFDN.MatchImpulseResponse
+   pyFDN.MatchEnergyDecay
+   pyFDN.MatchCumulativeEnergy
+   pyFDN.Energy
+   pyFDN.Sparsity
+   pyFDN.L1
+   pyFDN.L2
 
 Plotting
 --------

{pyfdn-0.3.0 → pyfdn-0.4.1}/docs/conf.py

@@ -148,6 +148,17 @@ marimo_cache_notebooks = False
 #
 # This patch lives in conf.py (our repo), so the installed sphinx-marimo package
 # stays pristine and deployment (RTD / GitHub Actions) needs no vendored changes.
+#
+# Cell errors are build failures: a notebook that raises still produces HTML,
+# with the traceback baked in where the output should be, so a broken example
+# reaches the published site looking like a rendered page. We record every
+# notebook whose export exited non-zero and fail the build at the end (see
+# ``setup`` below) instead of aborting on the first one, so a single run reports
+# all of them. Set ``PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS=1`` to downgrade this back
+# to a warning when you need a build out of a knowingly broken notebook.
+_marimo_export_failures: "list[tuple[str, str]]" = []
+
+
 def _patch_marimo_static_export():
     import subprocess
 
@@ -173,8 +184,8 @@ def _patch_marimo_static_export():
         # `html` (not `html-wasm`) executes the notebook server-side with the real
         # venv and embeds the outputs. marimo returns a non-zero exit code when any
         # cell raises during execution, but it still writes the HTML (with the error
-        # baked in), so we log a warning and keep going rather than aborting the
-        # whole docs build on one bad notebook.
+        # baked in), so we record the failure and keep going; the build-finished
+        # handler turns the collected failures into a build error.
         proc = subprocess.run(
             [
                 "marimo",
@@ -190,9 +201,10 @@ def _patch_marimo_static_export():
         )
         if proc.returncode != 0:
             print(
-                f"[conf.py] WARNING: '{relative_path}' had cell errors during static "
+                f"[conf.py] ERROR: '{relative_path}' had cell errors during static "
                 f"export (output still written):\n{proc.stderr.strip()}"
             )
+            _marimo_export_failures.append((str(relative_path), proc.stderr.strip()))
 
         return {
             "name": output_name,
@@ -205,3 +217,30 @@ def _patch_marimo_static_export():
 
 
 _patch_marimo_static_export()
+
+
+def _fail_on_marimo_export_errors(app, exception):
+    """Fail the build if any notebook raised while being exported."""
+    # The build already failed for another reason; don't mask it.
+    if exception is not None or not _marimo_export_failures:
+        return
+
+    report = "\n\n".join(
+        f"{path}:\n{stderr}" for path, stderr in _marimo_export_failures
+    )
+    if os.environ.get("PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS") == "1":
+        print(
+            f"[conf.py] WARNING: {len(_marimo_export_failures)} notebook(s) had cell "
+            f"errors; failing is disabled via PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS:\n{report}"
+        )
+        return
+
+    raise RuntimeError(
+        f"{len(_marimo_export_failures)} example notebook(s) raised during static "
+        f"export. The generated HTML contains the traceback instead of the intended "
+        f"output, so this must not be published:\n\n{report}"
+    )
+
+
+def setup(app):
+    app.connect("build-finished", _fail_on_marimo_export_errors)

{pyfdn-0.3.0 → pyfdn-0.4.1}/docs/example_gallery.py

@@ -15,11 +15,14 @@ OUTPUT_FILE = DOCS_DIR / "examples_gallery.rst"
 
 CATEGORY_ORDER = (
     "Getting Started",
-    "Absorption & Filters",
-    "Translation Examples",
-    "Allpass FDN Examples",
+    "Feedback Matrices",
+    "Absorption & Decay",
+    "Analysis & Verification",
+    "Optimization",
+    "Allpass FDNs",
     "Special FDNs",
-    "FDN Design & Analysis",
+    "Representations",
+    "Export & Deployment",
 )
 
 

{pyfdn-0.3.0 → pyfdn-0.4.1}/docs/index.rst

@@ -58,6 +58,7 @@ feedback matrices, designing loop filters, and inspecting pole locations.
    usage
    examples_gallery
    api_reference
+   training_losses
    modules
    contributing
    authors

pyfdn-0.4.1/docs/training_losses.rst

@@ -0,0 +1,99 @@
+===============================
+Training losses: design notes
+===============================
+
+Why the losses in :mod:`pyFDN.train.losses` are shaped the way they are. The
+reasoning is qualitative on purpose: what is stated here is a design choice and
+its rationale, not a benchmark. Behaviour is FDN- and seed-dependent, so measure
+your own case before assuming any of it transfers.
+
+
+Flatness on the training grid depends on ``nfft``
+=================================================
+
+:class:`~pyFDN.FlatMagnitude` measures ``|H|`` at the model's DFT bins, so its
+frequency resolution *is* the model's ``nfft``. The truncation to ``nfft``
+samples is a rectangular window, so the peak-to-median range of ``|H|`` grows
+with ``nfft``, and the mean-squared error weights the tallest modes ever more
+heavily. Loss values are therefore comparable across runs at one ``nfft`` and
+not across different ones. A multi-resolution loss
+(:class:`~pyFDN.FlatSpectrogram`), whose analysis windows set their own
+resolution, is the way out.
+
+The optimization crosses long plateaus on ``FlatMagnitude``; ``train_fdn``'s
+default ``patience=10`` stops inside one. Raise it for a converged fit.
+
+
+Asymmetric flatness: peaks over dips
+====================================
+
+:class:`~pyFDN.AsymmetricFlatMagnitude` raises the two sides of the deviation
+from flat to different powers so peaks cost more than dips. The exponent, not a
+weight, is what makes it bite: at ``peak_power=4`` a peak twice as tall costs
+sixteen times as much. Flat stays the unique minimum at every ``peak_power``
+(normalizing by RMS forces ``<(1 + d)^2> = 1``), and the loss is gain-invariant.
+
+It is deliberately **not** in decibels: ``∂dB/∂|H| ∝ 1/|H|``, so in dB the
+deepest nulls dominate the gradient however lightly weighted. In linear
+magnitude the gradient is ``∝ p·(d⁺)^(p-1)``, largest at the tallest peaks,
+while a dip is bounded at ``d = -1``.
+
+The cost is steps and steadiness: that same gradient vanishes near the optimum,
+so a higher exponent takes longer to converge and varies more from seed to seed.
+The advantage over ``FlatMagnitude`` is not unconditional. Loss values are not
+comparable across ``peak_power``, or with ``FlatMagnitude``; compare the
+responses.
+
+
+Multi-resolution flatness: average over frames first
+====================================================
+
+:class:`~pyFDN.FlatSpectrogram` averages the short-time magnitudes over frames
+into a Welch estimate *before* measuring flatness. Asking each individual frame
+to be flat instead is actively harmful: an isolated echo inside a short frame
+already has a flat frame spectrum, so that objective rewards an impulsive,
+comb-filtered IR.
+
+
+Energy decay vs. spectrogram distance
+=====================================
+
+:class:`~pyFDN.MatchEnergyDecay` compares octave-band Schroeder curves. A
+magnitude spectrogram distance is not a substitute for fitting a decay: it
+compares two signals frame by frame, and two rooms with identical decay have
+uncorrelated fine structure, so predicting *silence* scores better there than
+predicting the right amount of the wrong detail. Fitted to a measured room, a
+spectrogram distance is minimized by an FDN whose RT falls well short of the
+measurement, where an energy-decay loss is not.
+
+
+Doubly-cumulated energy
+=======================
+
+:class:`~pyFDN.MatchCumulativeEnergy` integrates the short-time power spectrum
+twice — backwards in time and along frequency — and scores the RMS difference of
+the two surfaces after a compressive power.
+
+**Why cumulate twice.** The time direction is Schroeder backward integration
+(the reason ``MatchEnergyDecay`` exists). The frequency direction replaces
+splitting into octave bands: band edges are an arbitrary quantization a fit can
+satisfy on average while getting the shape wrong, whereas a cumulative sum is
+the limit of ever-finer bands and is monotone and smooth in both axes, which a
+gradient values. Read down the ``t = 0`` edge and you have the integrated
+spectrum (colour); read across the ``f = 0`` edge and you have the full-band
+decay; the interior ties them together band by band.
+
+**Compression, not decibels.** The surface spans the whole dynamic range of the
+decay, so a plain MSE would see only the first frames. Raising the normalized
+surface to a fractional ``power`` (0.5 default) compresses that range while
+staying bounded, its gradient ``∝ x^(p-1)`` finite everywhere the floor allows.
+A logarithm is worse: it turns the silence *below* the response into an
+unbounded penalty dominated by whichever bin is nearest zero.
+
+**Which way the frequency cumulation runs.** Cumulating downwards alone — the
+default, and the plain reading of "energy above this frequency" — leaves the
+bottom octave with almost no gradient, and a fit that has to *find* a decay
+tends to abandon it there. ``frequency="both"`` scores both directions and
+averages, which recovers the low end; it is the setting to reach for when the
+decay is not given. This is a matter of weighting rather than frequency
+resolution, so a longer analysis window is not the fix.

{pyfdn-0.3.0 → pyfdn-0.4.1}/docs/usage.rst

@@ -7,12 +7,14 @@ All main functions are accessible directly from ``pyFDN``::
     import pyFDN
 
     feedback = pyFDN.random_orthogonal(4)
-    absorption = pyFDN.first_order_absorption(1.2, 0.9, [100, 150, 200, 250], 48_000)
+    attenuation = pyFDN.decay_to_first_order_shelf(
+        1.2, 0.9, None, [100, 150, 200, 250], 48_000
+    )
     gain_db = pyFDN.lin_to_db([0.5, 1.0, 2.0])
 
 Or import specific functions::
 
-    from pyFDN import random_orthogonal, first_order_absorption, dss_to_ss
+    from pyFDN import random_orthogonal, decay_to_first_order_shelf, dss_to_ss
 
     feedback = random_orthogonal(4)
 

{pyfdn-0.3.0 → pyfdn-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyFDN"
-version = "0.3.0"
+version = "0.4.1"
 description = "Python library for Feedback Delay Networks"
 readme = "README.rst"
 authors = [
@@ -113,7 +113,7 @@ include = ["pyFDN*"]
 # triggers on. Usage: bump-my-version bump {major|minor|patch}
 
 [tool.bumpversion]
-current_version = "0.3.0"
+current_version = "0.4.1"
 allow_dirty = false
 commit = true
 message = "Bump version: {current_version} → {new_version}"