IsoSpecPy 2.6.0__tar.gz → 2.6.1__tar.gz

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

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.6.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"
@@ -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.
 
@@ -56,12 +55,18 @@ 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.1"
+isospec = "0.2"
 ```
 
-The build script compiles the bundled C++ library; a C++20 compiler is all that is needed. See `rust/README.md`.
+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
 

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

@@ -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.
 
@@ -26,12 +26,18 @@ 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.1"
+isospec = "0.2"
 ```
 
-The build script compiles the bundled C++ library; a C++20 compiler is all that is needed. See `rust/README.md`.
+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
 

isospecpy-2.6.1/VERSION

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

{isospecpy-2.6.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.6.0 → isospecpy-2.6.1}/src/IsoSpec++/cwrapper.cpp

@@ -341,87 +341,122 @@ ISOSPEC_C_FN_CODES(IsoStochasticGenerator)
 
 // ______________________________________________________ FixedEnvelopes
 
-void* setupThresholdFixedEnvelope(void* iso,
-                     double threshold,
-                     bool absolute,
-                     bool  get_confs)
+// Each envelope constructor comes in two forms. The plain one leaves the
+// caller's Iso alone, so it fully copies it (marginal tables and all) for the
+// generator inside to own. The *Consuming one takes the Iso over: it moves it
+// into the generator and deletes the emptied handle before returning, whether
+// or not it succeeded. Skipping the copy saves 0.65 us of the 4.5 us a
+// 30-residue peptide takes in Binned at 1 Da and target 0.99 (x86-64-v3).
+// The helpers are templates and lambdas, so they sit outside extern "C".
+}  // extern "C"
+
+namespace
+{
+template<typename F>
+void* envelope_from_iso(void* iso, bool consume, F&& make) noexcept
 {
+    // Owned before c_guard runs anything, so that the handle goes on every path.
+    const std::unique_ptr<Iso> owned(consume ? reinterpret_cast<Iso*>(iso) : nullptr);
     return c_guard([&]() -> void*
     {  // Use copy elision to allocate on heap with named constructor
-        return new FixedEnvelope(
-            FixedEnvelope::FromThreshold(Iso(*reinterpret_cast<const Iso*>(iso), true),
-                                         threshold,
-                                         absolute,
-                                         get_confs));
+        if(consume)
+            return new FixedEnvelope(make(std::move(*owned)));
+        return new FixedEnvelope(make(Iso(*reinterpret_cast<const Iso*>(iso), true)));
     });
 }
 
-void* setupTotalProbFixedEnvelope(void* iso,
-                     double target_coverage,
-                     bool optimize,
-                     bool get_confs)
+void* threshold_envelope(void* iso, bool consume, double threshold, bool absolute, bool get_confs) noexcept
 {
-    return c_guard([&]() -> void*
-    {  // Use copy elision to allocate on heap with named constructor
-        return new FixedEnvelope(
-            FixedEnvelope::FromTotalProb(Iso(*reinterpret_cast<const Iso*>(iso), true),
-                                         target_coverage,
-                                         optimize,
-                                         get_confs));
-    });
+    return envelope_from_iso(iso, consume, [&](Iso&& i)
+        { return FixedEnvelope::FromThreshold(std::move(i), threshold, absolute, get_confs); });
 }
 
-void* setupStochasticFixedEnvelope(void* iso,
-                    size_t no_molecules,
-                    double precision,
-                    double beta_bias,
-                    bool get_confs)
+void* total_prob_envelope(void* iso, bool consume, double target_coverage, bool optimize, bool get_confs) noexcept
 {
-    return c_guard([&]() -> void*
-    {  // Use copy elision to allocate on heap with named constructor
-        return new FixedEnvelope(
-            FixedEnvelope::FromStochastic(Iso(*reinterpret_cast<const Iso*>(iso), true),
-                                          no_molecules,
-                                          precision,
-                                          beta_bias,
-                                          get_confs));
-    });
+    return envelope_from_iso(iso, consume, [&](Iso&& i)
+        { return FixedEnvelope::FromTotalProb(std::move(i), target_coverage, optimize, get_confs); });
 }
 
-void* setupStochasticFixedEnvelopeSeeded(void* iso,
-                    size_t no_molecules,
-                    double precision,
-                    double beta_bias,
-                    bool get_confs,
-                    uint64_t seed)
+void* stochastic_envelope(void* iso, bool consume, size_t no_molecules, double precision, double beta_bias,
+                          bool get_confs) noexcept
 {
-    return c_guard([&]() -> void*
+    return envelope_from_iso(iso, consume, [&](Iso&& i)
+        { return FixedEnvelope::FromStochastic(std::move(i), no_molecules, precision, beta_bias, get_confs); });
+}
+
+void* stochastic_envelope_seeded(void* iso, bool consume, size_t no_molecules, double precision,
+                                 double beta_bias, bool get_confs, uint64_t seed) noexcept
+{
+    return envelope_from_iso(iso, consume, [&](Iso&& i)
     {
         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));
+        return FixedEnvelope::FromStochastic(std::move(i), no_molecules, precision, beta_bias, get_confs, rng);
     });
 }
 
+void* binned_envelope(void* iso, bool consume, double target_total_prob, double bin_width,
+                      double bin_middle) noexcept
+{
+    return envelope_from_iso(iso, consume, [&](Iso&& i)
+        { return FixedEnvelope::Binned(std::move(i), target_total_prob, bin_width, bin_middle); });
+}
+}  // namespace
 
-void* setupBinnedFixedEnvelope(void* iso,
-                    double target_total_prob,
-                    double bin_width,
-                    double bin_middle)
+extern "C"
 {
-    return c_guard([&]() -> void*
-    {  // Use copy elision to allocate on heap with named constructor
-        return new FixedEnvelope(
-            FixedEnvelope::Binned(Iso(*reinterpret_cast<const Iso*>(iso), true),
-                                  target_total_prob,
-                                  bin_width,
-                                  bin_middle));
-    });
+
+void* setupThresholdFixedEnvelope(void* iso, double threshold, bool absolute, bool get_confs)
+{
+    return threshold_envelope(iso, false, threshold, absolute, get_confs);
+}
+
+void* setupThresholdFixedEnvelopeConsuming(void* iso, double threshold, bool absolute, bool get_confs)
+{
+    return threshold_envelope(iso, true, threshold, absolute, get_confs);
+}
+
+void* setupTotalProbFixedEnvelope(void* iso, double target_coverage, bool optimize, bool get_confs)
+{
+    return total_prob_envelope(iso, false, target_coverage, optimize, get_confs);
+}
+
+void* setupTotalProbFixedEnvelopeConsuming(void* iso, double target_coverage, bool optimize, bool get_confs)
+{
+    return total_prob_envelope(iso, true, target_coverage, optimize, get_confs);
+}
+
+void* setupStochasticFixedEnvelope(void* iso, size_t no_molecules, double precision, double beta_bias,
+                                   bool get_confs)
+{
+    return stochastic_envelope(iso, false, no_molecules, precision, beta_bias, get_confs);
+}
+
+void* setupStochasticFixedEnvelopeConsuming(void* iso, size_t no_molecules, double precision, double beta_bias,
+                                            bool get_confs)
+{
+    return stochastic_envelope(iso, true, no_molecules, precision, beta_bias, get_confs);
+}
+
+void* setupStochasticFixedEnvelopeSeeded(void* iso, size_t no_molecules, double precision, double beta_bias,
+                                         bool get_confs, uint64_t seed)
+{
+    return stochastic_envelope_seeded(iso, false, no_molecules, precision, beta_bias, get_confs, seed);
+}
+
+void* setupStochasticFixedEnvelopeSeededConsuming(void* iso, size_t no_molecules, double precision,
+                                                  double beta_bias, bool get_confs, uint64_t seed)
+{
+    return stochastic_envelope_seeded(iso, true, no_molecules, precision, beta_bias, get_confs, seed);
+}
+
+void* setupBinnedFixedEnvelope(void* iso, double target_total_prob, double bin_width, double bin_middle)
+{
+    return binned_envelope(iso, false, target_total_prob, bin_width, bin_middle);
+}
+
+void* setupBinnedFixedEnvelopeConsuming(void* iso, double target_total_prob, double bin_width, double bin_middle)
+{
+    return binned_envelope(iso, true, target_total_prob, bin_width, bin_middle);
 }
 
 void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_sorted, bool prob_sorted, double total_prob)

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

@@ -130,21 +130,39 @@ ISOSPEC_C_API void* setupIsoStochasticGeneratorSeeded(void* iso,
                                    double beta_bias,
                                    uint64_t seed);
 
+/* Envelopes from an Iso. Each comes in two forms: the plain one leaves `iso`
+   untouched (it copies it, marginal tables and all), the *Consuming one takes
+   `iso` over and saves that copy (0.65 us of a 30-residue peptide's 4.5 us
+   binned at 1 Da). A *Consuming call deletes `iso` before returning, whether
+   or not it succeeds: never use or deleteIso() it afterwards. */
 ISOSPEC_C_API void* setupThresholdFixedEnvelope(void* iso,
                               double threshold,
                               bool absolute,
                               bool get_confs);
+ISOSPEC_C_API void* setupThresholdFixedEnvelopeConsuming(void* iso,
+                              double threshold,
+                              bool absolute,
+                              bool get_confs);
 
 ISOSPEC_C_API void* setupTotalProbFixedEnvelope(void* iso,
                               double taget_coverage,
                               bool optimize,
                               bool get_confs);
+ISOSPEC_C_API void* setupTotalProbFixedEnvelopeConsuming(void* iso,
+                              double taget_coverage,
+                              bool optimize,
+                              bool get_confs);
 
 ISOSPEC_C_API void* setupStochasticFixedEnvelope(void* iso,
                               size_t no_molecules,
                               double precision,
                               double beta_bias,
                               bool get_confs);
+ISOSPEC_C_API void* setupStochasticFixedEnvelopeConsuming(void* iso,
+                              size_t no_molecules,
+                              double precision,
+                              double beta_bias,
+                              bool get_confs);
 
 ISOSPEC_C_API void* setupStochasticFixedEnvelopeSeeded(void* iso,
                               size_t no_molecules,
@@ -152,11 +170,21 @@ ISOSPEC_C_API void* setupStochasticFixedEnvelopeSeeded(void* iso,
                               double beta_bias,
                               bool get_confs,
                               uint64_t seed);
+ISOSPEC_C_API void* setupStochasticFixedEnvelopeSeededConsuming(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,
                     double bin_middle);
+ISOSPEC_C_API void* setupBinnedFixedEnvelopeConsuming(void* iso,
+                    double target_total_prob,
+                    double bin_width,
+                    double bin_middle);
 
 ISOSPEC_C_API void freeReleasedArray(void* array);
 

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/fixedEnvelopes.cpp

@@ -1303,8 +1303,15 @@ template<bool tgetConfs> void FixedEnvelope::total_prob_init(Iso&& iso, double t
     // recomputes land inside the smaller buffer rather than past its end.
     this->_confs_no = end;
 
-    if(end <= current_size/2)
-        // Overhead in memory of 2x or more, shrink to fit
+    // Overhead in memory of 2x or more: shrink to fit, but only buffers big
+    // enough for the waste to matter. Below the VM backend's threshold the
+    // shrink is a fresh aligned_alloc plus a copy of every survivor, paid on
+    // every call for at most a few hundred KiB of slack (C254H377N65O75S6 to
+    // p = 0.9999: 25 KiB copied out of 64 KiB buffers, each call).
+    size_t bytes_per_conf = 2 * sizeof(double);
+    constexpr_if(tgetConfs)
+        bytes_per_conf += this->allDimSizeofInt;
+    if(end <= current_size/2 && current_size * bytes_per_conf >= aligned_ptr_detail::vm_backend_threshold())
         this->template reallocate_memory<tgetConfs>(end);
 }
 
@@ -1587,26 +1594,49 @@ FixedEnvelope FixedEnvelope::Binned(Iso&& iso, double target_total_prob, double
         throw std::logic_error("Binned: the shifted bin grid starts below its first slot");
     const size_t no_bins = static_cast<size_t>(last_slot) + 2;
 
-    double* acc;
-# if ISOSPEC_GOT_MMAN
-    acc = reinterpret_cast<double*>(mmap(nullptr, sizeof(double)*no_bins, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
-    if(acc == MAP_FAILED)
-        throw std::bad_alloc();
+    // The accumulator spans the whole mass range, of which a large molecule
+    // populates only a small part: mapped anonymously, the rest costs address
+    // space only.  A small one's range is mostly populated, and below
+    // ISOSPEC_BINNED_MMAP_MIN_BYTES (see fixedEnvelopes.h) calloc's zeroing is
+    // cheaper than mmap's syscalls and page faults.  Above it calloc is no
+    // substitute: glibc serves blocks up to its adaptive mmap threshold (as much
+    // as 32 MiB) from the heap and memsets all of them.
+    const size_t acc_bytes = sizeof(double)*no_bins;
+#if ISOSPEC_GOT_MMAN
+    const bool mapped = acc_bytes >= ISOSPEC_BINNED_MMAP_MIN_BYTES;
 #else
-    // Platforms without mmap use a zero-initialized heap accumulator.
-    acc = reinterpret_cast<double*>(calloc(no_bins, sizeof(double)));
-    if(acc == nullptr)
-        throw std::bad_alloc();
+    constexpr bool mapped = false;
+#endif
+
+    double* acc;
+    if(mapped)
+    {
+#if ISOSPEC_GOT_MMAN
+        acc = reinterpret_cast<double*>(mmap(nullptr, acc_bytes, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+        if(acc == MAP_FAILED)
+            throw std::bad_alloc();
 #endif
-    // Keep the original mapping alive through generator construction and output
-    // growth, both of which can throw. acc is offset below for absolute indexing;
-    // the owner must always retain the actual base address for cleanup.
-    const auto release_acc = [no_bins](double* base) noexcept {
+    }
+    else
+    {
+        acc = reinterpret_cast<double*>(calloc(no_bins, sizeof(double)));
+        if(acc == nullptr)
+            throw std::bad_alloc();
+    }
+    // Keep the accumulator alive through generator construction and output
+    // growth, both of which can throw.
+    const auto release_acc = [acc_bytes, mapped](double* base) noexcept {
 #if ISOSPEC_GOT_MMAN
-        munmap(base, sizeof(double)*no_bins);
+        if(mapped)
+        {
+            munmap(base, acc_bytes);
+            return;
+        }
 #else
-        free(base);
+        (void)acc_bytes;
+        (void)mapped;
 #endif
+        free(base);
     };
     std::unique_ptr<double, decltype(release_acc)> acc_owner(acc, release_acc);
 
@@ -1622,8 +1652,8 @@ FixedEnvelope FixedEnvelope::Binned(Iso&& iso, double target_total_prob, double
 #  ifndef ISOSPEC_BINNED_HUGEPAGE_MIN_BYTES
 #    define ISOSPEC_BINNED_HUGEPAGE_MIN_BYTES (size_t(64) << 20)  // 64 MiB
 #  endif
-    if(sizeof(double)*no_bins >= ISOSPEC_BINNED_HUGEPAGE_MIN_BYTES)
-        madvise(acc, sizeof(double)*no_bins, MADV_HUGEPAGE);
+    if(mapped && acc_bytes >= ISOSPEC_BINNED_HUGEPAGE_MIN_BYTES)
+        madvise(acc, acc_bytes, MADV_HUGEPAGE);
 #endif
 
     std::ptrdiff_t nonzero_slot = 0;

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/fixedEnvelopes.h

@@ -43,6 +43,20 @@
 #  define ISOSPEC_BINNED_LAYER_MAXSTEP (-3.0)
 #endif
 
+// Binned() takes its bin accumulator from calloc below this size, and maps it
+// anonymously at and above it.  The mmap path costs a fixed 2-25 us (map, page
+// faults, unmap: 2.5 on Alder Lake, 2 on M1 macOS, 8 under WSL2, 25 in a KVM
+// guest), which calloc saves; calloc in turn zeroes the whole range, which the
+// mmap path never touches beyond the populated bins.  Measured as calloc/mmap
+// time: glucose at 0.001 Da (241 KB) 0.43 / 0.21 / 0.63 / 0.43 on those four,
+// a 1 kDa peptide at 0.01 Da (157 KB) 0.69 / 0.30 / 0.80 / 0.53.  Where calloc
+// starts to lose depends on how much of the range is populated: on Alder Lake,
+// insulin breaks even at ~300 KB, a 1 kDa peptide at ~1 MB; the other hosts
+// tolerate 1-2 MB.  256 KiB never loses on the primary target.
+#ifndef ISOSPEC_BINNED_MMAP_MIN_BYTES
+#  define ISOSPEC_BINNED_MMAP_MIN_BYTES (std::size_t(256) << 10)
+#endif
+
 // The same knob for total_prob_init, which can afford a wider step than Binned:
 // it trims afterwards, so overshooting the target costs only the work of
 // generating what gets thrown away.

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/isoMath.cpp

@@ -10,7 +10,10 @@
 // NOLINT(legal/copyright)
 
 
+#include <algorithm>
 #include <cmath>
+#include <cstdint>
+#include <limits>
 #include <cstdlib>
 #include <new>
 #include "isoMath.h"
@@ -180,51 +183,150 @@ double NormalPDF(double x, double mean, double stdev)
 
 const double sqrt_pi = 1.772453850905516027298167483341145182798;
 
-double LowerIncompleteGamma2(int a, double x)
+namespace
 {
-    double base;
-    double exp_minus_x = exp(-x);
-    double current_s;
-    if(a % 2 == 0)
-    {
-        base = 1 - exp_minus_x;
-        current_s = 1.0;
-        a--;
-    }
-    else
+// The regularised incomplete gamma functions at a = k/2, k >= 1: their values
+// P(a, s) and Q(a, s) = 1 - P(a, s), each computed directly so that neither
+// loses its relative precision to cancellation in its tail, and the density
+// dP/ds = s^(a-1) e^(-s) / Gamma(a), which every Halley step needs anyway.
+// `lgamma_a` is lnGamma(a). Region by region, as Boost's gamma_p does it:
+//   s <  a+1:  P = s^a e^-s / Gamma(a+1) * sum_n s^n / ((a+1)...(a+n)),
+//              whose prefix is density * s / a and whose terms fall at once;
+//   s >= a+1:  Q's finite sum, for k = 2m and k = 2m+1
+//              Q(m, s)     = e^-s * sum_{j<m} s^j / j!
+//              Q(m+1/2, s) = erfc(sqrt(s)) + e^-s * sum_{j<m} s^(j+1/2) / Gamma(j+3/2),
+//              summed downward from its last term, which is the density:
+//              each term is the next one times (j+a-m)/s < 1, so nothing
+//              overflows whatever k, and the sum stops once the terms are
+//              below rounding.
+struct GammaHalf
+{
+    double P, Q, density;
+};
+
+GammaHalf gamma_half(int k, double s, double lgamma_a)
+{
+    const double a = 0.5 * k;
+    const double density = exp((a - 1.0) * log(s) - s - lgamma_a);
+
+    if(s < a + 1.0)
     {
-        base = sqrt_pi * erf(sqrt(x));
-        current_s = 0.5;
+        double t = 1.0, series = 1.0;
+        for(double d = a + 1.0; t > series * 0x1p-54; d += 1.0)
+        {
+            t *= s / d;
+            series += t;
+        }
+        const double P = density * (s / a) * series;
+        return {P, 1.0 - P, density};
     }
 
-    a = a/2;
-    for(; a; a--)
+    double sum = 0.0, t = density;
+    for(int i = 0; i < k / 2 && t > sum * 0x1p-54; i++)
     {
-        base = base * current_s - pow(x, current_s) * exp_minus_x;
-        current_s += 1.0;
+        sum += t;
+        t *= (a - 1.0 - i) / s;
     }
-
-    return base;
+    const double Q = (k % 2 == 0) ? sum : erfc(sqrt(s)) + sum;
+    return {1.0 - Q, Q, density};
 }
+}  // namespace
 
-double InverseLowerIncompleteGamma2(int a, double x)
+double InverseChiSquareCDF2(int k, double x)
 {
-    double l = 0.0;
-    double p = tgamma(a);
-    double s;
-
-    do {
-        s = (l+p) / 2.0;
-        double v = LowerIncompleteGamma2(a, s);
-        if (x < v)
-            p = s;
+    // q = 2s with P(k/2, s) = x. The initial guess is the larger of
+    //   * Wilson and Hilferty (1931): (q/k)^(1/3) is close to normal with mean
+    //     1 - 2/(9k) and variance 2/(9k), so q ~ k (1 - 2/(9k) + z sqrt(2/(9k)))^3
+    //     with z the normal quantile of x -- within a fraction of a percent
+    //     away from the far tails;
+    //   * the leading term of P's series, P(a, s) <= s^a / Gamma(a+1), whose
+    //     inverse s = (x Gamma(a+1))^(1/a) is a lower bound on the root
+    //     everywhere and accurate in the lower tail, where Wilson-Hilferty's
+    //     cube can go negative.
+    // Then Halley's iteration (as in DiDonato and Morris 1986, and Boost's
+    // gamma_p_inv): f'' / f' = (a-1)/s - 1 for f = P(a, s) - x, so each step
+    // costs one evaluation of gamma_half, and from this guess two (rarely
+    // more; at most 10 in the far tails of k < 10) reach full precision. The callers need about 0.1% (the quantile
+    // only orders marginals by estimated size), but the steps past that cost
+    // little and make the function testable against reference values. No
+    // tgamma or pow: one exp and one log per step, lnGamma from lgamma_half.
+    //
+    // Defined everywhere, so that the sort keys built from it are never NaN:
+    // 0 for k <= 0 (no freedom) and for x <= 0 or NaN; x >= 1, whose quantile
+    // is infinite, is answered at the largest double below 1.
+    if(k <= 0 || !(x > 0.0))
+        return 0.0;
+    x = (std::min)(x, 1.0 - 0x1p-53);
+    if(k == 2)
+        return -2.0 * log1p(-x);   // exponential with mean 2: exact
+
+    const double a = 0.5 * k;
+    // lnGamma(1/2) = ln(sqrt(pi)) is below lgamma_half's domain.
+    const double lgamma_a = k == 1 ? 0.5723649429247001 : lgamma_half(k);
+
+    double s_wh;
+    if(k == 1 && x >= 0.5)
+    {
+        // The square of a standard normal: q = z^2 for z the normal quantile
+        // at (1+x)/2, taken from its tail (1-x)/2, which keeps its precision;
+        // NormalCDFInverse's 4.5e-4 makes it a guess. Below the median the
+        // series bound is the better one.
+        const double z = NormalCDFInverse(0.5 * (1.0 - x));
+        s_wh = 0.5 * z * z;
+    }
+    else
+    {
+        const double v = 2.0 / (9.0 * k);
+        const double h = 1.0 - v + NormalCDFInverse(x) * sqrt(v);
+        s_wh = h > 0.0 ? a * h * h * h : 0.0;
+    }
+    const double lower_bound = exp((log(x) + lgamma_half(static_cast<std::int64_t>(k) + 2)) / a);
+    double s = (std::max)(s_wh, lower_bound);
+    if(!(s > 0.0))
+        return 0.0;   // below the smallest double
+
+    // Solved for P below the median and for Q above it, in whichever tail
+    // keeps its relative precision; both are increasing in s.
+    const bool upper = x > 0.5;
+    const double target = upper ? 1.0 - x : x;
+    double lo = lower_bound, hi = std::numeric_limits<double>::infinity();
+    for(int iteration = 0; iteration < 100; iteration++)
+    {
+        const GammaHalf g = gamma_half(k, s, lgamma_a);
+        const double f = upper ? target - g.Q : g.P - target;
+        if(f == 0.0 || !(g.density > 0.0))
+            break;
+        if(f < 0.0)
+            lo = s;
         else
-            l = s;
-    } while((p-l)*1000.0 > p);
-
-    return s;
+            hi = s;
+        const double newton = f / g.density;
+        const double curvature = 1.0 - 0.5 * newton * ((a - 1.0) / s - 1.0);
+        const double halley = curvature > 0.5 ? newton / curvature : newton;
+        // Converged once the step is below 2^-20 relative: Halley's error
+        // after a step of d is of order d^3, so taking that step puts s
+        // within rounding of the root (checked over k = 1..1000 and x from
+        // 1e-15 to 1 - 1e-15 against SciPy: worst 4e-14, one evaluation
+        // fewer than a 2^-40 test, the same answers). Checked before the
+        // bracket, which a step below one ulp of s cannot enter.
+        if(fabs(halley) <= s * 0x1p-20)
+        {
+            s -= halley;
+            break;
+        }
+        // A step leaving the bracket falls back to Newton's, then to
+        // bisection (or doubling, while the bracket has no upper end).
+        double next = s - halley;
+        if(!(next > lo && next < hi))
+            next = s - newton;
+        if(!(next > lo && next < hi))
+            next = std::isfinite(hi) ? 0.5 * (lo + hi) : 2.0 * (std::max)(s, lo);
+        s = next;
+    }
+    return 2.0 * s;
 }
 
+
 thread_local std::mt19937 random_gen(std::random_device{}());
 
 size_t rdvariate_binom(size_t tries, double succ_prob, std::mt19937& rgen)

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/isoMath.h

@@ -110,17 +110,11 @@ double NormalCDFInverse(double p, double mean, double stdev);
 double NormalCDF(double x, double mean, double stdev);
 double NormalPDF(double x, double mean = 0.0, double stdev = 1.0);
 
-// Returns lower incomplete gamma function of a/2, x, where a is int and > 0.
-double LowerIncompleteGamma2(int a, double x);
-
-// Returns y such that LowerIncompleteGamma2(a, y) == x. Approximately.
-double InverseLowerIncompleteGamma2(int a, double x);
-
-// Computes the inverse Cumulative Distribution Funcion of the Chi-Square distribution with k degrees of freedom
-inline double InverseChiSquareCDF2(int k, double x)
-{
-    return InverseLowerIncompleteGamma2(k, x*tgamma(static_cast<double>(k)/2.0)) * 2.0;
-}
+// The quantile function (inverse CDF) of the chi-square distribution with k
+// degrees of freedom at x: q with P(k/2, q/2) = x, to about 1e-12 relative
+// (tested against SciPy). 0 for k <= 0 and for x <= 0 or NaN; finite for
+// x >= 1. Thread-safe: no lgamma.
+double InverseChiSquareCDF2(int k, double x);
 
 extern thread_local std::mt19937 random_gen;
 

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/marginalTrek++.cpp

@@ -736,8 +736,12 @@ bool LayeredMarginal::extend(double new_threshold, bool do_sort)
     for(size_t ii = 0; ii < ISOSPEC_LPROB_GUARDIANS; ii++)
         lProbs.pop_back();  // Remove the trailing -inf guardians; restored at the end
 
-    pod_vector<Conf> new_fringe;
-    pod_vector<double> new_fringe_unn_lprobs;
+    // Empty already (swapped with the drained fringe at the end of the last
+    // call), unless that call threw partway.
+    pod_vector<Conf>& new_fringe = next_fringe;
+    pod_vector<double>& new_fringe_unn_lprobs = next_fringe_unn_lprobs;
+    new_fringe.clear_keep_capacity();
+    new_fringe_unn_lprobs.clear_keep_capacity();
 
     while(!fringe.empty())
     {
@@ -809,10 +813,15 @@ bool LayeredMarginal::extend(double new_threshold, bool do_sort)
         size_t to_sort_size = configurations.size() - probs.size();
         if(to_sort_size > 0)
         {
-            std::unique_ptr<size_t[]> order_arr(get_inverse_order(lProbs.data()+1+probs.size(), to_sort_size));
+            // get_inverse_order(), into the reused sort_order.
             double* P = lProbs.data()+1+probs.size();
             Conf* C = configurations.data()+probs.size();
-            size_t* O = order_arr.get();
+            sort_order.clear_keep_capacity();
+            sort_order.resize(to_sort_size);
+            size_t* O = sort_order.data();
+            for(size_t ii = 0; ii < to_sort_size; ii++)
+                O[ii] = ii;
+            std::sort(O, O + to_sort_size, [P](size_t i, size_t j) { return P[i] > P[j]; });
             impose_order(O, to_sort_size, P, C);
         }
     }

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/marginalTrek++.h

@@ -402,6 +402,12 @@ class LayeredMarginal : public Marginal
     pod_vector<Conf> configurations;
     pod_vector<Conf> fringe;
     pod_vector<double> fringe_unn_lprobs;
+    // extend()'s scratch, kept between calls so that a layer allocates
+    // nothing once they have grown: the fringe below the new threshold (then
+    // swapped with fringe), and the sort order of the new configurations.
+    pod_vector<Conf> next_fringe;
+    pod_vector<double> next_fringe_unn_lprobs;
+    pod_vector<size_t> sort_order;
     Allocator<int> allocator;
     pod_vector<double> lProbs;
     pod_vector<double> probs;

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpec++/pod_vector.h

@@ -19,6 +19,7 @@
 #include <type_traits>
 #include <cstdlib>
 #include <cstddef>
+#include <cstring>
 #include <utility>
 #include <new>
 #include <algorithm>
@@ -29,19 +30,66 @@
 
 template<typename T> class unsafe_pod_vector;
 
+// The first inline_capacity elements live inside the object itself; the
+// store moves to the heap only when the vector outgrows them, and stays there.
+// Most vectors in the library (a marginal's configurations, probabilities and
+// masses, a layer's fringe) never get past a handful of elements, so they
+// cost no allocation at all. The flip side: unlike a plain heap vector, a move
+// or swap of a vector that is still inline copies its elements, so pointers
+// into data() do not survive either. (unsafe_pod_vector, below, has no inline
+// storage: it must stay trivially copyable, and a self-pointer would not.)
 template<typename T> class pod_vector
 {
+ public:
+    static constexpr size_t inline_capacity = 16;
+
+ private:
     T* backend_past_end;
     T* first_free;
     T* store;
+    alignas(T) unsigned char inline_buf[inline_capacity * sizeof(T)];
+
+    ISOSPEC_FORCE_INLINE T* inline_store() noexcept { return reinterpret_cast<T*>(inline_buf); }
+    ISOSPEC_FORCE_INLINE bool is_inline() const noexcept { return store == reinterpret_cast<const T*>(inline_buf); }
+
+    void reset_to_inline() noexcept
+    {
+        store = first_free = inline_store();
+        backend_past_end = store + inline_capacity;
+    }
+
+    // Takes other's contents; *this must hold no heap store. other is left
+    // empty and inline.
+    void take(pod_vector<T>& other) noexcept
+    {
+        if(other.is_inline())
+        {
+            const size_t n = other.size();
+            reset_to_inline();
+            memcpy(static_cast<void*>(store), other.store, n * sizeof(T));
+            first_free = store + n;
+        }
+        else
+        {
+            backend_past_end = other.backend_past_end;
+            first_free = other.first_free;
+            store = other.store;
+        }
+        other.reset_to_inline();
+    }
 
  public:
-    explicit pod_vector(size_t initial_size = 16)
+    explicit pod_vector(size_t initial_size = inline_capacity)
     {
     #if !ISOSPEC_BUILDING_R
         static_assert(std::is_trivially_copyable<T>::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
     #endif
 
+        if(initial_size <= inline_capacity)
+        {
+            reset_to_inline();
+            return;
+        }
         store = reinterpret_cast<T*>(malloc(sizeof(T) * initial_size));
         if(store == NULL)
             throw std::bad_alloc();
@@ -51,25 +99,20 @@ template<typename T> class pod_vector
 
     pod_vector(const pod_vector<T>& other) = delete;
     pod_vector& operator=(const pod_vector<T>& other) = delete;
-    pod_vector& operator=(pod_vector<T>&& other)
+    pod_vector& operator=(pod_vector<T>&& other) noexcept
     {
-        free(store);
-        backend_past_end = other.backend_past_end;
-        first_free = other.first_free;
-        store = other.store;
-        other.backend_past_end = other.first_free = other.store = NULL;
+        if(this != &other)
+        {
+            if(!is_inline())
+                free(store);
+            take(other);
+        }
         return *this;
     }
 
-    pod_vector(pod_vector<T>&& other)
-    {
-        backend_past_end = other.backend_past_end;
-        first_free = other.first_free;
-        store = other.store;
-        other.backend_past_end = other.first_free = other.store = NULL;
-    }
+    pod_vector(pod_vector<T>&& other) noexcept { take(other); }
 
-    ~pod_vector() { free(store); backend_past_end = first_free = store = NULL; }
+    ~pod_vector() { if(!is_inline()) free(store); }
 
     explicit pod_vector(unsafe_pod_vector<T>&& other)
     {
@@ -83,9 +126,20 @@ template<typename T> class pod_vector
     {
         ISOSPEC_IMPOSSIBLE(n < static_cast<size_t>(backend_past_end - store));
         const std::ptrdiff_t store_used_size = first_free - store;
-        T* new_store = reinterpret_cast<T*>(realloc(store, n * sizeof(T)));
-        if(new_store == NULL)
-            throw std::bad_alloc();
+        T* new_store;
+        if(is_inline())
+        {
+            new_store = reinterpret_cast<T*>(malloc(n * sizeof(T)));
+            if(new_store == NULL)
+                throw std::bad_alloc();
+            memcpy(static_cast<void*>(new_store), store, store_used_size * sizeof(T));
+        }
+        else
+        {
+            new_store = reinterpret_cast<T*>(realloc(store, n * sizeof(T)));
+            if(new_store == NULL)
+                throw std::bad_alloc();
+        }
         first_free = new_store + store_used_size;
         backend_past_end = new_store + n;
         store = new_store;
@@ -187,9 +241,16 @@ template<typename T> class pod_vector
 
     void swap(pod_vector<T>& other) noexcept
     {
-        std::swap(backend_past_end, other.backend_past_end);
-        std::swap(first_free, other.first_free);
-        std::swap(store, other.store);
+        if(!is_inline() && !other.is_inline())
+        {
+            std::swap(backend_past_end, other.backend_past_end);
+            std::swap(first_free, other.first_free);
+            std::swap(store, other.store);
+            return;
+        }
+        pod_vector<T> tmp(std::move(other));
+        other.take(*this);
+        take(tmp);
     }
 
     typedef T* iterator;
@@ -214,10 +275,14 @@ template<typename T> class pod_vector
 
     void clear()
     {
-        free(store);
-        first_free = store = backend_past_end = NULL;
+        if(!is_inline())
+            free(store);
+        reset_to_inline();
     }
 
+    // Unlike clear(), keeps the storage for reuse.
+    void clear_keep_capacity() noexcept { first_free = store; }
+
     friend class unsafe_pod_vector<T>;
 };
 

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpecPy/IsoSpecPy.py

@@ -506,6 +506,12 @@ class Iso(object):
     def parse_conf(self, cptr, starting_with = 0):
         return tuple(tuple(cptr[i+starting_with] for i in o) for o in self.offsets)
 
+    def _hand_over(self):
+        """Gives the C Iso away to a *Consuming setup call, which deletes it,
+        and leaves this object without one. Saves that call copying it."""
+        c_iso, self.iso = self.iso, None
+        return c_iso
+
     def _get_parse_conf_fun(self):
         # Can't just use the above function as lambda, as the entire class instance will be in closure
         offsets = self.offsets
@@ -894,7 +900,7 @@ def IsoThreshold(threshold,
         **kwds: named arguments to IsoSpectrum.
     """
     iso = Iso(formula = formula, get_confs = get_confs, **kwargs)
-    tabulator = _check_pointer(isoFFI.clib.setupThresholdFixedEnvelope(iso.iso, threshold, absolute, get_confs),
+    tabulator = _check_pointer(isoFFI.clib.setupThresholdFixedEnvelopeConsuming(iso._hand_over(), threshold, absolute, get_confs),
                                "setupThresholdFixedEnvelope")
     ido = IsoDistribution(cobject = tabulator, get_confs = get_confs, iso = iso)
     isoFFI.clib.deleteFixedEnvelope(tabulator, False)
@@ -916,7 +922,7 @@ def IsoTotalProb(prob_to_cover,
             **kwargs: named arguments to the superclass.
         """
         iso = Iso(formula=formula, get_confs=get_confs, **kwargs)
-        tabulator = _check_pointer(isoFFI.clib.setupTotalProbFixedEnvelope(iso.iso, prob_to_cover, get_minimal_pset, get_confs),
+        tabulator = _check_pointer(isoFFI.clib.setupTotalProbFixedEnvelopeConsuming(iso._hand_over(), prob_to_cover, get_minimal_pset, get_confs),
                                    "setupTotalProbFixedEnvelope")
         ido = IsoDistribution(cobject = tabulator, get_confs = get_confs, iso = iso)
         isoFFI.clib.deleteFixedEnvelope(tabulator, False)
@@ -947,9 +953,9 @@ def IsoStochastic(no_molecules,
         """
         iso = Iso(formula=formula, get_confs=get_confs, **kwargs)
         if seed is None:
-            tabulator = isoFFI.clib.setupStochasticFixedEnvelope(iso.iso, no_molecules, precision, beta_bias, get_confs)
+            tabulator = isoFFI.clib.setupStochasticFixedEnvelopeConsuming(iso._hand_over(), no_molecules, precision, beta_bias, get_confs)
         else:
-            tabulator = isoFFI.clib.setupStochasticFixedEnvelopeSeeded(iso.iso, no_molecules, precision, beta_bias,
+            tabulator = isoFFI.clib.setupStochasticFixedEnvelopeSeededConsuming(iso._hand_over(), no_molecules, precision, beta_bias,
                                                                        get_confs, _check_seed(seed))
         _check_pointer(tabulator, "setupStochasticFixedEnvelope")
         ido = IsoDistribution(cobject = tabulator, get_confs = get_confs, iso = iso)
@@ -973,7 +979,7 @@ def IsoBinned(bin_width,
             **kwargs: named arguments to the superclass.
         """
         iso = Iso(formula=formula, get_confs=False, **kwargs)
-        tabulator = _check_pointer(isoFFI.clib.setupBinnedFixedEnvelope(iso.iso, target_total_prob, bin_width, bin_middle),
+        tabulator = _check_pointer(isoFFI.clib.setupBinnedFixedEnvelopeConsuming(iso._hand_over(), target_total_prob, bin_width, bin_middle),
                                    "setupBinnedFixedEnvelope")
         ido = IsoDistribution(cobject = tabulator, get_confs = False, iso = iso)
         isoFFI.clib.deleteFixedEnvelope(tabulator, False)

{isospecpy-2.6.0 → isospecpy-2.6.1}/src/IsoSpecPy/isoFFI.py

@@ -92,17 +92,30 @@ class IsoFFI:
                                     double threshold,
                                     bool absolute,
                                     bool get_confs);
+        void* setupThresholdFixedEnvelopeConsuming(void* iso,
+                                    double threshold,
+                                    bool absolute,
+                                    bool get_confs);
 
         void* setupTotalProbFixedEnvelope(void* iso,
                                       double taget_coverage,
                                       bool optimize,
                                       bool get_confs);
+        void* setupTotalProbFixedEnvelopeConsuming(void* iso,
+                                      double taget_coverage,
+                                      bool optimize,
+                                      bool get_confs);
 
         void* setupStochasticFixedEnvelope(void* iso,
                                      size_t no_molecules,
                                      double precision,
                                      double beta_bias,
                                      bool get_confs);
+        void* setupStochasticFixedEnvelopeConsuming(void* iso,
+                                     size_t no_molecules,
+                                     double precision,
+                                     double beta_bias,
+                                     bool get_confs);
 
         void* setupStochasticFixedEnvelopeSeeded(void* iso,
                                      size_t no_molecules,
@@ -110,11 +123,21 @@ class IsoFFI:
                                      double beta_bias,
                                      bool get_confs,
                                      uint64_t seed);
+        void* setupStochasticFixedEnvelopeSeededConsuming(void* iso,
+                                     size_t no_molecules,
+                                     double precision,
+                                     double beta_bias,
+                                     bool get_confs,
+                                     uint64_t seed);
 
         void* setupBinnedFixedEnvelope(void* iso,
                             double target_total_prob,
                             double bin_width,
                             double bin_middle);
+        void* setupBinnedFixedEnvelopeConsuming(void* iso,
+                            double target_total_prob,
+                            double bin_width,
+                            double bin_middle);
 
         void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_sorted, bool prob_sorted, double total_prob);
         void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob);

isospecpy-2.6.0/VERSION

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