IsoSpecPy 2.3.0.dev11__cp313-cp313-win_arm64.whl

IsoSpecPy/Advanced.py

@@ -0,0 +1,32 @@
+'''This file contains a set of functions useful for the analysis of properties of
+isotopic envelopes. These are unlikely to be of any interest to end-users, only
+for developers interested in testing some properties of the isotopic envelopes.
+These are implemented mostly in Python, and so, not as fast as the rest of the
+package.'''
+
+def _int_neighbours(subisotopologue_conf):
+    conf = list(subisotopologue_conf)
+    for i in range(len(conf)):
+        for j in range(len(conf)):
+            if i != j and conf[i] > 0:
+                conf[i] -= 1
+                conf[j] += 1
+                yield tuple(conf)
+                conf[i] += 1
+                conf[j] -= 1
+
+
+def neighbours(conf):
+    for i in range(len(conf)):
+        for si_neigh in _int_neighbours(conf[i]):
+            yield tuple(conf[j] if j != i else si_neigh for j in range(len(conf)))
+
+
+
+
+def conf_mass(iso, conf):
+    return sum(sum(mass * cnt for mass, cnt in zip(masses, cnts)) for masses, cnts in zip(iso.isotopeMasses, conf))
+
+
+from IsoSpecPy import Iso
+Iso.conf_mass = conf_mass

IsoSpecPy/Distributions.py

@@ -0,0 +1,94 @@
+import math
+
+from .IsoSpecPy import IsoDistribution
+
+
+
+
+def simple_inverse(fun, prec = 0.01):
+    
+    def inverse(x):
+        start = -1.0
+        while fun(start) > x:
+            start *= 2.0
+        end = 1.0
+        while fun(end) < x:
+            end *= 2.0
+
+        while (end - start) > prec:
+            print(start, end)
+            mid = (end + start) * 0.5
+            if fun(mid) < x:
+                start = mid
+            else:
+                end = mid
+
+        return (end + start) * 0.5
+
+    return inverse
+            
+
+
+class Distribution(IsoDistribution):
+    def __init__(self, cdf, bin_width = 0.01, precision = 0.99, inverse_cdf = None):
+        if inverse_cdf is None:
+            inverse_cdf = simple_inverse(cdf, prec = bin_width*0.125)
+
+        prec_missing = 0.5 * (1.0 - precision)
+
+        start = inverse_cdf(prec_missing)
+        end = inverse_cdf(1.0 - prec_missing)
+
+        half_bin_width = 0.5*bin_width
+
+        bw_inverse = 1.0 / bin_width
+
+        def bw_round(x):
+            return math.floor(x*bw_inverse + 0.5) / bw_inverse
+
+        start = bw_round(start)
+        end = bw_round(end)
+
+        last_bin_start = start - half_bin_width
+        last_cdf = cdf(last_bin_start)
+        
+        probs = [0.0]
+        masses = [last_bin_start - half_bin_width]
+
+        while last_bin_start < end:
+            next_bin_start = last_bin_start + bin_width
+            next_cdf = cdf(next_bin_start)
+
+            masses.append(last_bin_start + half_bin_width)
+            probs.append(next_cdf - last_cdf)
+
+            last_cdf = next_cdf
+            last_bin_start = next_bin_start
+
+        sprobs = 1.0/sum(probs)
+        probs = [p*sprobs for p in probs]
+
+        probs.append(0.0)
+        masses.append(last_bin_start + half_bin_width)
+
+        super(Distribution, self).__init__(masses = masses, probs = probs)
+
+        self.mass_sorted = True
+
+
+
+class Gaussian(Distribution):
+    def __init__(self, stdev, bin_width = 0.01, precision = 0.99):
+        varfactor = 1.0/(stdev * 1.4142135623730951)
+        cdf = lambda x: 0.5*(1.0+math.erf(x*varfactor))
+        inv_cdf = None
+        try:
+            # If scipy is available, use its ppf
+            from scipy.stats import norm
+            inv_cdf = lambda x: norm.ppf(x, loc = 0.0, scale = stdev)
+        except ImportError:
+            pass # oh well, no scipy, we'll just use binsearch-based inversion
+
+        super(Gaussian, self).__init__(cdf = cdf, bin_width = bin_width, precision = precision, inverse_cdf = inv_cdf)
+
+

IsoSpecPy/Formulas.py

@@ -0,0 +1,71 @@
+from .IsoSpecPy import Iso
+from collections import Counter
+
+
+
+loratadine = "C22H23N2O2Cl1"
+desloratadine = "C19H19N2Cl1"
+titin = "C169719H270466N45688O52238S911"
+bovine_insulin = "C254H377N65O75S6"
+ubiquitin = "C378H629N105O118S1"
+substance_p = "C63H98N18O13S1"
+protein_p16 = "C681H1100N216O208S5"
+cholesterol = "C27H46O1"
+caffeine = "C8H10N4O2"
+water = "H2O1"
+glucose = "C6H12O6"
+sucrose = "C12H22O11"
+horse_myoglobin = "C769H1212N210O218S2"
+oxygen = "O2"
+
+
+
+
+
+averagine_unit = Counter({
+'C' : 4.9384,
+'H' : 7.7583,
+'N' : 1.3577,
+'O' : 1.4773,
+'S' : 0.0417})
+
+averagine_mass = 111.1254
+
+def fillHs(d, target_avg_mass):
+    while True:
+        i = Iso(formula = d)
+        if i.getTheoreticalAverageMass() > target_avg_mass:
+            break
+        d['H'] += 1
+
+def averagine_dct(target_avg_mass):
+    units = float(target_avg_mass) / averagine_mass
+    d = dict((key, int(units*val)) for key, val in averagine_unit.items())
+    fillHs(d, target_avg_mass)
+    for x in list(d.keys()):
+        if d[x] == 0:
+            del d[x]
+    return d
+
+def averagine(target_avg_mass):
+    return ''.join(str(key)+str(val) for key, val in sorted(averagine_dct(target_avg_mass).items(), key= lambda x: x[0]))
+
+
+acgt_avg_base = Counter({
+'C' : 9.75,
+'H' : 12.25,
+'N' : 3.75,
+'O' : 6.0,
+'P' : 1.0
+})
+
+def acgt_dct(no_bases, add_water = True):
+    c = {key : int(val*no_bases+0.5) for key, val in acgt_avg_base.items()}
+    if add_water:
+        c['H'] += 2
+        c['O'] += 1
+    return c
+
+def acgt(no_bases, add_water = True):
+    c = acgt_dct(no_bases, add_water = add_water)
+    return ''.join(str(key)+str(val) for key, val in sorted(c.items(), key= lambda x: x[0]))

IsoSpecPy/IsoSpec++/allocator.h

@@ -0,0 +1,69 @@
+/*
+ *   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 "conf.h"
+#include "pod_vector.h"
+
+namespace IsoSpec
+{
+
+template <typename T> inline void copyConf(
+    const T* source, T* destination,
+    int dim
+){
+    memcpy(destination, source, dim*sizeof(T));
+}
+
+template <typename T> class Allocator
+{
+ private:
+    T*      currentTab;
+    int currentId;
+    const int       dim, tabSize;
+    pod_vector<T*>  prevTabs;
+
+ public:
+    explicit Allocator(const int dim, const int tabSize = 10000);
+    ~Allocator();
+
+    Allocator(const Allocator& other) = delete;
+    Allocator& operator=(const Allocator& other) = delete;
+
+    void shiftTables();
+
+    inline T* newConf()
+    {
+        currentId++;
+
+        if (currentId >= tabSize)
+            shiftTables();
+
+        return &(currentTab[ currentId * dim ]);
+    }
+
+    inline T* makeCopy(const T* conf)
+    {
+        T* currentPlace = newConf();
+        copyConf<T>( conf, currentPlace, dim );
+
+        return currentPlace;
+    }
+};
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/btrd.h

@@ -0,0 +1,206 @@
+/* This file was taken from Boost, as permitted by Boost licence,
+ * with slight modifications. The reason is: we don't want to introduce
+ * dependency on the whole Boost just for this one thing.
+ *
+ * Source: boost random/binomial_distribution.hpp header file, at version 1.71
+ *
+ * Copyright Steven Watanabe 2010
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ */
+
+#pragma once
+
+#include "isoMath.h"
+#include <cstdlib>
+#include <cstdint>
+#include <cmath>
+#include <limits>
+
+
+namespace IsoSpec {
+
+typedef double RealType;
+typedef int64_t IntType;
+
+
+static const RealType btrd_binomial_table[10] = {
+    0.08106146679532726,
+    0.04134069595540929,
+    0.02767792568499834,
+    0.02079067210376509,
+    0.01664469118982119,
+    0.01387612882307075,
+    0.01189670994589177,
+    0.01041126526197209,
+    0.009255462182712733,
+    0.008330563433362871
+};
+
+
+/**
+ * The binomial distribution is an integer valued distribution with
+ * two parameters, @c t and @c p.  The values of the distribution
+ * are within the range [0,t].
+ *
+ * The distribution function is
+ * \f$\displaystyle P(k) = {t \choose k}p^k(1-p)^{t-k}\f$.
+ *
+ * The algorithm used is the BTRD algorithm described in
+ *
+ *  @blockquote
+ *  "The generation of binomial random variates", Wolfgang Hormann,
+ *  Journal of Statistical Computation and Simulation, Volume 46,
+ *  Issue 1 & 2 April 1993 , pages 101 - 110
+ *  @endblockquote
+ */
+
+
+// computes the correction factor for the Stirling approximation
+// for log(k!)
+static RealType fc(IntType k)
+{
+    if(k < 10) { return btrd_binomial_table[k]; }
+    else
+    {
+        RealType ikp1 = RealType(1) / (k + 1);
+        return (RealType(1)/12
+             - (RealType(1)/360
+             - (RealType(1)/1260)*(ikp1*ikp1))*(ikp1*ikp1))*ikp1;
+    }
+}
+
+IntType btrd(IntType _t, RealType p, IntType m, std::mt19937& urng = random_gen)
+{
+    using std::floor;
+    using std::abs;
+    using std::log;
+
+    RealType btrd_r = p/(1-p);
+    RealType btrd_nr = (_t+1)*btrd_r;
+    RealType btrd_npq = _t*p*(1-p);
+    RealType sqrt_npq = sqrt(btrd_npq);
+    RealType btrd_b = 1.15 + 2.53 * sqrt_npq;
+    RealType btrd_a = -0.0873 + 0.0248*btrd_b + 0.01*p;
+    RealType btrd_c = _t*p + 0.5;
+    RealType btrd_alpha = (2.83 + 5.1/btrd_b) * sqrt_npq;
+    RealType btrd_v_r = 0.92 - 4.2/btrd_b;
+    RealType btrd_u_rv_r = 0.86*btrd_v_r;
+
+    while(true) {
+        RealType u;
+        RealType v = stdunif(urng);
+        if(v <= btrd_u_rv_r) {
+            u = v/btrd_v_r - 0.43;
+            return static_cast<IntType>(floor(
+                (2*btrd_a/(0.5 - abs(u)) + btrd_b)*u + btrd_c));
+        }
+
+        if(v >= btrd_v_r) {
+            u = stdunif(urng) - 0.5;
+        } else {
+            u = v/btrd_v_r - 0.93;
+            u = ((u < 0)? -0.5 : 0.5) - u;
+            v = stdunif(urng) * btrd_v_r;
+        }
+
+        RealType us = 0.5 - abs(u);
+        IntType k = static_cast<IntType>(floor((2*btrd_a/us + btrd_b)*u + btrd_c));
+        if(k < 0 || k > _t) continue;
+        v = v*btrd_alpha/(btrd_a/(us*us) + btrd_b);
+        RealType km = abs(k - m);
+        if(km <= 15) {
+            RealType f = 1;
+            if(m < k) {
+                IntType i = m;
+                do {
+                    ++i;
+                    f = f*(btrd_nr/i - btrd_r);
+                } while(i != k);
+            } else if(m > k) {
+                IntType i = k;
+                do {
+                    ++i;
+                    v = v*(btrd_nr/i - btrd_r);
+                } while(i != m);
+            }
+            if(v <= f) return k;
+            else continue;
+        } else {
+            // final acceptance/rejection
+            v = log(v);
+            RealType rho =
+                (km/btrd_npq)*(((km/3. + 0.625)*km + 1./6)/btrd_npq + 0.5);
+            RealType t = -km*km/(2*btrd_npq);
+            if(v < t - rho) return k;
+            if(v > t + rho) continue;
+
+            IntType nm = _t - m + 1;
+            RealType h = (m + 0.5)*log((m + 1)/(btrd_r*nm))
+                       + fc(m) + fc(_t - m);
+
+            IntType nk = _t - k + 1;
+            if(v <= h + (_t+1)*log(static_cast<RealType>(nm)/nk)
+                      + (k + 0.5)*log(nk*btrd_r/(k+1))
+                      - fc(k)
+                      - fc(_t - k))
+            {
+                return k;
+            } else {
+                continue;
+            }
+        }
+    }
+}
+
+IntType invert(IntType t, RealType p, std::mt19937& urng = random_gen)
+{
+    RealType q = 1 - p;
+    RealType s = p / q;
+    RealType a = (t + 1) * s;
+    RealType r = pow((1 - p), static_cast<RealType>(t));
+    RealType u = stdunif(urng);
+    IntType x = 0;
+    while(u > r) {
+        u = u - r;
+        ++x;
+        RealType r1 = ((a/x) - s) * r;
+        // If r gets too small then the round-off error
+        // becomes a problem.  At this point, p(i) is
+        // decreasing exponentially, so if we just call
+        // it 0, it's close enough.  Note that the
+        // minimum value of q_n is about 1e-7, so we
+        // may need to be a little careful to make sure that
+        // we don't terminate the first time through the loop
+        // for float.  (Hence the test that r is decreasing)
+        if(r1 < std::numeric_limits<RealType>::epsilon() && r1 < r) {
+            break;
+        }
+        r = r1;
+    }
+    return x;
+}
+
+
+IntType boost_binomial_distribution_variate(IntType t_arg, RealType p_arg, std::mt19937& urng = random_gen)
+{
+    bool other_side = p_arg > 0.5;
+    RealType fake_p = other_side ? 1.0 - p_arg : p_arg;
+    IntType m = static_cast<IntType>((t_arg+1)*fake_p);
+    IntType result;
+    if(m < 11)
+        result = invert(t_arg, fake_p, urng);
+    else
+        result = btrd(t_arg, fake_p, m, urng);
+
+    if(other_side)
+        return t_arg - result;
+    else
+        return result;
+}
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/conf.h

@@ -0,0 +1,38 @@
+/*
+ *   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
+{
+
+typedef int* Conf;
+
+struct ProbAndConfPtr
+{
+    // For some reason std::pair isn't trivially copyable...
+    double first;
+    Conf second;
+
+    ProbAndConfPtr(double p, Conf c) : first(p), second(c) {}
+
+    bool operator<(const ProbAndConfPtr& other) const
+    {
+        return first < other.first;
+    }
+};
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/cwrapper.h

@@ -0,0 +1,179 @@
+/*
+ *   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 "platform.h"
+
+#define ISOSPEC_ALGO_LAYERED 0
+#define ISOSPEC_ALGO_ORDERED 1
+#define ISOSPEC_ALGO_THRESHOLD_ABSOLUTE 2
+#define ISOSPEC_ALGO_THRESHOLD_RELATIVE 3
+#define ISOSPEC_ALGO_LAYERED_ESTIMATE 4
+
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+ISOSPEC_C_API void * setupIso(int             dimNumber,
+                const int*      isotopeNumbers,
+                const int*      atomCounts,
+                const double*   isotopeMasses,
+                const double*   isotopeProbabilities);
+
+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 getHeaviestPeakMassIso(void* iso);
+ISOSPEC_C_API double getMonoisotopicPeakMassIso(void* iso);
+ISOSPEC_C_API double getModeLProbIso(void* iso);
+ISOSPEC_C_API double getModeMassIso(void* iso);
+ISOSPEC_C_API double getTheoreticalAverageMassIso(void* iso);
+ISOSPEC_C_API double getIsoVariance(void* iso);
+ISOSPEC_C_API double getIsoStddev(void* iso);
+ISOSPEC_C_API double* getMarginalLogSizeEstimates(void* iso, double target_total_prob);
+
+
+ISOSPEC_C_API void deleteIso(void* iso);
+
+
+// ______________________________________________________THRESHOLD GENERATOR
+ISOSPEC_C_API void* setupIsoThresholdGenerator(void* iso,
+                                 double threshold,
+                                 bool _absolute,
+                                 int _tabSize,
+                                 int _hashSize,
+                                 bool reorder_marginals);
+ISOSPEC_C_API double massIsoThresholdGenerator(void* generator);
+ISOSPEC_C_API double lprobIsoThresholdGenerator(void* generator);
+ISOSPEC_C_API double probIsoThresholdGenerator(void* generator);
+ISOSPEC_C_API void get_conf_signatureIsoThresholdGenerator(void* generator, int* space);
+ISOSPEC_C_API bool advanceToNextConfigurationIsoThresholdGenerator(void* generator);
+ISOSPEC_C_API void deleteIsoThresholdGenerator(void* generator);
+
+
+// ______________________________________________________LAYERED GENERATOR
+ISOSPEC_C_API void* setupIsoLayeredGenerator(void* iso,
+                               int _tabSize,
+                               int _hashSize,
+                               bool reorder_marginals,
+                               double t_prob_hint);
+ISOSPEC_C_API double massIsoLayeredGenerator(void* generator);
+ISOSPEC_C_API double lprobIsoLayeredGenerator(void* generator);
+ISOSPEC_C_API double probIsoLayeredGenerator(void* generator);
+ISOSPEC_C_API void get_conf_signatureIsoLayeredGenerator(void* generator, int* space);
+ISOSPEC_C_API bool advanceToNextConfigurationIsoLayeredGenerator(void* generator);
+ISOSPEC_C_API void deleteIsoLayeredGenerator(void* generator);
+
+// ______________________________________________________ORDERED GENERATOR
+ISOSPEC_C_API void* setupIsoOrderedGenerator(void* iso,
+                               int _tabSize,
+                               int _hashSize);
+ISOSPEC_C_API double massIsoOrderedGenerator(void* generator);
+ISOSPEC_C_API double lprobIsoOrderedGenerator(void* generator);
+ISOSPEC_C_API double probIsoOrderedGenerator(void* generator);
+ISOSPEC_C_API void get_conf_signatureIsoOrderedGenerator(void* generator, int* space);
+ISOSPEC_C_API bool advanceToNextConfigurationIsoOrderedGenerator(void* generator);
+ISOSPEC_C_API void deleteIsoOrderedGenerator(void* generator);
+
+// ______________________________________________________STOCHASTIC GENERATOR
+ISOSPEC_C_API void* setupIsoStochasticGenerator(void* iso,
+                                   size_t no_molecules,
+                                   double precision,
+                                   double beta_bias);
+ISOSPEC_C_API double massIsoStochasticGenerator(void* generator);
+ISOSPEC_C_API double lprobIsoStochasticGenerator(void* generator);
+ISOSPEC_C_API double probIsoStochasticGenerator(void* generator);
+ISOSPEC_C_API void get_conf_signatureIsoStochasticGenerator(void* generator, int* space);
+ISOSPEC_C_API bool advanceToNextConfigurationIsoStochasticGenerator(void* generator);
+ISOSPEC_C_API void deleteIsoStochasticGenerator(void* generator);
+
+ISOSPEC_C_API void* setupThresholdFixedEnvelope(void* iso,
+                              double threshold,
+                              bool absolute,
+                              bool get_confs);
+
+ISOSPEC_C_API void* setupTotalProbFixedEnvelope(void* iso,
+                              double taget_coverage,
+                              bool optimize,
+                              bool get_confs);
+
+ISOSPEC_C_API void* setupStochasticFixedEnvelope(void* iso,
+                              size_t no_molecules,
+                              double precision,
+                              double beta_bias,
+                              bool get_confs);
+
+ISOSPEC_C_API void* setupBinnedFixedEnvelope(void* iso,
+                    double target_total_prob,
+                    double bin_width,
+                    double bin_middle);
+
+ISOSPEC_C_API void freeReleasedArray(void* array);
+
+ISOSPEC_C_API void array_add(double* array, size_t N, double what);
+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* copyFixedEnvelope(void* other);
+ISOSPEC_C_API void deleteFixedEnvelope(void* tabulator, bool releaseEverything);
+
+ISOSPEC_C_API const double* massesFixedEnvelope(void* tabulator);
+ISOSPEC_C_API const double* probsFixedEnvelope(void* tabulator);
+ISOSPEC_C_API const int*    confsFixedEnvelope(void* tabulator);
+ISOSPEC_C_API size_t confs_noFixedEnvelope(void* tabulator);
+
+ISOSPEC_C_API double empiricAverageMass(void* tabulator);
+ISOSPEC_C_API double empiricVariance(void* tabulator);
+ISOSPEC_C_API double empiricStddev(void* tabulator);
+
+ISOSPEC_C_API double wassersteinDistance(void* tabulator1, void* tabulator2);
+ISOSPEC_C_API double orientedWassersteinDistance(void* tabulator1, void* tabulator2);
+ISOSPEC_C_API double abyssalWassersteinDistance(void* tabulator1, void* tabulator2, double abyss_depth, double other_scale);
+//ISOSPEC_C_API double abyssalWassersteinDistanceGrad(void* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the);
+
+struct ws_match_res{
+double res1;
+double res2;
+double flow;
+};
+
+ISOSPEC_C_API struct ws_match_res wassersteinMatch(void* tabulator1, void* tabulator2, double flow_dist, double other_scale);
+
+ISOSPEC_C_API void* addEnvelopes(void* tabulator1, void* tabulator2);
+ISOSPEC_C_API void* convolveEnvelopes(void* tabulator1, void* tabulator2);
+
+ISOSPEC_C_API double getTotalProbOfEnvelope(void* envelope);
+ISOSPEC_C_API void scaleEnvelope(void* envelope, double factor);
+ISOSPEC_C_API void normalizeEnvelope(void* envelope);
+ISOSPEC_C_API void shiftMassEnvelope(void* envelope, double d_mass);
+ISOSPEC_C_API void resampleEnvelope(void* envelope, size_t ionic_current, double beta_bias);
+ISOSPEC_C_API void* binnedEnvelope(void* envelope, double width, double middle);
+ISOSPEC_C_API void* linearCombination(void* const * const envelopes, const double* intensities, size_t count);
+
+ISOSPEC_C_API void sortEnvelopeByMass(void* envelope);
+ISOSPEC_C_API void sortEnvelopeByProb(void* envelope);
+
+ISOSPEC_C_API void parse_fasta_c(const char* fasta, int atomCounts[6]);
+
+
+#ifdef __cplusplus
+}
+#endif