IsoSpecPy 2.5.0__tar.gz → 2.6.1__tar.gz

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

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.5.0
+Version: 2.6.1
 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
 License-Expression: BSD-2-Clause
 License-File: LICENCE
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -21,7 +20,7 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Operating System :: OS Independent
 Project-URL: Homepage, https://github.com/MatteoLacki/IsoSpec
 Project-URL: Repository, https://github.com/MatteoLacki/IsoSpec
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: cffi
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
@@ -32,7 +31,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
 
@@ -42,7 +41,7 @@ IsoSpec is primarily used as a library by mass spectrometry software. It is impl
 pip install IsoSpecPy
 ```
 
-The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.9.
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.10.
 
 To build from source: `pip install .` from a checkout. A C++20 compiler is required.
 
@@ -54,6 +53,21 @@ install.packages("IsoSpecR")
 
 From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
 
+### Rust
+
+```bash
+cargo add isospec
+```
+
+or, in `Cargo.toml`:
+
+```toml
+[dependencies]
+isospec = "0.2"
+```
+
+The crate ([crates.io](https://crates.io/crates/isospec), API documentation on [docs.rs](https://docs.rs/isospec)) carries the C++ sources and compiles them in its build script; a C++20 compiler is all that is needed. See `rust/README.md`.
+
 ### C++ library
 
 ```bash
@@ -160,6 +174,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 +214,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 +236,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 +250,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.1}/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
 
@@ -12,7 +12,7 @@ IsoSpec is primarily used as a library by mass spectrometry software. It is impl
 pip install IsoSpecPy
 ```
 
-The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.9.
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.10.
 
 To build from source: `pip install .` from a checkout. A C++20 compiler is required.
 
@@ -24,6 +24,21 @@ install.packages("IsoSpecR")
 
 From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
 
+### Rust
+
+```bash
+cargo add isospec
+```
+
+or, in `Cargo.toml`:
+
+```toml
+[dependencies]
+isospec = "0.2"
+```
+
+The crate ([crates.io](https://crates.io/crates/isospec), API documentation on [docs.rs](https://docs.rs/isospec)) carries the C++ sources and compiles them in its build script; a C++20 compiler is all that is needed. See `rust/README.md`.
+
 ### C++ library
 
 ```bash
@@ -130,6 +145,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 +185,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 +207,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 +221,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.1/VERSION

@@ -0,0 +1 @@
+2.6.1

{isospecpy-2.5.0 → isospecpy-2.6.1}/pyproject.toml

@@ -32,10 +32,9 @@ license = "BSD-2-Clause"
 license-files = ["LICENCE"]
 authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

{isospecpy-2.5.0 → isospecpy-2.6.1}/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.1}/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.1}/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).