IsoSpecPy 2.3.4__tar.gz → 2.3.5__tar.gz

{isospecpy-2.3.4 → isospecpy-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.3.4
+Version: 2.3.5
 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

{isospecpy-2.3.4 → isospecpy-2.3.5}/pyproject.toml

@@ -9,7 +9,7 @@ cmake.source-dir = "skbuild"
 name = "IsoSpecPy"
 dependencies = ["cffi"]
 description = "IsoSpecPy is a Python library for computing isotopic distributions of molecules."
-version = "2.3.4"
+version = "2.3.5"
 license = "BSD-2-Clause"
 license-files = ["LICENCE"]
 authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpec++/cwrapper.cpp

@@ -129,8 +129,9 @@ double* getMarginalLogSizeEstimates(void* iso, double target_total_prob)
 {
     Iso* i = reinterpret_cast<Iso*>(iso);
     double* ret = reinterpret_cast<double*>(malloc(sizeof(double)*i->getDimNumber()));
-    if(ret != nullptr)
-        i->saveMarginalLogSizeEstimates(ret, target_total_prob);
+    if(ret == nullptr)
+        throw std::bad_alloc();
+    i->saveMarginalLogSizeEstimates(ret, target_total_prob);
     return ret;
 }
 
@@ -383,13 +384,6 @@ double abyssalWassersteinDistance(void* tabulator1, void* tabulator2, double aby
     return reinterpret_cast<FixedEnvelope*>(tabulator1)->AbyssalWassersteinDistance(*reinterpret_cast<FixedEnvelope*>(tabulator2), abyss_depth, other_scale);
 }
 
-#if 0
-double abyssalWassersteinDistanceGrad(void* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the)
-{
-    return AbyssalWassersteinDistanceGrad(reinterpret_cast<FixedEnvelope* const*>(envelopes), scales, ret_gradient, N, abyss_depth_exp, abyss_depth_the);
-}
-#endif
-
 struct ws_match_res wassersteinMatch(void* tabulator1, void* tabulator2, double flow_dist, double other_scale)
 {
     struct ws_match_res res;
@@ -483,7 +477,7 @@ void array_fma(double* array, size_t N, double mul, double add)
 #if defined(FP_FAST_FMA)
         array[ii] = std::fma(array[ii], mul, add);
 #else
-        array[ii] += (array[ii] * mul) + add;
+        array[ii] = (array[ii] * mul) + add;
 #endif
 }
 

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpec++/fixedEnvelopes.cpp

@@ -28,9 +28,11 @@ _probs(array_copy_malloc<double>(other._probs, other._confs_no)),
 _confs(array_copy_nptr_malloc<int>(other._confs, other._confs_no*other.allDim)),
 _confs_no(other._confs_no),
 allDim(other.allDim),
+allDimSizeofInt(other.allDimSizeofInt),
 sorted_by_mass(other.sorted_by_mass),
 sorted_by_prob(other.sorted_by_prob),
-total_prob(other.total_prob)
+total_prob(other.total_prob),
+current_size(other._confs_no)
 {}
 
 FixedEnvelope::FixedEnvelope(FixedEnvelope&& other) :
@@ -39,15 +41,60 @@ _probs(other._probs),
 _confs(other._confs),
 _confs_no(other._confs_no),
 allDim(other.allDim),
+allDimSizeofInt(other.allDimSizeofInt),
 sorted_by_mass(other.sorted_by_mass),
 sorted_by_prob(other.sorted_by_prob),
-total_prob(other.total_prob)
+total_prob(other.total_prob),
+current_size(other.current_size)
 {
 other._masses = nullptr;
 other._probs  = nullptr;
 other._confs  = nullptr;
 other._confs_no = 0;
 other.total_prob = 0.0;
+other.current_size = 0;
+}
+
+FixedEnvelope& FixedEnvelope::operator=(const FixedEnvelope& other)
+{
+    if(this == &other)
+        return *this;
+    // Copy-and-swap: construct the copy first so that if any allocation inside
+    // the copy constructor throws, *this is left untouched.  Only after tmp is
+    // fully built do we pilfer its pointers; tmp then destructs holding the old
+    // ones, which frees them without any possibility of failure.
+    FixedEnvelope tmp(other);
+    std::swap(_masses,         tmp._masses);
+    std::swap(_probs,          tmp._probs);
+    std::swap(_confs,          tmp._confs);
+    _confs_no       = tmp._confs_no;
+    allDim          = tmp.allDim;
+    allDimSizeofInt = tmp.allDimSizeofInt;
+    sorted_by_mass  = tmp.sorted_by_mass;
+    sorted_by_prob  = tmp.sorted_by_prob;
+    total_prob      = tmp.total_prob;
+    current_size    = tmp.current_size;
+    return *this;
+}
+
+FixedEnvelope& FixedEnvelope::operator=(FixedEnvelope&& other)
+{
+    if(this == &other)
+        return *this;
+    free(_masses);
+    free(_probs);
+    free(_confs);
+    _masses         = other._masses;         other._masses      = nullptr;
+    _probs          = other._probs;          other._probs       = nullptr;
+    _confs          = other._confs;          other._confs       = nullptr;
+    _confs_no       = other._confs_no;       other._confs_no    = 0;
+    allDim          = other.allDim;
+    allDimSizeofInt = other.allDimSizeofInt;
+    sorted_by_mass  = other.sorted_by_mass;
+    sorted_by_prob  = other.sorted_by_prob;
+    total_prob      = other.total_prob;      other.total_prob   = 0.0;
+    current_size    = other.current_size;    other.current_size = 0;
+    return *this;
 }
 
 FixedEnvelope::FixedEnvelope(double* in_masses, double* in_probs, size_t in_confs_no, bool masses_sorted, bool probs_sorted, double _total_prob) :
@@ -246,6 +293,12 @@ void FixedEnvelope::resample(size_t samples, double beta_bias)
     double cprob = 0.0;
     size_t pidx = -1; // Overflows - but it doesn't matter.
 
+    // Sentinel: prevents the inner while(pprob < cprob) from walking off the end
+    // if floating-point rounding leaves the accumulated probability sum slightly
+    // below 1.0. Safe to overwrite in-place: rdvariate_binom guards succ_prob>=1.0
+    // so infinity is handled correctly, and the sentinel is always cleaned up before
+    // return — either by the loop zeroing the slot when it advances pidx to here,
+    // or by the memset below when the loop terminates earlier.
     _probs[_confs_no-1] = (std::numeric_limits<double>::max)();
 
     while(samples > 0)
@@ -502,244 +555,6 @@ double FixedEnvelope::AbyssalWassersteinDistance(FixedEnvelope& other, double ab
     return accd + condemned * abyss_depth * 0.5;
 }
 
-#if 0
-double FixedEnvelope::ScaledAbyssalWassersteinDistance(FixedEnvelope * const * others, double abyss_depth, const double* other_scales, const size_t N)
-{
-    sort_by_mass();
-
-    std::priority_queue<std::pair<double, size_t>> PQ;
-    std::unique_ptr<size_t[]> indices = std::make_unique<size_t[]>(N);
-    memset(indices.get(), 0, sizeof(size_t)*N);
-
-    for(size_t ii=0; ii<N; ii++)
-    {
-        others[ii]->sort_by_mass();
-        if(others[ii]->_confs_no > 0)
-            PQ.emplace_back({others._probs[0], ii});
-    }
-
-
-
-
-    std::vector<std::pair<double, double>> carried;
-
-    size_t idx_this = 0;
-    size_t idx_other = 0;
-
-    //std::cout << "AAA" << std::endl;
-
-    auto finished = [&]() -> bool { return idx_this >= _confs_no && PQ.empty(); };
-    auto next = [&]() -> std::tuple<double, double, size_t> {
-                            if(idx_this >= _confs_no || (idx_other < other._confs_no && _masses[idx_this] > other._masses[idx_other]))
-                            {
-                                std::pair<double, double> res = std::pair<double, double>(other._masses[idx_other], other._probs[idx_other]*other_scale);
-                                idx_other++;
-                                return res;
-                            }
-                            else
-                            {
-                                std::pair<double, double> res = std::pair<double, double>(_masses[idx_this], -_probs[idx_this]);
-                                idx_this++;
-                                return res;
-                            }
-                        };
-    double accd = 0.0;
-    double condemned = 0.0;
-
-    while(!finished())
-    {
-        auto [m, p] = next();
-        if(!carried.empty() && carried[0].second * p > 0.0)
-        {
-            carried.emplace_back(m, p);
-            continue;
-        }
-
-        while(!carried.empty())
-        {
-            auto& [cm, cp] = carried.back();
-            if(m - cm >= abyss_depth)
-            {
-                for(auto it = carried.cbegin(); it != carried.cend(); it++)
-                    condemned += fabs(it->second);
-                carried.clear();
-                break;
-            }
-            if((cp+p)*p > 0.0)
-            {
-                accd += fabs((m-cm)*cp);
-                p += cp;
-                carried.pop_back();
-            }
-            else
-            {
-                accd += fabs((m-cm)*p);
-                cp += p;
-                p = 0.0;
-                break;
-            }
-        }
-        if(p != 0.0)
-            carried.emplace_back(m, p);
-        //std::cout << m << " " << p << std::endl;
-    }
-
-    for(auto it = carried.cbegin(); it != carried.cend(); it++)
-        condemned += fabs(it->second);
-
-    return accd + condemned * abyss_depth * 0.5;
-}
-
-#endif
-
-#if 0
-double AbyssalWassersteinDistanceGrad(FixedEnvelope* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the)
-{
-return 0.0;
-    std::unique_ptr<size_t[]> env_idx = std::make_unique<size_t[]>(N+1);
-    memset(env_idx.get(), 0, (N+1)*sizeof(size_t));
-    memset(ret_gradient, 0, (N+1)*sizeof(double));
-
-    auto pq_cmp = [](std::pair<double, size_t>& p1, std::pair<double, size_t>& p2) { return p1.first > p2.first; };
-    std::priority_queue<std::pair<double, size_t>, std::vector<std::pair<double, size_t>>, decltype(pq_cmp)> PQ(pq_cmp);
-
-    for(size_t ii=0; ii<=N; ii++)
-    {
-        envelopes[ii]->sort_by_mass();
-        if(envelopes[ii]->_confs_no > 0)
-        {
-            std::cout << "Initial push: " << envelopes[ii]->_masses[0] << " " << ii << '\n';
-            PQ.push({envelopes[ii]->_masses[0], ii});
-        }
-    }
-
-    std::vector<std::tuple<double, double, size_t>> carried;
-
-    auto next = [&]() -> std::tuple<double, double, size_t> {
-                            auto [mass, eidx] = PQ.top();
-                            double prob = envelopes[eidx]->_probs[env_idx[eidx]];
-                            PQ.pop();
-                            if(eidx == 0)
-                                prob = -prob;
-                            else
-                                prob = prob * scales[eidx];
-                            std::cout << "Next: " << mass << " " << prob << " " << eidx << '\n';
-                            env_idx[eidx]++;
-                            if(env_idx[eidx] < envelopes[eidx]->_confs_no)
-                                PQ.push({envelopes[eidx]->_masses[env_idx[eidx]], eidx});
-
-                            return {mass, prob, eidx};
-                        };
-    double accd = 0.0;
-    double condemned = 0.0;
-    //double flow;
-    const double max_flow_dist = abyss_depth_exp + abyss_depth_the;
-    max_flow_dist *= 2.0;
-
-    while(!PQ.empty())
-    {
-        auto [m, p, eidx] = next();
-        if(!carried.empty() && std::get<1>(carried[0]) * p > 0.0)
-        {
-            carried.emplace_back(m, p, eidx);
-            continue;
-        }
-
-        while(!carried.empty())
-        {
-            auto& [cm, cp, ceidx] = carried.back();
-            if(m - cm >= max_flow_dist)
-            {
-                for(auto it = carried.cbegin(); it != carried.cend(); it++)
-                    condemned += fabs(std::get<1>(*it));
-                carried.clear();
-                break;
-            }
-            std::cout << "accing\n";
-            if((cp+p)*p > 0.0)
-            {
-                accd += fabs((m-cm)*cp);
-                p += cp;
-                carried.pop_back();
-                std::cout << "cprob:" << cp << '\n';
-            }
-            else
-            {
-                accd += fabs((m-cm)*p);
-                cp += p;
-                std::cout << "prob:" << p << '\n';
-                p = 0.0;
-                break;
-            }
-        }
-        if(p != 0.0)
-            carried.emplace_back(m, p, eidx);
-        //std::cout << m << " " << p << std::endl;
-    }
-
-    for(auto it = carried.cbegin(); it != carried.cend(); it++)
-        condemned += fabs(std::get<1>(*it));
-
-    std::cout << "ISO:" << accd << " " << condemned << '\n';
-    return accd + condemned * max_flow_dist * 0.5;
-    while(!PQ.empty())
-    {
-        auto [m, p, eidx] = next();
-        if(!carried.empty() && (std::get<1>(carried[0]) * p > 0.0))
-        {
-            carried.emplace_back(m, p, eidx);
-            continue;
-        }
-
-        while(!carried.empty())
-        {
-            auto& [cm, cp, ceidx] = carried.back();
-            if(m - cm >= max_flow_dist)
-            {
-                for(auto it = carried.cbegin(); it != carried.cend(); it++)
-                {
-                    flow = fabs(std::get<1>(*it));
-                    const size_t target_idx = std::get<2>(*it);
-                    flow *= target_idx == 0 ? abyss_depth_exp : abyss_depth_the;
-                    ret_gradient[target_idx] += flow;
-                    condemned += flow;
-                    std::cout << "condemnin': " << m << " " << p << " " << eidx << " | " << cm << " " << cp << " " << ceidx << '\n';
-                }
-                carried.clear();
-                break;
-            }
-            if((cp+p)*p > 0.0)
-            {
-                flow = fabs((m-cm)*cp);
-                accd += flow;
-                p += cp;
-                ret_gradient[ceidx] += flow;
-                carried.pop_back();
-            }
-            else
-            {
-                flow = fabs((m-cm)*p);
-                accd += flow;
-                cp += p;
-                ret_gradient[eidx] += flow;
-                p = 0.0;
-                break;
-            }
-        }
-        if(p != 0.0)
-            carried.emplace_back(m, p, eidx);
-        //std::cout << m << " " << p << std::endl;
-    }
-
-    for(auto it = carried.cbegin(); it != carried.cend(); it++)
-        condemned += fabs(std::get<1>(*it));
-
-
-    return accd + condemned * (abyss_depth_exp + abyss_depth_the) * 0.5;
-}
-#endif
-
-
 std::tuple<double, double, double> FixedEnvelope::WassersteinMatch(FixedEnvelope& other, double flow_distance, double other_scale)
 {
     if(_confs_no == 0)
@@ -867,48 +682,60 @@ FixedEnvelope FixedEnvelope::bin(double bin_width, double middle)
 
 template<bool tgetConfs> void FixedEnvelope::reallocate_memory(size_t new_size)
 {
-    current_size = new_size;
-    // FIXME: Handle overflow gracefully here. It definitely could happen for people still stuck on 32 bits...
-    _masses = reinterpret_cast<double*>(realloc(_masses, new_size * sizeof(double)));
-    if(_masses == nullptr)
+    if(new_size > SIZE_MAX / sizeof(double))
         throw std::bad_alloc();
+    double* tmp_masses = reinterpret_cast<double*>(realloc(_masses, new_size * sizeof(double)));
+    if(tmp_masses == nullptr)
+        throw std::bad_alloc();
+    _masses = tmp_masses;
     tmasses = _masses + _confs_no;
 
-    _probs  = reinterpret_cast<double*>(realloc(_probs,  new_size * sizeof(double)));
-    if(_probs == nullptr)
+    double* tmp_probs = reinterpret_cast<double*>(realloc(_probs,  new_size * sizeof(double)));
+    if(tmp_probs == nullptr)
         throw std::bad_alloc();
+    _probs = tmp_probs;
     tprobs  = _probs  + _confs_no;
 
     constexpr_if(tgetConfs)
     {
-        _confs  = reinterpret_cast<int*>(realloc(_confs,  new_size * allDimSizeofInt));
-        if(_confs == nullptr)
+        if(allDimSizeofInt > 0 && new_size > SIZE_MAX / static_cast<size_t>(allDimSizeofInt))
+            throw std::bad_alloc();
+        int* tmp_confs = reinterpret_cast<int*>(realloc(_confs,  new_size * allDimSizeofInt));
+        if(tmp_confs == nullptr)
             throw std::bad_alloc();
+        _confs = tmp_confs;
         tconfs = _confs + (allDim * _confs_no);
     }
+    current_size = new_size;
 }
 
 void FixedEnvelope::slow_reallocate_memory(size_t new_size)
 {
-    current_size = new_size;
-    // FIXME: Handle overflow gracefully here. It definitely could happen for people still stuck on 32 bits...
-    _masses = reinterpret_cast<double*>(realloc(_masses, new_size * sizeof(double)));
-    if(_masses == nullptr)
+    if(new_size > SIZE_MAX / sizeof(double))
+        throw std::bad_alloc();
+    double* tmp_masses = reinterpret_cast<double*>(realloc(_masses, new_size * sizeof(double)));
+    if(tmp_masses == nullptr)
         throw std::bad_alloc();
+    _masses = tmp_masses;
     tmasses = _masses + _confs_no;
 
-    _probs  = reinterpret_cast<double*>(realloc(_probs,  new_size * sizeof(double)));
-    if(_probs == nullptr)
+    double* tmp_probs = reinterpret_cast<double*>(realloc(_probs,  new_size * sizeof(double)));
+    if(tmp_probs == nullptr)
         throw std::bad_alloc();
+    _probs = tmp_probs;
     tprobs  = _probs  + _confs_no;
 
     if(_confs != nullptr)
     {
-        _confs  = reinterpret_cast<int*>(realloc(_confs,  new_size * allDimSizeofInt));
-        if(_confs == nullptr)
+        if(allDimSizeofInt > 0 && new_size > SIZE_MAX / static_cast<size_t>(allDimSizeofInt))
             throw std::bad_alloc();
+        int* tmp_confs = reinterpret_cast<int*>(realloc(_confs,  new_size * allDimSizeofInt));
+        if(tmp_confs == nullptr)
+            throw std::bad_alloc();
+        _confs = tmp_confs;
         tconfs = _confs + (allDim * _confs_no);
     }
+    current_size = new_size;
 }
 
 template<bool tgetConfs> void FixedEnvelope::threshold_init(Iso&& iso, double threshold, bool absolute)
@@ -1155,7 +982,7 @@ FixedEnvelope FixedEnvelope::Binned(Iso&& iso, double target_total_prob, double
 
         ret.reallocate_memory<false>(ISOSPEC_INIT_TABLE_SIZE);
 
-        for(size_t ii = nonzero_idx; ii >= idx_min && empty_steps < distance_10da; ii--)
+        for(size_t ii = nonzero_idx; empty_steps < distance_10da; )
         {
             if(acc[ii] > 0.0)
             {
@@ -1164,6 +991,8 @@ FixedEnvelope FixedEnvelope::Binned(Iso&& iso, double target_total_prob, double
             }
             else
                 empty_steps++;
+            if(ii == idx_min) break;
+            ii--;
         }
 
         empty_steps = 0;

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpec++/fixedEnvelopes.h

@@ -34,9 +34,6 @@ namespace IsoSpec
 
 class FixedEnvelope;
 
-double AbyssalWassersteinDistanceGrad(FixedEnvelope* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the);
-
-
 class ISOSPEC_EXPORT_SYMBOL FixedEnvelope {
  protected:
     double* _masses;
@@ -61,7 +58,7 @@ class ISOSPEC_EXPORT_SYMBOL FixedEnvelope {
         allDim(0),
         sorted_by_mass(false),
         sorted_by_prob(false),
-        total_prob(0.0),
+        total_prob(NAN),
         current_size(0),
         allDimSizeofInt(0)
         // Deliberately not initializing tmasses, tprobs, tconfs
@@ -69,6 +66,8 @@ class ISOSPEC_EXPORT_SYMBOL FixedEnvelope {
 
     FixedEnvelope(const FixedEnvelope& other);
     FixedEnvelope(FixedEnvelope&& other);
+    FixedEnvelope& operator=(const FixedEnvelope& other);
+    FixedEnvelope& operator=(FixedEnvelope&& other);
 
     FixedEnvelope(double* masses, double* probs, size_t confs_no, bool masses_sorted = false, bool probs_sorted = false, double _total_prob = NAN);
     FixedEnvelope(double* masses, double* probs, int* confs, size_t confs_no, int _allDim, bool masses_sorted = false, bool probs_sorted = false, double _total_prob = NAN);
@@ -239,7 +238,6 @@ class ISOSPEC_EXPORT_SYMBOL FixedEnvelope {
         return Binned(Iso(iso, false), target_total_prob, bin_width, bin_middle);
     }
 
-    friend double AbyssalWassersteinDistanceGrad(FixedEnvelope* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the);
 };
 
 }  // namespace IsoSpec

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpecPy/Distributions.py

@@ -16,7 +16,6 @@ def simple_inverse(fun, prec = 0.01):
             end *= 2.0
 
         while (end - start) > prec:
-            print(start, end)
             mid = (end + start) * 0.5
             if fun(mid) < x:
                 start = mid

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpecPy/IsoSpecPy.py

@@ -62,11 +62,10 @@ def ParseFormula(formula):
 
     return ret
 
-fasta_parsing_space = isoFFI.ffi.new("int[6]")
-
 def ParseFASTA(fasta):
     if isinstance(fasta, str):
         fasta = fasta.encode("ascii")
+    fasta_parsing_space = isoFFI.ffi.new("int[6]")
     isoFFI.clib.parse_fasta_c(fasta, fasta_parsing_space)
     elements = list("CHNOS")
     if fasta_parsing_space[5] > 0:
@@ -183,8 +182,10 @@ class Iso(object):
                     raise ValueError("All isotope probabilities p must fulfill: 0.0 < p <= 1.0")
 
         self.isotopeNumbers = tuple(map(len, self.isotopeMasses))
-        assert self.isotopeNumbers == tuple(map(len, self.isotopeProbabilities))
-        assert len(self.atomCounts) == len(self.isotopeNumbers) == len(self.isotopeProbabilities)
+        if self.isotopeNumbers != tuple(map(len, self.isotopeProbabilities)):
+            raise ValueError("isotopeMasses and isotopeProbabilities must have the same number of isotopes per element")
+        if len(self.atomCounts) != len(self.isotopeNumbers) or len(self.isotopeNumbers) != len(self.isotopeProbabilities):
+            raise ValueError("atomCounts, isotopeMasses, and isotopeProbabilities must all have the same length")
 
         self.dimNumber = len(self.isotopeNumbers)
 
@@ -299,7 +300,7 @@ class IsoDistribution(object):
         try:
             import numpy as np
         except ImportError as e:
-            raise Exception(e.msg + "\nThis requires numpy to be installed.")
+            raise Exception(str(e) + "\nThis requires numpy to be installed.")
         return np.frombuffer(isoFFI.ffi.buffer(self.masses))
 
     def np_probs(self):
@@ -307,7 +308,7 @@ class IsoDistribution(object):
         try:
             import numpy as np
         except ImportError as e:
-            raise Exception(e.msg + "\nThis requires numpy to be installed.")
+            raise Exception(str(e) + "\nThis requires numpy to be installed.")
         return np.frombuffer(isoFFI.ffi.buffer(self.probs))
 
     def __iter__(self):
@@ -358,22 +359,16 @@ class IsoDistribution(object):
                 self.parse_conf = iso._get_parse_conf_fun()
 
         elif probs is not None or masses is not None:
-            assert probs is not None and masses is not None
-            assert len(probs) == len(masses)
+            if probs is None or masses is None:
+                raise ValueError("masses and probs must both be provided together")
+            if len(probs) != len(masses):
+                raise ValueError("masses and probs must have the same length")
             self.size = len(probs)
             type_str = "double["+str(self.size)+"]"
             self.probs  = isoFFI.ffi.new(type_str, probs)
             self.masses = isoFFI.ffi.new(type_str, masses)
-        elif cobject == probs == masses == get_confs == iso == None:
-            self.size = 0
-            type_str = "double["+str(self.size)+"]"
-            self.probs  = isoFFI.ffi.new(type_str, [])
-            self.masses = isoFFI.ffi.new(type_str, [])
-            self._total_prob = 0.0
-            self.mass_sorted = True
-            self.prob_sorted = True
         else:
-            raise RuntimeError("Invalid arguments for IsoDistribution constructor")
+            raise ValueError("IsoDistribution requires at least one of: cobject, or masses+probs")
 
     def _get_cobject(self):
         if hasattr(self, 'raw_confs') and self.raw_confs is not None:
@@ -666,13 +661,15 @@ def IsoStochastic(no_molecules,
                  beta_bias=5.0,
                  get_confs=False,
                  **kwargs):
-        """Initialize the IsoDistribution isotopic distribution by total probability.
+        """Initialize the isotopic distribution by stochastic sampling, simulating a measured mass spectrum
+        with a given number of ions. Each configuration is drawn independently according to its isotopic
+        probability, producing integer ion counts rather than exact probabilities.
 
         Args:
-            no_molecules (uint): ionic current in instrument
+            no_molecules (uint): number of ions to simulate (ionic current).
             formula (str): a chemical formula, e.g. "C2H6O1" or "C2H6O".
-            precision (float): passed to IsoTotalProbGenerator. Between 0.0 and 1.0.
-            beta_bias (float, nonnegative): fiddling with this parameter does not change the result, but might make computations slightly faster (or likely, much, much slower is you screw it up...)
+            precision (float): total probability of the envelope used for sampling. Between 0.0 and 1.0.
+            beta_bias (float, nonnegative): fiddling with this parameter does not change the result, but might make computations slightly faster (or likely, much, much slower if you screw it up...)
             get_confs (boolean): should we report the counts of isotopologues?
             **kwargs: named arguments to the superclass.
         """
@@ -688,14 +685,14 @@ def IsoBinned(bin_width,
                  target_total_prob=0.9999,
                  bin_middle=0.0,
                  **kwargs):
-        """Initialize the IsoDistribution isotopic distribution by total probability.
+        """Initialize the isotopic distribution as a binned (histogram) envelope.
+        Configurations are grouped into bins of equal width and their probabilities summed.
 
         Args:
-            no_molecules (uint): ionic current in instrument
+            bin_width (float): width of each bin in Da.
             formula (str): a chemical formula, e.g. "C2H6O1" or "C2H6O".
-            precision (float): passed to IsoTotalProbGenerator. Between 0.0 and 1.0.
-            beta_bias (float, nonnegative): fiddling with this parameter does not change the result, but might make computations slightly faster (or likely, much, much slower is you screw it up...)
-            get_confs (boolean): should we report the counts of isotopologues?
+            target_total_prob (float): total probability of configurations to include before binning. Between 0.0 and 1.0.
+            bin_middle (float): offset of bin centres from zero.
             **kwargs: named arguments to the superclass.
         """
         iso = Iso(formula=formula, get_confs=False, **kwargs)
@@ -781,12 +778,13 @@ class IsoThresholdGenerator(IsoGenerator):
 class IsoLayeredGenerator(IsoGenerator):
     """Class alowing memory-efficient iteration over the isotopic distribution up till some joint probability of the reported peaks."""
     def __init__(self, formula="", get_confs=False, reorder_marginals = True, t_prob_hint = 0.99, **kwargs):
-        """Initialize IsoThresholdGenerator.
+        """Initialize IsoLayeredGenerator.
 
         Args:
             formula (str): a chemical formula, e.g. "C2H6O1" or "C2H6O".
-            absolute (boolean): should we report peaks with probabilities above an absolute probability threshold, or above a relative threshold amounting to a given proportion of the most probable peak?
             get_confs (boolean): should we report the counts of isotopologues?
+            reorder_marginals (boolean): should the marginal distributions be reordered for efficiency?
+            t_prob_hint (float): hint for the target total probability, used to size internal buffers.
             **kwargs: named arguments to the superclass.
         """
         super(IsoLayeredGenerator, self).__init__(formula=formula, get_confs=get_confs, **kwargs)
@@ -832,7 +830,7 @@ class IsoOrderedGenerator(IsoGenerator):
     def __del__(self):
         try:
             if self.cgen is not None:
-                self.ffi.deleteIsoLayeredGenerator(self.cgen)
+                self.ffi.deleteIsoOrderedGenerator(self.cgen)
                 self.cgen = None
         except AttributeError:
             pass

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpecPy/PeriodicTbl.py

@@ -20,7 +20,7 @@ symbol_to_masses = dict(symbol_to_masses)
 symbol_to_probs = dict(symbol_to_probs)
 
 # Several derivative convenience dicts...
-symbol_to_massprob = dict((key, [zip(symbol_to_masses[key], symbol_to_probs[key])]) for key in symbol_to_probs.keys())
+symbol_to_massprob = dict((key, list(zip(symbol_to_masses[key], symbol_to_probs[key]))) for key in symbol_to_probs.keys())
 
 def crossprod(l1, l2):
     return sum(x1*x2 for x1, x2 in zip(l1, l2))

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpecPy/approximations.py

@@ -24,15 +24,6 @@ def test_log_multinomial_confs_cnt():
 	assert abs(x - 4.189655) < 10**(-5)
 
 
-def multinomial_confs_cnt(n, i):
-	"""Return the approximate number of configurations of the multinomial distribution.
-
-	Args:
-		n (int): The number of trials.
-		i (int): The number of possible outcomes.
-	"""
-	return exp(log_subiso_cnt_simplex(n, i))
-
 
 def log_V_simplex(n, i):
 	"""Get the natural logarithm of the volume of a simplex {(x_1,..,x_{i-1}): \sum_{j=1}^i = n}.

{isospecpy-2.3.4 → isospecpy-2.3.5}/src/IsoSpecPy/isoFFI.py

@@ -184,7 +184,7 @@ sure you want to do that, edit the source and disable this check."""
         extension = [".so", ".dylib", ".dll"]
         try:
             if platform.system() == "Linux":
-                extension = [".so", "pyd"]
+                extension = [".so", ".pyd"]
             elif platform.system() == "Windows":
                 extension = [".dll", ".pyd"]
         except:
@@ -236,7 +236,7 @@ sure you want to do that, edit the source and disable this check."""
             except (IndexError, OSError) as e:
                 errmsg = (
                     "Load libIsoSpec++.so, tried: "
-                    + libpath
+                    + str(libpath)
                     + "\n"
                     + "Got error: "
                     + str(type(e))