IsoSpecPy 2.4.0__cp315-cp315-win32.whl

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,223 @@
+/*
+ *   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
+
+
+// Error reporting across the C ABI: these functions never let a C++ exception
+// escape (that would be undefined behaviour for a C / cffi caller). On bad input
+// or out-of-memory they instead return an out-of-band error value:
+//   * functions returning a handle/pointer return NULL,
+//   * functions returning a double return NaN,
+//   * functions returning an integer/bool return 0 / false.
+// Callers should check the returned handle for NULL before using it.
+
+#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 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);
+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* 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);
+
+/* These three hand the envelope's array over to the caller, who must free() it
+   (with freeReleasedArray) once done. That costs a copy of the whole array
+   whenever the envelope did not allocate it with plain malloc() -- which is the
+   normal case now that everything the library produces is SIMD-aligned, and one
+   that grew large enough is mapped straight from the OS. Prefer the *WithDeleter
+   variants below, which never copy. */
+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);
+
+/* How a buffer obtained from one of the *WithDeleter entry points below has to
+   be given back: deleter(array, size), exactly once, with the very size that
+   came out alongside the pointer. free() is not, in general, the right answer.
+   Call it through freeReleasedArrayWithDeleter() rather than directly, so
+   callers that cannot invoke a raw function pointer (cffi, say) need not. */
+typedef void (*IsoSpecArrayDeleter)(void* array, size_t size);
+
+/* Zero-copy counterparts of the three getters above: each yields the array's
+   pointer and writes out the (size, deleter) pair needed to release it. Both
+   out-parameters may be NULL if not wanted -- but then the array can only be
+   leaked. A NULL return means either an empty envelope or an error. */
+ISOSPEC_C_API double* massesFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+ISOSPEC_C_API double* probsFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+ISOSPEC_C_API int*    confsFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+
+ISOSPEC_C_API void freeReleasedArrayWithDeleter(void* array, size_t size, IsoSpecArrayDeleter deleter);
+
+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]);
+
+/* What the library's batched kernels are vectorised to on this machine, as a
+   stable lowercase token: "scalar", "sse2", "avx", "avx2", "avx512", "neon", or
+   "simd" for a vector unit with no name here. Never NULL; a static string, so
+   it must NOT be freed. See active_simd_level() in isa_kernels.h. */
+ISOSPEC_C_API const char* activeSimdLevel(void);
+
+
+#ifdef __cplusplus
+}
+#endif

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,70 @@
+/*
+ *   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 <cstddef>
+#include <cstring>
+
+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[static_cast<unsigned char>(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