IsoSpecPy 2.3.0.dev1__tar.gz → 2.3.0.dev3__tar.gz

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/Makefile

@@ -1,6 +1,6 @@
 OPTFLAGS=-O3 -march=native -mtune=native
 DEBUGFLAGS=-O0 -g -Werror -DISOSPEC_DEBUG -DDEBUG -D_GLIBCXX_DEBUG
-CXXFLAGS=-std=c++11 -Wall -pedantic -Wextra -Wshadow -Wcast-align -Wcast-qual -Wctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-include-dirs -Wno-old-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wno-sign-conversion -Wsign-promo -Wswitch-default -Wundef
+CXXFLAGS=-std=c++17 -Wall -pedantic -Wextra -Wshadow -Wcast-align -Wcast-qual -Wctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-include-dirs -Wno-old-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wno-sign-conversion -Wsign-promo -Wswitch-default -Wundef
 SRCFILES=cwrapper.cpp allocator.cpp  dirtyAllocator.cpp  isoSpec++.cpp  isoMath.cpp  marginalTrek++.cpp  operators.cpp element_tables.cpp misc.cpp mman.cpp fixedEnvelopes.cpp fasta.cpp
 
 all: unitylib

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/fasta.h

@@ -30,6 +30,11 @@ extern const double aa_elem_probabilities[19];
 
 extern const int aa_symbol_to_elem_counts[256*6];
 
+//! Count elemental composition of an unmodificed sequence of amino acids, resulting in CHNOSSe counts.
+/*!
+    WARNING!!! This function does not add the terminating H and OH groups, resulting in a residue backbone skeleton formula.
+    If you don't know what that means, you should probably be using parse_fasta_full function.
+*/
 inline void parse_fasta(const char* fasta, int atomCounts[6])
 {
     memset(atomCounts, 0, sizeof(decltype(atomCounts[0]))*6);
@@ -42,4 +47,21 @@ inline void parse_fasta(const char* fasta, int atomCounts[6])
     }
 }
 
+//! Turn an input FASTA aminoacid sequence into atom counts, in CHNOSSe order.
+/*!
+    Unlike parse_fasta, this function includes the H and OH groups at the N- and C- termini of the skeleton, resulting in a formula of a full (inert) molecule.
+*/
+inline void parse_fasta_full(const char* fasta, int atomCounts[6])
+{
+    parse_fasta(fasta, atomCounts);
+    // Add terminal water (H2O) for either precursor or fragment.
+    const int H_INDEX = 1; // Indexing: 0=C, 1=H, 2=N, 3=O, 4=S, 5=Se
+    const int O_INDEX = 3;
+
+    atomCounts[H_INDEX] += 2;
+    atomCounts[O_INDEX] += 1;
+}
+
+
+
 }  // namespace IsoSpec

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/isoMath.cpp

@@ -146,9 +146,8 @@ double InverseLowerIncompleteGamma2(int a, double x)
     return s;
 }
 
-std::random_device random_dev;
-std::mt19937 random_gen(random_dev());
-std::uniform_real_distribution<double> stdunif(0.0, 1.0);
+thread_local std::mt19937 random_gen(std::random_device{}());
+thread_local std::uniform_real_distribution<double> stdunif(0.0, 1.0);
 
 size_t rdvariate_binom(size_t tries, double succ_prob, std::mt19937& rgen)
 {

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/isoMath.h

@@ -70,8 +70,8 @@ inline double InverseChiSquareCDF2(int k, double x)
     return InverseLowerIncompleteGamma2(k, x*tgamma(static_cast<double>(k)/2.0)) * 2.0;
 }
 
-extern std::mt19937 random_gen;
-extern std::uniform_real_distribution<double> stdunif;
+extern thread_local std::mt19937 random_gen;
+extern thread_local std::uniform_real_distribution<double> stdunif;
 
 inline double rdvariate_beta_1_b(double b, std::mt19937& rgen = random_gen)
 {

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/isoSpec++.cpp

@@ -811,33 +811,32 @@ IsoLayeredGeneratorTemplate<MarginalType>::~IsoLayeredGeneratorTemplate()
 template class IsoLayeredGeneratorTemplate<LayeredMarginal>;
 //template class IsoLayeredGeneratorTemplate<PrecalculatedMarginal>;
 //template class IsoLayeredGeneratorTemplate<MarginalTrek>;
+template class IsoLayeredGeneratorTemplate<SingleAtomMarginal<true>>;
 
 /*
  * ------------------------------------------------------------------------------------------------------------------------
  */
 
-
-IsoOrderedGenerator::IsoOrderedGenerator(Iso&& iso, int _tabSize, int _hashSize) :
+template<typename MarginalType>
+IsoOrderedGeneratorTemplate<MarginalType>::IsoOrderedGeneratorTemplate(Iso&& iso, int _tabSize, int _hashSize) :
 IsoGenerator(std::move(iso), false), allocator(dimNumber, _tabSize)
 {
     partialLProbs = &currentLProb;
     partialMasses = &currentMass;
     partialProbs = &currentProb;
 
-    marginalResults = new MarginalTrek*[dimNumber];
+    marginalResults = new MarginalType*[dimNumber];
 
     for(int i = 0; i < dimNumber; i++)
-        marginalResults[i] = new MarginalTrek(std::move(*(marginals[i])), _tabSize, _hashSize);
+        marginalResults[i] = new MarginalType(std::move(*(marginals[i])), _tabSize, _hashSize);
 
     logProbs        = new const pod_vector<double>*[dimNumber];
     masses          = new const pod_vector<double>*[dimNumber];
-    marginalConfs   = new const pod_vector<int*>*[dimNumber];
 
     for(int i = 0; i < dimNumber; i++)
     {
         masses[i] = &marginalResults[i]->conf_masses();
         logProbs[i] = &marginalResults[i]->conf_lprobs();
-        marginalConfs[i] = &marginalResults[i]->confs();
     }
 
     topConf = allocator.newConf();
@@ -857,20 +856,19 @@ IsoGenerator(std::move(iso), false), allocator(dimNumber, _tabSize)
     pq.push(topConf);
 }
 
-
-IsoOrderedGenerator::~IsoOrderedGenerator()
+template<typename MarginalType>
+IsoOrderedGeneratorTemplate<MarginalType>::~IsoOrderedGeneratorTemplate()
 {
-    dealloc_table<MarginalTrek*>(marginalResults, dimNumber);
+    dealloc_table<MarginalType*>(marginalResults, dimNumber);
     delete[] logProbs;
     delete[] masses;
-    delete[] marginalConfs;
     partialLProbs = nullptr;
     partialMasses = nullptr;
     partialProbs = nullptr;
 }
 
-
-bool IsoOrderedGenerator::advanceToNextConfiguration()
+template<typename MarginalType>
+bool IsoOrderedGeneratorTemplate<MarginalType>::advanceToNextConfiguration()
 {
     if(pq.size() < 1)
         return false;
@@ -920,24 +918,30 @@ bool IsoOrderedGenerator::advanceToNextConfiguration()
     return true;
 }
 
+template class IsoOrderedGeneratorTemplate<MarginalTrek>;
+template class IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>;
+
 
 /*
  * ---------------------------------------------------------------------------------------------------
  */
 
 template<typename IsoType>
-IsoStochasticGeneratorTemplate<IsoType>::IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double _precision, double _beta_bias) :
+IsoStochasticGeneratorTemplate<IsoType>::IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double _precision, double _beta_bias, std::mt19937& _rng) :
 IsoGenerator(std::move(iso)),
 ILG(std::move(*this)),
 to_sample_left(no_molecules),
 precision(_precision),
 beta_bias(_beta_bias),
 confs_prob(0.0),
-chasing_prob(0.0)
+chasing_prob(0.0),
+rdvariate_gen(_rng)
 {}
 
 template class IsoStochasticGeneratorTemplate<IsoLayeredGeneratorTemplate<LayeredMarginal>>;
-template class IsoStochasticGeneratorTemplate<IsoOrderedGenerator>;
+template class IsoStochasticGeneratorTemplate<IsoLayeredGeneratorTemplate<SingleAtomMarginal<true>>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<MarginalTrek>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>>;
 //template class IsoStochasticGeneratorTemplate<IsoThresholdGenerator>;
 
 /*

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/isoSpec++.h

@@ -21,6 +21,7 @@
 #include <limits>
 #include <string>
 #include <vector>
+#include <algorithm>
 #include "platform.h"
 #include "dirtyAllocator.h"
 #include "summator.h"
@@ -233,24 +234,24 @@ class ISOSPEC_EXPORT_SYMBOL IsoGenerator : public Iso
     This algorithm take O(N*log(N)) to compute the N isotopologues because of using the Priority Queue data structure.
     Obtaining the N isotopologues can be achieved in O(N) if they are not required to be spit out in the descending order.
 */
-class ISOSPEC_EXPORT_SYMBOL IsoOrderedGenerator: public IsoGenerator
+template<typename MarginalType>
+class ISOSPEC_EXPORT_SYMBOL IsoOrderedGeneratorTemplate: public IsoGenerator
 {
  private:
-    MarginalTrek**              marginalResults;                    /*!< Table of pointers to marginal distributions of subisotopologues. */
+    MarginalType**              marginalResults;                    /*!< Table of pointers to marginal distributions of subisotopologues. */
     std::priority_queue<void*, pod_vector<void*>, ConfOrder> pq;   /*!< The priority queue used to generate isotopologues ordered by descending probability. */
     void*                       topConf;                            /*!< Most probable configuration. */
     DirtyAllocator              allocator;                          /*!< Structure used for alocating memory for isotopologues. */
     const pod_vector<double>**  logProbs;                           /*!< Obtained log-probabilities. */
     const pod_vector<double>**  masses;                             /*!< Obtained masses. */
-    const pod_vector<Conf>**    marginalConfs;                      /*!< Obtained counts of isotopes. */
     double                      currentLProb;                       /*!< The log-probability of the current isotopologue. */
     double                      currentMass;                        /*!< The mass of the current isotopologue. */
     double                      currentProb;                        /*!< The probability of the current isotopologue. */
     int                         ccount;
 
  public:
-    IsoOrderedGenerator(const IsoOrderedGenerator& other) = delete;
-    IsoOrderedGenerator& operator=(const IsoOrderedGenerator& other) = delete;
+    IsoOrderedGeneratorTemplate(const IsoOrderedGeneratorTemplate& other) = delete;
+    IsoOrderedGeneratorTemplate& operator=(const IsoOrderedGeneratorTemplate& other) = delete;
 
     bool advanceToNextConfiguration() override final;
 
@@ -261,29 +262,49 @@ class ISOSPEC_EXPORT_SYMBOL IsoOrderedGenerator: public IsoGenerator
     */
     inline void get_conf_signature(int* space) const override final
     {
-        int* c = getConf(topConf);
+        if constexpr (std::is_same<MarginalType, MarginalTrek>::value)
+        {
+            int* c = getConf(topConf);
 
-        if (ccount >= 0)
-            c[ccount]--;
+            if (ccount >= 0)
+                c[ccount]--;
 
-        for(int ii = 0; ii < dimNumber; ii++)
-        {
-            memcpy(space, marginalResults[ii]->confs()[c[ii]], isotopeNumbers[ii]*sizeof(int));
-            space += isotopeNumbers[ii];
-        }
+            for(int ii = 0; ii < dimNumber; ii++)
+            {
+                memcpy(space, marginalResults[ii]->confs()[c[ii]], isotopeNumbers[ii]*sizeof(int));
+                space += isotopeNumbers[ii];
+            }
 
-        if (ccount >= 0)
-            c[ccount]++;
+            if (ccount >= 0)
+                c[ccount]++;
+        }
+        else
+            throw std::runtime_error("IsoOrderedGeneratorTemplate::get_conf_signature() called on a non-MarginalTrek generator. This is not supported yet.");
     };
 
     //! The move-contstructor.
-    IsoOrderedGenerator(Iso&& iso, int _tabSize  = 1000, int _hashSize = 1000);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
+    IsoOrderedGeneratorTemplate(Iso&& iso, int _tabSize  = 1000, int _hashSize = 1000);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
 
     //! Destructor.
-    virtual ~IsoOrderedGenerator();
-};
+    virtual ~IsoOrderedGeneratorTemplate();
+
+    inline void get_conf_by_indexes(int* space)
+    {
+        if constexpr (std::is_same<MarginalType, SingleAtomMarginal<false>>::value)
+        {
+            if(dimNumber == 0)
+                return;
+
+            int* c = getConf(topConf);
+            space[0] = std::max(c[0]-1, 0);
 
+            for(int ii = 1; ii < dimNumber; ii++)
+                space[ii] = c[ii];
+        }
+    }
+};
 
+using IsoOrderedGenerator = IsoOrderedGeneratorTemplate<MarginalTrek>;
 
 
 //! The generator of isotopologues above a given threshold value.
@@ -533,6 +554,29 @@ class ISOSPEC_EXPORT_SYMBOL IsoLayeredGeneratorTemplate : public IsoGenerator
 
     bool nextLayer(double offset);
 
+    void get_conf_by_indexes(int* space) const
+    {
+        if constexpr (std::is_same<MarginalType, SingleAtomMarginal<true>>::value)
+        {
+            counter[0] = lProbs_ptr - lProbs_ptr_start;
+            if(marginalOrder != nullptr)
+            {
+                for(int ii = 0; ii < dimNumber; ii++)
+                {
+                    int jj = marginalOrder[ii];
+                    space[ii] = marginalResultsUnsorted[ii]->get_original_position(counter[jj]);
+                }
+            }
+            else
+            {
+                for(int ii = 0; ii < dimNumber; ii++)
+                    space[ii] = marginalResultsUnsorted[ii]->get_original_position(counter[ii]);
+            }
+        }
+        else
+            throw std::runtime_error("IsoLayeredGeneratorTemplate::get_conf_by_indexes() called on a non-SingleAtomMarginal generator. This is not supported yet.");
+    }
+
  private:
     bool carry();
 };
@@ -548,9 +592,10 @@ class IsoStochasticGeneratorTemplate : public IsoGenerator
     double confs_prob;
     double chasing_prob;
     size_t current_count;
+    std::mt19937& rdvariate_gen;  /*!< The random number generator used to generate random numbers. */
 
  public:
-    IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double precision = 0.9999, double beta_bias = 5.0);
+    IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double precision = 0.9999, double beta_bias = 5.0, std::mt19937& rdvariate_gen = random_gen);
 
     ISOSPEC_FORCE_INLINE size_t count() const { return current_count; }
 
@@ -636,6 +681,11 @@ class IsoStochasticGeneratorTemplate : public IsoGenerator
             }
         };
     }
+
+    ISOSPEC_FORCE_INLINE void get_indexes(int* space)
+    {
+        ILG.get_conf_by_indexes(space);
+    }
 };
 
 using IsoStochasticGenerator = IsoStochasticGeneratorTemplate<IsoLayeredGenerator>;

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/marginalTrek++.cpp

@@ -695,4 +695,46 @@ double LayeredMarginal::get_max_mass() const
     return ret;
 }
 
+/* ===============================================================   */
+
+template<bool add_guards>
+SingleAtomMarginal<add_guards>::SingleAtomMarginal(Marginal&& m, int, int)
+: Marginal(std::move(m)), current_threshold(1.0), extended_to_idx(0)
+{
+    original_indexes.resize(isotopeNo);
+    for(size_t ii = 0; ii < isotopeNo; ++ii)
+        original_indexes[ii] = ii;
+
+    std::sort(original_indexes.begin(), original_indexes.end(), [&](int a, int b) {
+        return atom_lProbs[a] > atom_lProbs[b];
+    });
+
+
+    masses.reserve(isotopeNo);
+    probs.reserve(isotopeNo);
+
+    if constexpr (add_guards)
+    {
+        lProbs.reserve(isotopeNo+2);
+        lProbs.push_back(std::numeric_limits<double>::infinity());
+    }
+    else
+        lProbs.reserve(isotopeNo);
+
+    for(size_t idx : original_indexes)
+    {
+        lProbs.push_back(atom_lProbs[idx]);
+        probs.push_back(exp(lProbs.back()));
+        masses.push_back(atom_masses[idx]);
+    }
+
+    if constexpr (add_guards)
+   {
+        lProbs.push_back(-std::numeric_limits<double>::infinity());
+        guarded_lProbs = lProbs.data()+1;
+    }
+    else
+        guarded_lProbs = lProbs.data();
+}
+
 }  // namespace IsoSpec

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/marginalTrek++.h

@@ -21,6 +21,7 @@
 #include <vector>
 #include <functional>
 #include <utility>
+#include <memory>
 #include "conf.h"
 #include "allocator.h"
 #include "operators.h"
@@ -409,8 +410,164 @@ class LayeredMarginal : public Marginal
         \return The log-probability of a/the most probable subisotopologue.
     */
     inline double getModeLProb() const { return mode_lprob; }
+    const pod_vector<double>& conf_lprobs() const { return lProbs; }
+    const pod_vector<double>& conf_masses() const { return masses; }
+
 };
 
 
 
+
+
+
+
+
+template <bool add_guards>
+class SingleAtomMarginal : public Marginal
+{
+ private:
+    double current_threshold;
+    pod_vector<double> lProbs;
+    pod_vector<double> probs;
+    pod_vector<double> masses;
+    pod_vector<size_t> original_indexes;
+    double* guarded_lProbs;
+    int extended_to_idx;
+
+ public:
+    //! Move constructor: specializes the Marginal class.
+    /*!
+    */
+    SingleAtomMarginal(Marginal&& m, int tabSize = 1000, int hashSize = 1000);  // NOLINT(runtime/explicit) - constructor deliberately left usable as a conversion
+
+    SingleAtomMarginal(const SingleAtomMarginal& other) = delete;
+    SingleAtomMarginal& operator=(const SingleAtomMarginal& other) = delete;
+
+    //! Extend the set of computed subisotopologues to those above the new threshold.
+    /*!
+        \param new_threshold The new log-probability limiting the subisotopologues from below.
+        \return Returns false, if there are no fringe-subisotopologues (subisotopologues that were neighbours of the previously calculated subisotopologues, with log-probability below the previous threshold).
+    */
+    bool extend(double new_threshold, [[maybe_unused]] bool do_sort = true) {
+        static_assert(add_guards, "SingleAtomMarginal::extend: add_guards must be true");
+        current_threshold = new_threshold;
+        bool extended = false;
+        while(guarded_lProbs[extended_to_idx] >= current_threshold)
+        {
+            extended_to_idx++;
+            extended = true;
+        }
+        return extended || (guarded_lProbs[extended_to_idx] != -std::numeric_limits<double>::infinity());
+    };
+
+    //! get the log-probability of the idx-th subisotopologue, see details in @ref PrecalculatedMarginal::get_lProb.
+    inline double get_lProb(int idx) const { return guarded_lProbs[idx]; }  // access to idx == -1 is valid and gives a guardian of +inf
+
+    //! get the probability of the idx-th subisotopologue, see details in @ref PrecalculatedMarginal::get_eProb.
+    inline double get_prob(int idx) const { return probs[idx]; }
+
+    //! get the mass of the idx-th subisotopologue, see details in @ref PrecalculatedMarginal::get_mass.
+    inline double get_mass(int idx) const { return masses[idx]; }
+
+    //! get the pointer to lProbs array. Accessing index -1 is legal and returns a guardian of -inf. Warning: The pointer gets invalidated on calls to extend()
+    inline const double* get_lProbs_ptr() const { return lProbs.data()+1; }
+
+    //! get the counts of isotopes that define the subisotopologue, see details in @ref PrecalculatedMarginal::get_conf.
+    inline const Conf& get_conf([[maybe_unused]] int idx) const { throw std::logic_error("SingleAtomMarginal.get_conf: not implemented"); /*return configurations[idx];*/ }
+
+    //! Get the number of precomputed subisotopologues, see details in @ref PrecalculatedMarginal::get_no_confs.
+    inline unsigned int get_no_confs() const {
+        if constexpr(add_guards)
+            return extended_to_idx;
+        else
+            return static_cast<unsigned int>(original_indexes.size());}
+
+    //! Get the minimal mass in current layer
+    inline double get_min_mass() const { throw std::logic_error("SingleAtomMarginal.get_min_mass: not implemented"); };
+
+    //! Get the maximal mass in current layer
+    double get_max_mass() const { throw std::logic_error("SingleAtomMarginal.get_max_mass: not implemented"); };
+
+    //! Get the log-probability of the mode subisotopologue.
+    /*!
+        \return The log-probability of a/the most probable subisotopologue.
+    */
+    inline double getModeLProb() const { return mode_lprob; }
+
+    inline bool probeConfigurationIdx(int idx)
+    {
+        return idx < static_cast<int>(original_indexes.size());
+    }
+    const pod_vector<double>& conf_lprobs() const { return lProbs; }
+    const pod_vector<double>& conf_masses() const { return masses; }
+
+    int get_original_position(int idx) const
+    {
+        #ifdef ISOSPEC_DEBUG
+        if (idx < 0 || static_cast<size_t>(idx) >= original_indexes.size())
+            throw std::out_of_range("Index out of range in SingleAtomMarginal::et_original_position");
+        #endif
+        return original_indexes[idx];
+    }
+};
+
+
+
+
+template <typename T>
+class LoggingMarginal : public Marginal
+{
+ private:
+    std::unique_ptr<T> real_marginal;
+ public:
+
+
+    LoggingMarginal(T&& m) : Marginal(m), real_marginal(std::make_unique(std::move(m))) {}
+    LoggingMarginal(T&& m, int tabSize, int hashSize)
+        : Marginal(m), real_marginal(std::make_unique<T>(std::move(m), tabSize, hashSize)) {}
+
+    LoggingMarginal(const LoggingMarginal& other) = delete;
+    LoggingMarginal& operator=(const LoggingMarginal& other) = delete;
+
+    inline double getModeLProb() const { auto ret = real_marginal->getModeLProb(); std::cout << "LoggingMarginal::getModeLProb: " << ret << std::endl; return ret; }
+    inline double get_lProb(int idx) const { auto ret = real_marginal->get_lProb(idx); std::cout << "LoggingMarginal::get_lProb: " << idx << " " << ret << std::endl; return ret; }
+    inline double get_prob(int idx) const { auto ret = real_marginal->get_prob(idx); std::cout << "LoggingMarginal::get_prob: " << idx << " " << ret << std::endl; return ret; }
+    inline double get_mass(int idx) const { auto ret = real_marginal->get_mass(idx); std::cout << "LoggingMarginal::get_mass: " << idx << " " << ret << std::endl; return ret; }
+    inline const double* get_lProbs_ptr() const { auto ret = real_marginal->get_lProbs_ptr(); std::cout << "LoggingMarginal::get_lProbs_ptr: "; printArray<double>(ret, real_marginal->get_no_confs()); return ret; }
+    inline const Conf& get_conf(int idx) const { auto ret = real_marginal->get_conf(idx); std::cout << "LoggingMarginal::get_conf: " << idx << std::endl; return ret; }
+    inline unsigned int get_no_confs() const { auto ret = real_marginal->get_no_confs(); std::cout << "LoggingMarginal::get_no_confs: " << ret << std::endl; return ret; }
+    inline bool probeConfigurationIdx(int idx) { auto ret = real_marginal->probeConfigurationIdx(idx); std::cout << "LoggingMarginal::probeConfigurationIdx: " << idx << " " << ret << std::endl; return ret; }
+    inline double get_min_mass() const { auto ret = real_marginal->get_min_mass(); std::cout << "LoggingMarginal::get_min_mass: " << ret << std::endl; return ret; }
+    inline double get_max_mass() const { auto ret = real_marginal->get_max_mass(); std::cout << "LoggingMarginal::get_max_mass: " << ret << std::endl; return ret; }
+    inline double getModeMass() const { auto ret = real_marginal->getModeMass(); std::cout << "LoggingMarginal::getModeMass: " << ret << std::endl; return ret; }
+    inline double getLightestConfMass() const { auto ret = real_marginal->getLightestConfMass(); std::cout << "LoggingMarginal::getLightestConfMass: " << ret << std::endl; return ret; }
+    inline double getHeaviestConfMass() const { auto ret = real_marginal->getHeaviestConfMass(); std::cout << "LoggingMarginal::getHeaviestConfMass: " << ret << std::endl; return ret; }
+    inline double getMonoisotopicConfMass() const { auto ret = real_marginal->getMonoisotopicConfMass(); std::cout << "LoggingMarginal::getMonoisotopicConfMass: " << ret << std::endl; return ret; }
+    inline double getAtomAverageMass() const { auto ret = real_marginal->getAtomAverageMass(); std::cout << "LoggingMarginal::getAtomAverageMass: " << ret << std::endl; return ret; }
+    inline double variance() const { auto ret = real_marginal->variance(); std::cout << "LoggingMarginal::variance: " << ret << std::endl; return ret; }
+    inline double getTheoreticalAverageMass() const { auto ret = real_marginal->getTheoreticalAverageMass(); std::cout << "LoggingMarginal::getTheoreticalAverageMass: " << ret << std::endl; return ret; }
+    inline double getLogSizeEstimate(double logEllipsoidRadius) const
+    {
+        auto ret = real_marginal->getLogSizeEstimate(logEllipsoidRadius);
+        std::cout << "LoggingMarginal::getLogSizeEstimate: " << logEllipsoidRadius << " " << ret << std::endl;
+        return ret;
+    }
+    inline void ensureModeConf() { real_marginal->ensureModeConf(); std::cout << "LoggingMarginal::ensureModeConf" << std::endl; }
+    inline const pod_vector<double>& conf_lprobs() const { return real_marginal->conf_lprobs(); }
+    inline const pod_vector<double>& conf_masses() const { return real_marginal->conf_masses(); }
+    inline int get_original_position(int idx) const { return real_marginal->get_original_position(idx); }
+    inline int get_isotopeNo() const { return real_marginal->get_isotopeNo(); }
+    inline const double* get_lProbs() const { return real_marginal->get_lProbs(); }
+    inline const double* get_masses() const { return real_marginal->get_masses(); }
+    inline const double* get_atom_lProbs() const { return real_marginal->get_lProbs(); }
+    inline const double* get_atom_masses() const { return real_marginal->get_masses(); }
+    inline bool extend(double new_threshold, bool do_sort = true)
+    {
+        auto ret = real_marginal->extend(new_threshold, do_sort);
+        std::cout << "LoggingMarginal::extend: " << new_threshold << " " << ret << std::endl;
+        return ret;
+    }
+};
+
+
 }  // namespace IsoSpec

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/misc.h

@@ -96,6 +96,11 @@ template<typename T> void printVector(const std::vector<T>& vec)
     printArray<T>(vec.data(), vec.size());
 }
 
+template<typename T> void printVector(const pod_vector<T>& vec)
+{
+    printArray<T>(vec.data(), vec.size());
+}
+
 template<typename T> void printOffsets(const T** array, int size, const T* offset, const char* prefix = "")
 {
     if (strlen(prefix) > 0)

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpec++/mman.cpp

@@ -15,6 +15,7 @@
 #include "platform.h"
 #if ISOSPEC_GOT_MMAN && !ISOSPEC_GOT_SYSTEM_MMAN
 
+#define NOMINMAX
 #include <windows.h>
 #include <errno.h>
 #include <io.h>

isospecpy-2.3.0.dev3/IsoSpec++/test.cpp

@@ -0,0 +1,6 @@
+#include "isoSpec++.h"
+
+int main() {
+    auto orderedGenerator = IsoSpec::IsoOrderedGenerator("H2O1");
+    orderedGenerator.advanceToNextConfiguration();
+}

{isospecpy-2.3.0.dev1 → isospecpy-2.3.0.dev3}/IsoSpecPy.egg-info/PKG-INFO

@@ -1,4 +1,4 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: IsoSpecPy
 Version: 2.2.3
 Summary: Python interface to IsoSpec++ isotopic envelope calculator library
@@ -31,5 +31,15 @@ Requires-Dist: cffi
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: numpy; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 Python interface to IsoSpec++ isotopic envelope calculator library