IsoSpecPy 2.5.0__tar.gz → 2.6.0__tar.gz

{isospecpy-2.5.0 → isospecpy-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.5.0
+Version: 2.6.0
 Summary: IsoSpecPy is a Python library for computing isotopic distributions of molecules.
 Keywords: isotopic distribution,mass spectrometry,chemistry,isotopic envelope,isotopologues
 Author: Michał Startek, Mateusz Łącki
@@ -32,7 +32,7 @@ Description-Content-Type: text/markdown
 
 IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
 
-IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI), R (`IsoSpecR`, on CRAN) and Rust (`isospec`, the crate in `rust/`).
 
 ## Installation
 
@@ -54,6 +54,15 @@ install.packages("IsoSpecR")
 
 From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
 
+### Rust
+
+```toml
+[dependencies]
+isospec = "0.1"
+```
+
+The build script compiles the bundled C++ library; a C++20 compiler is all that is needed. See `rust/README.md`.
+
 ### C++ library
 
 ```bash
@@ -160,6 +169,27 @@ clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
 
 (`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
 
+### Rust
+
+```rust
+use isospec::{Iso, PeptideOptions};
+
+fn main() -> Result<(), isospec::Error> {
+    let iso = Iso::from_formula("H2O1")?;
+    for (mass, prob) in iso.envelope().total_prob(0.999)?.iter() {
+        println!("{mass}\t{prob}");
+    }
+
+    // A modified peptide; unlike Python's peptide_sequence=, the default
+    // here includes the terminal water.
+    let peptide = Iso::from_peptide("PEPTC[UNIMOD:4]DEK", &PeptideOptions::default())?;
+    println!("{}", peptide.monoisotopic_mass());
+    Ok(())
+}
+```
+
+See `rust/examples/` for binned spectra, generators with configurations, and labelled elements.
+
 ### R
 
 ```r
@@ -179,7 +209,19 @@ IsoSpecify(molecule = composition, stopCondition = 0.999)
 
 Like the Python `ParsePeptideSequence`, this returns the residue composition without a free peptide's terminal H2O -- add `c(H = 2, O = 1)` to it for the neutral molecule. A modification whose delta removes more atoms of an element than the bare sequence provides gives a negative count (`"G[UNIMOD:11]"` nets `H -1`, `S -1`); `IsoSpecify` rejects such a vector rather than quietly dropping those elements.
 
-See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annotated sequences.
+The rest of the API takes the same named vector, and treats an envelope as what `IsoSpecify` returns, a matrix with columns `mass` and `prob`:
+
+```r
+insulin <- c(C = 254, H = 377, N = 65, O = 75, S = 6)
+IsoProperties(insulin)$averageMass            # also mono/lightest/heaviest/mode peaks, variance
+IsoBinned(insulin, binWidth = 1)              # unit-resolution distribution, computed directly
+IsoStochastic(insulin, ionicCurrent = 1e4, seed = 1)   # simulated, reproducible measurement
+wassersteinDistance(IsoSpecify(insulin, 0.999), IsoSpecify(c(C = 254, H = 377, N = 65, O = 74, S = 7), 0.999))
+```
+
+with `envelopeConvolve`, `envelopeLinearCombination`, `envelopeBin` and `envelopeResample` for envelope arithmetic, and `orientedWassersteinDistance`, `abyssalWassersteinDistance` and `wassersteinMatch` beside `wassersteinDistance`.
+
+See `Examples/R/` for radiolabelling, full-spectrum extraction, Unimod-annotated sequences, and binned, simulated and compared envelopes.
 
 ## Advanced features
 
@@ -189,9 +231,11 @@ See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annot
   - `IsoBinned` — histogram-style envelope at a chosen bin width.
 - **FASTA/peptide-sequence support** — build an `Iso` directly from an amino-acid sequence, with `[UNIMOD:<id>]` modification tags recognized inline; optionally include the N/C-terminal water.
 - **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
-- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, binning, resampling, Wasserstein distances.
+- **Reproducible sampling** — stochastic envelopes and resampling take a seed (`seed=` in Python and R, `seeded_rng()` in C++, `with_seed` in Rust); a seed gives the same counts on every platform and in every binding.
 - **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
-- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+- **Thread safety** — the library never parallelises its own work, but independent molecules and envelopes may be used from any number of threads, and a shared molecule or envelope may be read from several at once.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability. Generators are in C++, Python and Rust; R has the materialized functions only.
 
 Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
 
@@ -201,11 +245,16 @@ Algorithmic details are in the papers cited below; the Supporting Information of
 src/IsoSpec++/    C++ core library (the algorithms live here)
 src/IsoSpecPy/    Python binding, loaded via cffi
 src/IsoSpecR/     R binding, via Rcpp
+rust/             Rust crate (Cargo.toml at the repository root), via cxx
 Examples/         Working examples in each language
-tests/            C, C++, and Python test suites
+tests/            C, C++, and Python test suites (R's are in src/IsoSpecR/tests, Rust's in rust/tests)
 skbuild/          scikit-build-core entry point used when installing the Python wheel
 ```
 
+## Changes
+
+`CHANGELOG` lists the major changes in each release (the Rust crate keeps its own, `rust/CHANGELOG.md`).
+
 ## Citation
 
 If IsoSpec is useful in your research, please cite:

{isospecpy-2.5.0 → isospecpy-2.6.0}/README.md

@@ -2,7 +2,7 @@
 
 IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
 
-IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI), R (`IsoSpecR`, on CRAN) and Rust (`isospec`, the crate in `rust/`).
 
 ## Installation
 
@@ -24,6 +24,15 @@ install.packages("IsoSpecR")
 
 From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
 
+### Rust
+
+```toml
+[dependencies]
+isospec = "0.1"
+```
+
+The build script compiles the bundled C++ library; a C++20 compiler is all that is needed. See `rust/README.md`.
+
 ### C++ library
 
 ```bash
@@ -130,6 +139,27 @@ clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
 
 (`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
 
+### Rust
+
+```rust
+use isospec::{Iso, PeptideOptions};
+
+fn main() -> Result<(), isospec::Error> {
+    let iso = Iso::from_formula("H2O1")?;
+    for (mass, prob) in iso.envelope().total_prob(0.999)?.iter() {
+        println!("{mass}\t{prob}");
+    }
+
+    // A modified peptide; unlike Python's peptide_sequence=, the default
+    // here includes the terminal water.
+    let peptide = Iso::from_peptide("PEPTC[UNIMOD:4]DEK", &PeptideOptions::default())?;
+    println!("{}", peptide.monoisotopic_mass());
+    Ok(())
+}
+```
+
+See `rust/examples/` for binned spectra, generators with configurations, and labelled elements.
+
 ### R
 
 ```r
@@ -149,7 +179,19 @@ IsoSpecify(molecule = composition, stopCondition = 0.999)
 
 Like the Python `ParsePeptideSequence`, this returns the residue composition without a free peptide's terminal H2O -- add `c(H = 2, O = 1)` to it for the neutral molecule. A modification whose delta removes more atoms of an element than the bare sequence provides gives a negative count (`"G[UNIMOD:11]"` nets `H -1`, `S -1`); `IsoSpecify` rejects such a vector rather than quietly dropping those elements.
 
-See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annotated sequences.
+The rest of the API takes the same named vector, and treats an envelope as what `IsoSpecify` returns, a matrix with columns `mass` and `prob`:
+
+```r
+insulin <- c(C = 254, H = 377, N = 65, O = 75, S = 6)
+IsoProperties(insulin)$averageMass            # also mono/lightest/heaviest/mode peaks, variance
+IsoBinned(insulin, binWidth = 1)              # unit-resolution distribution, computed directly
+IsoStochastic(insulin, ionicCurrent = 1e4, seed = 1)   # simulated, reproducible measurement
+wassersteinDistance(IsoSpecify(insulin, 0.999), IsoSpecify(c(C = 254, H = 377, N = 65, O = 74, S = 7), 0.999))
+```
+
+with `envelopeConvolve`, `envelopeLinearCombination`, `envelopeBin` and `envelopeResample` for envelope arithmetic, and `orientedWassersteinDistance`, `abyssalWassersteinDistance` and `wassersteinMatch` beside `wassersteinDistance`.
+
+See `Examples/R/` for radiolabelling, full-spectrum extraction, Unimod-annotated sequences, and binned, simulated and compared envelopes.
 
 ## Advanced features
 
@@ -159,9 +201,11 @@ See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annot
   - `IsoBinned` — histogram-style envelope at a chosen bin width.
 - **FASTA/peptide-sequence support** — build an `Iso` directly from an amino-acid sequence, with `[UNIMOD:<id>]` modification tags recognized inline; optionally include the N/C-terminal water.
 - **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
-- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, binning, resampling, Wasserstein distances.
+- **Reproducible sampling** — stochastic envelopes and resampling take a seed (`seed=` in Python and R, `seeded_rng()` in C++, `with_seed` in Rust); a seed gives the same counts on every platform and in every binding.
 - **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
-- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+- **Thread safety** — the library never parallelises its own work, but independent molecules and envelopes may be used from any number of threads, and a shared molecule or envelope may be read from several at once.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability. Generators are in C++, Python and Rust; R has the materialized functions only.
 
 Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
 
@@ -171,11 +215,16 @@ Algorithmic details are in the papers cited below; the Supporting Information of
 src/IsoSpec++/    C++ core library (the algorithms live here)
 src/IsoSpecPy/    Python binding, loaded via cffi
 src/IsoSpecR/     R binding, via Rcpp
+rust/             Rust crate (Cargo.toml at the repository root), via cxx
 Examples/         Working examples in each language
-tests/            C, C++, and Python test suites
+tests/            C, C++, and Python test suites (R's are in src/IsoSpecR/tests, Rust's in rust/tests)
 skbuild/          scikit-build-core entry point used when installing the Python wheel
 ```
 
+## Changes
+
+`CHANGELOG` lists the major changes in each release (the Rust crate keeps its own, `rust/CHANGELOG.md`).
+
 ## Citation
 
 If IsoSpec is useful in your research, please cite:

isospecpy-2.6.0/VERSION

@@ -0,0 +1 @@
+2.6.0

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/aligned_ptr.h

@@ -36,7 +36,9 @@
 // elsewhere for plain huge-page mmap): that layer has no remap concept at
 // all on Windows and no equivalent of mremap on Darwin, so each platform's
 // real growth primitive is used directly instead:
-//   - Linux / other real-mman UNIX: mmap + mremap(MREMAP_MAYMOVE) + munmap.
+//   - Linux (any libc with mremap): mmap + mremap(MREMAP_MAYMOVE) + munmap.
+//   - Other UNIX (FreeBSD, ...: no mremap): growth maps a fresh region and
+//     copies, shrink unmaps the tail in place.
 //   - Apple: mmap/munmap for create/destroy (Darwin has no mremap); growth
 //     re-wires pages into a fresh mapping via mach_vm_remap instead of
 //     copying, shrink just munmaps the tail in place.
@@ -57,25 +59,41 @@
 
 // The small-allocation backend needs an aligned allocator that can also be
 // deallocated with a plain std::free() (release() promises exactly that).
-// glibc/libc++'s std::aligned_alloc satisfies both at once. MSVC's CRT has
+// glibc/libc++'s std::aligned_alloc satisfies both at once. Windows' CRT
+// (MSVC's, and the msvcrt/UCRT that MinGW, i.e. R's Rtools, links against) has
 // no C11 aligned_alloc at all, only _aligned_malloc/_aligned_free -- and
 // memory from those two is NOT free()-compatible (the CRT stores its own
 // offset bookkeeping ahead of the returned pointer, which plain free() does
-// not know how to unwind). So on MSVC the small backend uses
+// not know how to unwind). So on Windows the small backend uses
 // _aligned_malloc/_aligned_free for its own storage (still genuinely
 // Alignment-aligned, as marginalTrek++.h's use of this class relies on),
 // and release() falls back to materialising a fresh plain-malloc()'d copy
 // to keep its free()-compatibility promise -- the same thing it already
 // does to escape a VM-backed region.
-#if defined(_MSC_VER)
+#if defined(_WIN32)
 #define ISOSPEC_ALIGNED_PTR_SMALL_BACKEND_FREE_COMPATIBLE 0
 #else
 #define ISOSPEC_ALIGNED_PTR_SMALL_BACKEND_FREE_COMPATIBLE 1
 #endif
 
 #if ISOSPEC_WE_ARE_ON_WINDOWS
+    // Without NOMINMAX, <windows.h> defines min and max as macros, which break
+    // every later std::min(...) and numeric_limits<T>::max() in the including
+    // translation unit. Defined only around this include, so that the macro
+    // itself does not leak into the caller's code (though a later <windows.h>
+    // there is then a no-op, without the macros); a caller who included
+    // <windows.h> first, macros and all, is covered by the parenthesised
+    // (std::min)(...) calls in the public headers.
+    #ifndef NOMINMAX
+        #define NOMINMAX
+        #define ISOSPEC_UNDEF_NOMINMAX
+    #endif
     #include <windows.h>
-    #if defined(_MSC_VER)
+    #ifdef ISOSPEC_UNDEF_NOMINMAX
+        #undef NOMINMAX
+        #undef ISOSPEC_UNDEF_NOMINMAX
+    #endif
+    #if defined(_WIN32)
         #include <malloc.h>   // _aligned_malloc / _aligned_free
     #endif
 #elif ISOSPEC_WE_ARE_ON_UNIX_YAY
@@ -303,7 +321,26 @@ inline void vm_resize(vm_region& r, std::size_t new_bytes)
     r.size = new_size;
 }
 
-#else  // Linux / other real-mman UNIX with an actual mremap()
+#else  // Other UNIX: Linux with mremap(), the rest (FreeBSD, ...) without
+
+// ThreadSanitizer intercepts mmap() and munmap() but not mremap(), so a region
+// that mremap() moves away from is freed behind its back and keeps its old
+// shadow state. When another thread's mremap() later lands on those
+// addresses, TSan reports its writes as racing with the previous owner's --
+// pure address reuse, reproduced with two threads and nothing else. Under
+// TSan, growth therefore goes through mmap + copy + munmap, which it does see.
+#if defined(__SANITIZE_THREAD__)
+#define ISOSPEC_ALIGNED_PTR_UNDER_TSAN 1
+#elif defined(__has_feature)
+#if __has_feature(thread_sanitizer)
+#define ISOSPEC_ALIGNED_PTR_UNDER_TSAN 1
+#endif
+#endif
+
+// mremap() is Linux's alone; MREMAP_MAYMOVE, from <sys/mman.h>, is the test.
+#if defined(MREMAP_MAYMOVE) && !defined(ISOSPEC_ALIGNED_PTR_UNDER_TSAN)
+#define ISOSPEC_ALIGNED_PTR_USE_MREMAP 1
+#endif
 
 inline void vm_resize(vm_region& r, std::size_t new_bytes)
 {
@@ -311,11 +348,24 @@ inline void vm_resize(vm_region& r, std::size_t new_bytes)
     if (new_size == r.size)
         return;
 
+#if !defined(ISOSPEC_ALIGNED_PTR_USE_MREMAP)
+    if (new_size < r.size) {
+        // Shrink in place: base address is untouched, just drop the tail.
+        ::munmap(static_cast<char*>(r.base) + new_size, r.size - new_size);
+        r.size = new_size;
+        return;
+    }
+    vm_region moved = vm_create(new_bytes);
+    std::memcpy(moved.base, r.base, (std::min)(r.size, moved.size));
+    vm_destroy(r);
+    r = moved;
+#else
     void* p = ::mremap(r.base, r.size, new_size, MREMAP_MAYMOVE);
     if (p == MAP_FAILED)
         throw std::bad_alloc();
     r.base = p;
     r.size = new_size;
+#endif
 }
 
 #endif  // __APPLE__
@@ -549,7 +599,7 @@ class aligned_unique_ptr {
             // still has to copy -- there is nothing yet to remap.
             aligned_ptr_detail::vm_region r = aligned_ptr_detail::vm_create(new_bytes);
             if (ptr_) {
-                std::memcpy(r.base, ptr_, std::min(capacity_bytes_, new_bytes));
+                std::memcpy(r.base, ptr_, (std::min)(capacity_bytes_, new_bytes));
                 free_small(ptr_);
             }
             region_ = r;
@@ -562,7 +612,7 @@ class aligned_unique_ptr {
 
         T* new_ptr = allocate_small(n);
         if (ptr_) {
-            std::memcpy(new_ptr, ptr_, std::min(capacity_bytes_, new_bytes));
+            std::memcpy(new_ptr, ptr_, (std::min)(capacity_bytes_, new_bytes));
             free_small(ptr_);
         }
         ptr_ = new_ptr;
@@ -573,7 +623,7 @@ class aligned_unique_ptr {
     // bare std::free() / C free(), regardless of which backend produced it.
     // Whenever the current backend isn't already free()-compatible on its
     // own -- a VM-backed region always needs this, and so does the small
-    // backend on MSVC (see ISOSPEC_ALIGNED_PTR_SMALL_BACKEND_FREE_COMPATIBLE
+    // backend on Windows (see ISOSPEC_ALIGNED_PTR_SMALL_BACKEND_FREE_COMPATIBLE
     // above) -- this materialises a fresh plain-malloc()'d copy instead.
     // That copy is the whole cost of calling this in those cases;
     // release_with_deleter() below avoids it when the caller can accept a

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/allocator.h

@@ -23,6 +23,13 @@
 namespace IsoSpec
 {
 
+// Configurations per allocator slab.  Small on purpose: with glibc, a slab of
+// up to 1032 bytes (4 isotopes x 64 ints = 1024) is recycled through the
+// per-thread tcache when the next molecule is built, so many small molecules
+// in a row run 16-20% faster than with 1000 (2000 tryptic peptides, threshold
+// generator, x86-64-v3 and v4).  Single large calculations do not notice.
+constexpr int default_tab_size = 64;
+
 template <typename T> inline void copyConf(
     const T* source, T* destination,
     int dim
@@ -39,7 +46,7 @@ template <typename T> class Allocator
     pod_vector<T*>  prevTabs;
 
  public:
-    explicit Allocator(const int dim, const int tabSize = 10000);
+    explicit Allocator(const int dim, const int tabSize = default_tab_size);
     ~Allocator();
 
     Allocator(const Allocator& other) = delete;

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/composition.h

@@ -27,6 +27,7 @@
 
 #pragma once
 
+#include <string_view>
 #include <vector>
 
 #include "isoSpec++.h"
@@ -87,6 +88,14 @@ struct ExpandedComposition {
     }
 };
 
+//! A formula string read as a composition: each element once, in the order
+//! written, counts signed ("H-2O-1" is accepted -- a composition may be a
+//! delta; build_iso_from_composition rejects negatives when one becomes a
+//! molecule). Throws std::invalid_argument for a malformed formula, an unknown
+//! element or one written twice, std::out_of_range for a count past int. The
+//! same tokenizer and checks as parse_formula, which goes through it.
+ElementComposition parse_formula_composition(std::string_view formula);
+
 //! Resolves each element of `composition` to its isotopes' masses and
 //! probabilities from element_tables.h, filling a caller-owned `out`
 //! (cleared first).

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/cwrapper.cpp

@@ -300,6 +300,43 @@ void* setupIsoStochasticGenerator(void* iso,
             beta_bias);
     });
 }
+
+namespace
+{
+// The random state a seeded generator draws from has to live as long as the
+// generator and be built before it: a base class listed first is both.
+struct OwnedRng
+{
+    std::mt19937 owned_rng;
+    explicit OwnedRng(uint64_t seed) : owned_rng(seeded_rng(seed)) {}
+};
+
+class SeededIsoStochasticGenerator : private OwnedRng, public IsoStochasticGenerator
+{
+ public:
+    SeededIsoStochasticGenerator(Iso&& iso, size_t no_molecules, double precision, double beta_bias, uint64_t seed) :
+    OwnedRng(seed),
+    IsoStochasticGenerator(std::move(iso), no_molecules, precision, beta_bias, owned_rng)
+    {}
+};
+}  // namespace
+
+void* setupIsoStochasticGeneratorSeeded(void* iso,
+                                        size_t no_molecules,
+                                        double precision,
+                                        double beta_bias,
+                                        uint64_t seed)
+{
+    return c_guard([&]() -> void*
+    {
+        // Handed out as the base, like the unseeded generator, so every
+        // *IsoStochasticGenerator function (delete included, through the
+        // virtual destructor) works on it unchanged.
+        IsoStochasticGenerator* generator = new SeededIsoStochasticGenerator(
+            std::move(*reinterpret_cast<Iso*>(iso)), no_molecules, precision, beta_bias, seed);
+        return generator;
+    });
+}
 ISOSPEC_C_FN_CODES(IsoStochasticGenerator)
 
 // ______________________________________________________ FixedEnvelopes
@@ -351,6 +388,26 @@ void* setupStochasticFixedEnvelope(void* iso,
     });
 }
 
+void* setupStochasticFixedEnvelopeSeeded(void* iso,
+                    size_t no_molecules,
+                    double precision,
+                    double beta_bias,
+                    bool get_confs,
+                    uint64_t seed)
+{
+    return c_guard([&]() -> void*
+    {
+        std::mt19937 rng = seeded_rng(seed);
+        return new FixedEnvelope(
+            FixedEnvelope::FromStochastic(Iso(*reinterpret_cast<const Iso*>(iso), true),
+                                          no_molecules,
+                                          precision,
+                                          beta_bias,
+                                          get_confs,
+                                          rng));
+    });
+}
+
 
 void* setupBinnedFixedEnvelope(void* iso,
                     double target_total_prob,
@@ -542,6 +599,15 @@ void resampleEnvelope(void* envelope, size_t ionic_current, double beta_bias)
     return c_guard([&]{ reinterpret_cast<FixedEnvelope*>(envelope)->resample(ionic_current, beta_bias); });
 }
 
+void resampleEnvelopeSeeded(void* envelope, size_t ionic_current, double beta_bias, uint64_t seed)
+{
+    return c_guard([&]
+    {
+        std::mt19937 rng = seeded_rng(seed);
+        reinterpret_cast<FixedEnvelope*>(envelope)->resample(ionic_current, beta_bias, rng);
+    });
+}
+
 
 void* binnedEnvelope(void* envelope, double width, double middle)
 {
@@ -614,27 +680,26 @@ void* parseFastaWithModsC(const char* sequence, const char* unimod_db_path)
 {
     return c_guard([&]() -> void*
     {
-        // Reused across calls (parse_fasta_with_mods_into only clears it,
-        // never releases capacity) -- avoids reallocating the scratch
-        // ElementComposition on every single call from Python/R, which is
-        // the real hot path this matters for (millions of peptides). Plain
-        // `static`, not `thread_local`: IsoSpec is single-threaded by design
-        // (this repo's CLAUDE.md) so they'd behave identically here, and
-        // thread_local's extra TLS teardown machinery is a real, observed
-        // crash risk for a dynamically-loaded Python/R extension module
-        // (segfault during interpreter shutdown, seen in CI on macOS) that
-        // buys nothing in a library that never has a second thread. Nothing
-        // below retains a pointer into `scratch` itself: `counts` is copied
-        // out by value, and `symbols` is built from elem_table_symbol's
-        // static string-literal pointers, not from `scratch`'s own storage --
-        // safe to overwrite `scratch` on the next call.
-        static ElementComposition scratch;
-        parse_fasta_with_mods_into(sequence, scratch, resolve_unimod_table(unimod_db_path));
+        // A fresh composition per call, not a reused `static` one: a static
+        // shared by every thread is a data race, and `thread_local` is no way
+        // out -- its TLS teardown has crashed a dynamically-loaded Python/R
+        // extension module at interpreter shutdown (seen in CI on macOS).
+        // Reserving up front makes each vector one allocation rather than a
+        // doubling series, and `count` is moved into the handle rather than
+        // copied, so the net cost over the static is one malloc/free pair:
+        // measured at +7 ns per call (43 -> 50 ns) on unmodified peptides and
+        // +2.5% on modified ones, x86-64-v3, gcc -- small next to any
+        // binding's own per-call overhead. 16 covers an unmodified peptide
+        // (C, H, N, O, S, Se) with room for what a few modifications add.
+        ElementComposition composition;
+        composition.element_first_index.reserve(16);
+        composition.count.reserve(16);
+        parse_fasta_with_mods_into(sequence, composition, resolve_unimod_table(unimod_db_path));
         std::unique_ptr<ElementCompositionHandle> handle(new ElementCompositionHandle());
-        handle->counts = scratch.count;
-        handle->symbols.reserve(scratch.element_first_index.size());
-        for(int idx : scratch.element_first_index)
+        handle->symbols.reserve(composition.element_first_index.size());
+        for(int idx : composition.element_first_index)
             handle->symbols.push_back(elem_table_symbol[idx]);
+        handle->counts = std::move(composition.count);
         return handle.release();
     });
 }

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/cwrapper.h

@@ -16,6 +16,9 @@
 
 #pragma once
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "platform.h"
 
 #define ISOSPEC_ALGO_LAYERED 0
@@ -117,6 +120,15 @@ ISOSPEC_C_API double probIsoStochasticGenerator(void* generator);
 ISOSPEC_C_API void get_conf_signatureIsoStochasticGenerator(void* generator, int* space);
 ISOSPEC_C_API bool advanceToNextConfigurationIsoStochasticGenerator(void* generator);
 ISOSPEC_C_API void deleteIsoStochasticGenerator(void* generator);
+// The *Seeded variants draw from a generator seeded with `seed`, so the same
+// seed reproduces the same sample (also across bindings). The unseeded ones draw
+// from a randomly seeded per-thread generator. A seeded stochastic generator
+// owns its random state and is used and deleted like an unseeded one.
+ISOSPEC_C_API void* setupIsoStochasticGeneratorSeeded(void* iso,
+                                   size_t no_molecules,
+                                   double precision,
+                                   double beta_bias,
+                                   uint64_t seed);
 
 ISOSPEC_C_API void* setupThresholdFixedEnvelope(void* iso,
                               double threshold,
@@ -134,6 +146,13 @@ ISOSPEC_C_API void* setupStochasticFixedEnvelope(void* iso,
                               double beta_bias,
                               bool get_confs);
 
+ISOSPEC_C_API void* setupStochasticFixedEnvelopeSeeded(void* iso,
+                              size_t no_molecules,
+                              double precision,
+                              double beta_bias,
+                              bool get_confs,
+                              uint64_t seed);
+
 ISOSPEC_C_API void* setupBinnedFixedEnvelope(void* iso,
                     double target_total_prob,
                     double bin_width,
@@ -185,7 +204,6 @@ ISOSPEC_C_API double empiricStddev(void* tabulator);
 ISOSPEC_C_API double wassersteinDistance(void* tabulator1, void* tabulator2);
 ISOSPEC_C_API double orientedWassersteinDistance(void* tabulator1, void* tabulator2);
 ISOSPEC_C_API double abyssalWassersteinDistance(void* tabulator1, void* tabulator2, double abyss_depth, double other_scale);
-// ISOSPEC_C_API double abyssalWassersteinDistanceGrad(void* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the);
 
 struct ws_match_res{
 double res1;
@@ -203,6 +221,7 @@ ISOSPEC_C_API void scaleEnvelope(void* envelope, double factor);
 ISOSPEC_C_API void normalizeEnvelope(void* envelope);
 ISOSPEC_C_API void shiftMassEnvelope(void* envelope, double d_mass);
 ISOSPEC_C_API void resampleEnvelope(void* envelope, size_t ionic_current, double beta_bias);
+ISOSPEC_C_API void resampleEnvelopeSeeded(void* envelope, size_t ionic_current, double beta_bias, uint64_t seed);
 ISOSPEC_C_API void* binnedEnvelope(void* envelope, double width, double middle);
 ISOSPEC_C_API void* linearCombination(void* const * const envelopes, const double* intensities, size_t count);
 

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/dirtyAllocator.h

@@ -18,6 +18,7 @@
 
 #include <cstring>
 #include "pod_vector.h"
+#include "allocator.h"
 
 namespace IsoSpec
 {
@@ -33,7 +34,7 @@ class DirtyAllocator
     pod_vector<void*>  prevTabs;
 
  public:
-    explicit DirtyAllocator(const int dim, const int tabSize = 10000);
+    explicit DirtyAllocator(const int dim, const int tabSize = default_tab_size);
     ~DirtyAllocator();
 
     DirtyAllocator(const DirtyAllocator& other) = delete;

{isospecpy-2.5.0 → isospecpy-2.6.0}/src/IsoSpec++/fasta.cpp

@@ -54,7 +54,7 @@ const double aa_elem_probabilities[19] = {
 };
 
 
-const int aa_symbol_to_elem_counts[256*6] = {
+constexpr int aa_symbol_to_elem_counts[256*6] = {
 /* Code:   0  unprintable   */       0, 0, 0, 0, 0, 0,
 /* Code:   1  unprintable   */       0, 0, 0, 0, 0, 0,
 /* Code:   2  unprintable   */       0, 0, 0, 0, 0, 0,
@@ -312,4 +312,31 @@ const int aa_symbol_to_elem_counts[256*6] = {
 /* Code: 254  unprintable   */       0, 0, 0, 0, 0, 0
 };
 
+namespace {
+
+constexpr PackedElemCounts pack_elem_counts()
+{
+    PackedElemCounts ret{};
+    for(int c = 0; c < 256; c++)
+        for(int ii = 0; ii < 6; ii++)
+            ret.row[c] |= static_cast<std::uint64_t>(aa_symbol_to_elem_counts[c*6 + ii]) << (AA_PACKED_FIELD_BITS * ii);
+    return ret;
+}
+
+constexpr bool packed_counts_cannot_overflow()
+{
+    for(int ii = 0; ii < 256*6; ii++)
+        if(aa_symbol_to_elem_counts[ii] < 0 ||
+           aa_symbol_to_elem_counts[ii] * AA_PACKED_FLUSH_EVERY >= (1 << AA_PACKED_FIELD_BITS))
+            return false;
+    return 6 * AA_PACKED_FIELD_BITS <= 64;
+}
+
+static_assert(packed_counts_cannot_overflow(),
+              "AA_PACKED_FLUSH_EVERY residues of the largest count must fit an AA_PACKED_FIELD_BITS field");
+
+}  // namespace
+
+constexpr PackedElemCounts aa_symbol_to_packed_elem_counts = pack_elem_counts();
+
 }  // namespace IsoSpec