IsoSpecPy 2.3.3__tar.gz → 2.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.3.3
+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.3 → 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.3"
+version = "2.3.5"
 license = "BSD-2-Clause"
 license-files = ["LICENCE"]
 authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]

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

@@ -59,16 +59,46 @@ double getLightestPeakMassIso(void* iso)
     return reinterpret_cast<Iso*>(iso)->getLightestPeakMass();
 }
 
+double getLightestPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getLightestPeakLProb();
+}
+
+void getLightestPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getLightestPeakSignature(space);
+}
+
 double getHeaviestPeakMassIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getHeaviestPeakMass();
 }
 
+double getHeaviestPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getHeaviestPeakLProb();
+}
+
+void getHeaviestPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getHeaviestPeakSignature(space);
+}
+
 double getMonoisotopicPeakMassIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakMass();
 }
 
+double getMonoisotopicPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakLProb();
+}
+
+void getMonoisotopicPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakSignature(space);
+}
+
 double getModeLProbIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getModeLProb();
@@ -99,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;
 }
 
@@ -265,6 +296,12 @@ void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_s
     return reinterpret_cast<void*>(ret);
 }
 
+void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob)
+{
+    FixedEnvelope* ret = new FixedEnvelope(masses, probs, confs, size, allDim, mass_sorted, prob_sorted, total_prob);
+    return reinterpret_cast<void*>(ret);
+}
+
 void deleteFixedEnvelope(void* t, bool release_everything)
 {
     FixedEnvelope* tt = reinterpret_cast<FixedEnvelope*>(t);
@@ -347,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;
@@ -447,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.3 → isospecpy-2.3.5}/src/IsoSpec++/cwrapper.h

@@ -40,8 +40,14 @@ ISOSPEC_C_API void * setupIso(int             dimNumber,
 ISOSPEC_C_API void * isoFromFasta(const char* fasta, bool use_nominal_masses, bool add_water);
 
 ISOSPEC_C_API double getLightestPeakMassIso(void* iso);
+ISOSPEC_C_API double getLightestPeakLProbIso(void* iso);
+ISOSPEC_C_API void getLightestPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getHeaviestPeakMassIso(void* iso);
+ISOSPEC_C_API double getHeaviestPeakLProbIso(void* iso);
+ISOSPEC_C_API void getHeaviestPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getMonoisotopicPeakMassIso(void* iso);
+ISOSPEC_C_API double getMonoisotopicPeakLProbIso(void* iso);
+ISOSPEC_C_API void getMonoisotopicPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getModeLProbIso(void* iso);
 ISOSPEC_C_API double getModeMassIso(void* iso);
 ISOSPEC_C_API double getTheoreticalAverageMassIso(void* iso);
@@ -132,6 +138,7 @@ ISOSPEC_C_API void array_mul(double* array, size_t N, double what);
 ISOSPEC_C_API void array_fma(double* array, size_t N, double mul, double add);
 
 ISOSPEC_C_API void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_sorted, bool prob_sorted, double total_prob);
+ISOSPEC_C_API void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob);
 ISOSPEC_C_API void* copyFixedEnvelope(void* other);
 ISOSPEC_C_API void deleteFixedEnvelope(void* tabulator, bool releaseEverything);
 

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

@@ -23,14 +23,16 @@ namespace IsoSpec
 {
 
 FixedEnvelope::FixedEnvelope(const FixedEnvelope& other) :
-_masses(array_copy<double>(other._masses, other._confs_no)),
-_probs(array_copy<double>(other._probs, other._confs_no)),
-_confs(array_copy_nptr<int>(other._confs, other._confs_no*other.allDim)),
+_masses(array_copy_malloc<double>(other._masses, other._confs_no)),
+_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) :
@@ -56,6 +103,19 @@ _probs(in_probs),
 _confs(nullptr),
 _confs_no(in_confs_no),
 allDim(0),
+allDimSizeofInt(0),
+sorted_by_mass(masses_sorted),
+sorted_by_prob(probs_sorted),
+total_prob(_total_prob)
+{}
+
+FixedEnvelope::FixedEnvelope(double* in_masses, double* in_probs, int* in_confs, size_t in_confs_no, int _allDim, bool masses_sorted, bool probs_sorted, double _total_prob) :
+_masses(in_masses),
+_probs(in_probs),
+_confs(in_confs),
+_confs_no(in_confs_no),
+allDim(_allDim),
+allDimSizeofInt(_allDim * sizeof(int)),
 sorted_by_mass(masses_sorted),
 sorted_by_prob(probs_sorted),
 total_prob(_total_prob)
@@ -233,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)
@@ -489,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)
@@ -854,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)
@@ -1142,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)
             {
@@ -1151,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.3 → 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,8 +66,11 @@ 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);
 
     virtual ~FixedEnvelope()
     {
@@ -238,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