IsoSpecPy 2.3.0.dev11__cp313-cp313-win_arm64.whl

IsoSpecPy/IsoSpec++/dirtyAllocator.h

@@ -0,0 +1,58 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <cstring>
+#include "pod_vector.h"
+
+namespace IsoSpec
+{
+
+class DirtyAllocator
+{
+ private:
+    void*   currentTab;
+    void*   currentConf;
+    void*   endOfTablePtr;
+    const int       tabSize;
+    int     cellSize;
+    pod_vector<void*>  prevTabs;
+
+ public:
+    explicit DirtyAllocator(const int dim, const int tabSize = 10000);
+    ~DirtyAllocator();
+
+    DirtyAllocator(const DirtyAllocator& other) = delete;
+    DirtyAllocator& operator=(const DirtyAllocator& other) = delete;
+
+    void shiftTables();
+
+    inline void* newConf()
+    {
+        if (currentConf >= endOfTablePtr)
+        {
+            shiftTables();
+        }
+
+        void*  ret = currentConf;
+        currentConf = reinterpret_cast<char*>(currentConf) + cellSize;
+
+        return ret;
+    }
+};
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/element_tables.h

@@ -0,0 +1,50 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <stddef.h>
+
+#include "platform.h"
+
+namespace IsoSpec
+{
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES 292
+ISOSPEC_C_API extern const size_t isospec_number_of_isotopic_entries;
+
+ISOSPEC_C_API extern const int elem_table_ID[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const int elem_table_atomicNo[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_probability[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_mass[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_massNo[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const int elem_table_extraNeutrons[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const char* elem_table_element[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const char* elem_table_symbol[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const bool elem_table_Radioactive[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_log_probability[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+
+
+#ifdef __cplusplus
+}
+#endif
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/fasta.h

@@ -0,0 +1,67 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+
+#pragma once
+
+namespace IsoSpec{
+
+// We will work with C H N O S Se tuples */
+extern const int aa_isotope_numbers[6];
+
+extern const double aa_elem_masses[19];
+
+extern const double aa_elem_nominal_masses[19];
+
+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);
+
+    for(size_t idx = 0; fasta[idx] != '\0'; ++idx)
+    {
+        const int* counts = &aa_symbol_to_elem_counts[fasta[idx]*6];
+        for(int ii = 0; ii < 6; ++ii)
+            atomCounts[ii] += counts[ii];
+    }
+}
+
+//! 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/IsoSpec++/fixedEnvelopes.h

@@ -0,0 +1,244 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <cstdlib>
+#include <algorithm>
+#include <vector>
+#include <utility>
+
+#include "isoSpec++.h"
+
+#ifdef DEBUG
+#define ISOSPEC_INIT_TABLE_SIZE 16
+#else
+#define ISOSPEC_INIT_TABLE_SIZE 1024
+#endif
+
+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;
+    double* _probs;
+    int*    _confs;
+    size_t  _confs_no;
+    int     allDim;
+    bool sorted_by_mass;
+    bool sorted_by_prob;
+    double total_prob;
+    size_t current_size;
+    double* tmasses;
+    double* tprobs;
+    int*    tconfs;
+    int allDimSizeofInt;
+
+ public:
+    ISOSPEC_FORCE_INLINE FixedEnvelope() : _masses(nullptr),
+        _probs(nullptr),
+        _confs(nullptr),
+        _confs_no(0),
+        allDim(0),
+        sorted_by_mass(false),
+        sorted_by_prob(false),
+        total_prob(0.0),
+        current_size(0),
+        allDimSizeofInt(0)
+        // Deliberately not initializing tmasses, tprobs, tconfs
+        {};
+
+    FixedEnvelope(const FixedEnvelope& other);
+    FixedEnvelope(FixedEnvelope&& other);
+
+    FixedEnvelope(double* masses, double* probs, size_t confs_no, bool masses_sorted = false, bool probs_sorted = false, double _total_prob = NAN);
+
+    virtual ~FixedEnvelope()
+    {
+        free(_masses);
+        free(_probs);
+        free(_confs);
+    };
+
+    FixedEnvelope operator+(const FixedEnvelope& other) const;
+    FixedEnvelope operator*(const FixedEnvelope& other) const;
+
+    inline size_t    confs_no()  const { return _confs_no; }
+    inline int       getAllDim() const { return allDim; }
+
+    inline const double*   masses() const { return _masses; }
+    inline const double*   probs()  const { return _probs; }
+    inline const int*      confs()  const { return _confs; }
+
+    inline double*   release_masses()     { double* ret = _masses; _masses = nullptr; return ret; }
+    inline double*   release_probs()      { double* ret = _probs;  _probs  = nullptr; return ret; }
+    inline int*      release_confs()      { int*    ret = _confs;  _confs  = nullptr; return ret; }
+    inline void      release_everything() { _confs = nullptr; _probs = _masses = nullptr; }
+
+
+    inline double     mass(size_t i)  const { return _masses[i]; }
+    inline double     prob(size_t i)  const { return _probs[i];  }
+    inline const int* conf(size_t i)  const { return _confs + i*allDim; }
+
+    void sort_by_mass();
+    void sort_by_prob();
+
+    double get_total_prob();
+    void scale(double factor);
+    void normalize();
+    void shift_mass(double shift);
+    void resample(size_t ionic_current, double beta_bias = 1.0);
+
+    double empiric_average_mass();
+    double empiric_variance();
+    double empiric_stddev() { return sqrt(empiric_variance()); }
+
+    double WassersteinDistance(FixedEnvelope& other);
+    double OrientedWassersteinDistance(FixedEnvelope& other);
+    double AbyssalWassersteinDistance(FixedEnvelope& other, double abyss_depth, double other_scale = 1.0);
+    std::tuple<double, double, double> WassersteinMatch(FixedEnvelope& other, double flow_distance, double other_scale = 1.0);
+
+
+    static FixedEnvelope LinearCombination(const std::vector<const FixedEnvelope*>& spectra, const std::vector<double>& intensities);
+    static FixedEnvelope LinearCombination(const FixedEnvelope* const * spectra, const double* intensities, size_t size);
+
+
+    FixedEnvelope bin(double bin_width = 1.0, double middle = 0.0);
+
+ private:
+    void sort_by(double* order);
+
+
+ protected:
+    template<typename T, bool tgetConfs> ISOSPEC_FORCE_INLINE void store_conf(const T& generator)
+    {
+        *tmasses = generator.mass(); tmasses++;
+        *tprobs  = generator.prob(); tprobs++;
+        constexpr_if(tgetConfs) { generator.get_conf_signature(tconfs); tconfs += allDim; }
+    }
+
+    ISOSPEC_FORCE_INLINE void store_conf(double _mass, double _prob)
+    {
+        if(_confs_no == current_size)
+            reallocate_memory<false>(current_size*2);
+
+        *tprobs = _prob;
+        *tmasses = _mass;
+        tprobs++;
+        tmasses++;
+
+        _confs_no++;
+    }
+
+    template<bool tgetConfs> ISOSPEC_FORCE_INLINE void swap(size_t idx1, size_t idx2, ISOSPEC_MAYBE_UNUSED int* conf_swapspace)
+    {
+        std::swap<double>(this->_probs[idx1],  this->_probs[idx2]);
+        std::swap<double>(this->_masses[idx1], this->_masses[idx2]);
+        constexpr_if(tgetConfs)
+        {
+            int* c1 = this->_confs + (idx1*this->allDim);
+            int* c2 = this->_confs + (idx2*this->allDim);
+            memcpy(conf_swapspace, c1, this->allDimSizeofInt);
+            memcpy(c1, c2, this->allDimSizeofInt);
+            memcpy(c2, conf_swapspace, this->allDimSizeofInt);
+        }
+    }
+
+    template<bool tgetConfs> void reallocate_memory(size_t new_size);
+    void slow_reallocate_memory(size_t new_size);
+
+ public:
+    template<bool tgetConfs> void threshold_init(Iso&& iso, double threshold, bool absolute);
+
+    template<bool tgetConfs, typename GenType = IsoLayeredGenerator> void addConfILG(const GenType& generator)
+    {
+        if(this->_confs_no == this->current_size)
+            this->template reallocate_memory<tgetConfs>(this->current_size*2);
+
+        this->template store_conf<GenType, tgetConfs>(generator);
+        this->_confs_no++;
+    }
+
+    template<bool tgetConfs> void total_prob_init(Iso&& iso, double target_prob, bool trim);
+
+    static FixedEnvelope FromThreshold(Iso&& iso, double threshold, bool absolute, bool tgetConfs = false)
+    {
+        FixedEnvelope ret;
+
+        if(tgetConfs)
+            ret.threshold_init<true>(std::move(iso), threshold, absolute);
+        else
+            ret.threshold_init<false>(std::move(iso), threshold, absolute);
+        return ret;
+    }
+
+    inline static FixedEnvelope FromThreshold(const Iso& iso, double _threshold, bool _absolute, bool tgetConfs = false)
+    {
+        return FromThreshold(Iso(iso, false), _threshold, _absolute, tgetConfs);
+    }
+
+    static FixedEnvelope FromTotalProb(Iso&& iso, double target_total_prob, bool optimize, bool tgetConfs = false)
+    {
+        FixedEnvelope ret;
+
+        if(tgetConfs)
+            ret.total_prob_init<true>(std::move(iso), target_total_prob, optimize);
+        else
+            ret.total_prob_init<false>(std::move(iso), target_total_prob, optimize);
+
+        return ret;
+    }
+
+    inline static FixedEnvelope FromTotalProb(const Iso& iso, double _target_total_prob, bool _optimize, bool tgetConfs = false)
+    {
+        return FromTotalProb(Iso(iso, false), _target_total_prob, _optimize, tgetConfs);
+    }
+
+    template<bool tgetConfs> void stochastic_init(Iso&& iso, size_t _no_molecules, double _precision, double _beta_bias);
+
+    inline static FixedEnvelope FromStochastic(Iso&& iso, size_t _no_molecules, double _precision = 0.9999, double _beta_bias = 5.0, bool tgetConfs = false)
+    {
+        FixedEnvelope ret;
+
+        if(tgetConfs)
+            ret.stochastic_init<true>(std::move(iso), _no_molecules, _precision, _beta_bias);
+        else
+            ret.stochastic_init<false>(std::move(iso), _no_molecules, _precision, _beta_bias);
+
+        return ret;
+    }
+
+    static FixedEnvelope FromStochastic(const Iso& iso, size_t _no_molecules, double _precision = 0.9999, double _beta_bias = 5.0, bool tgetConfs = false)
+    {
+        return FromStochastic(Iso(iso, false), _no_molecules, _precision, _beta_bias, tgetConfs);
+    }
+
+    static FixedEnvelope Binned(Iso&& iso, double target_total_prob, double bin_width, double bin_middle = 0.0);
+    static FixedEnvelope Binned(const Iso& iso, double target_total_prob, double bin_width, double bin_middle = 0.0)
+    {
+        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/IsoSpec++/isoMath.h

@@ -0,0 +1,87 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <cmath>
+#include <random>
+
+#if !defined(ISOSPEC_G_FACT_TABLE_SIZE)
+// 10M should be enough for anyone, right?
+// Actually, yes. If anyone tries to input a molecule that has more than 10M atoms,
+// he deserves to get an exception thrown in his face. OpenMS guys don't want to alloc
+// a table of 10M to memoize the necessary values though, use something smaller for them.
+  #if ISOSPEC_BUILDING_OPENMS
+    #define ISOSPEC_G_FACT_TABLE_SIZE 1024
+  #else
+    #define ISOSPEC_G_FACT_TABLE_SIZE 1024*1024*10
+  #endif
+#endif
+
+namespace IsoSpec
+{
+
+extern double* g_lfact_table;
+
+static inline double minuslogFactorial(int n)
+{
+    if (n < 2)
+        return 0.0;
+    #if ISOSPEC_BUILDING_OPENMS
+    if (n >= ISOSPEC_G_FACT_TABLE_SIZE)
+        return -lgamma(n+1);
+    #endif
+    if (g_lfact_table[n] == 0.0)
+        g_lfact_table[n] = -lgamma(n+1);
+
+    return g_lfact_table[n];
+}
+
+const double pi = 3.14159265358979323846264338328;
+const double logpi = 1.144729885849400174143427351353058711647294812915311571513623071472137769884826079783623270275489708;
+
+double NormalCDFInverse(double p);
+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;
+}
+
+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)
+{
+    return 1.0 - pow(stdunif(rgen), 1.0/b);
+}
+
+
+size_t rdvariate_binom(size_t tries, double succ_prob, std::mt19937& rgen = random_gen);
+
+
+
+
+}  // namespace IsoSpec