IsoSpecPy 2.3.0.dev1__tar.gz → 2.3.0.dev4__tar.gz

isospecpy-2.3.0.dev4/.vscode/settings.json

@@ -0,0 +1,48 @@
+{
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__verbose_abort": "cpp",
+        "array": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "execution": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "print": "cpp",
+        "queue": "cpp",
+        "ratio": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "algorithm": "cpp"
+    }
+}

isospecpy-2.3.0.dev4/IsoSpec++/Makefile

@@ -0,0 +1,35 @@
+OPTFLAGS=-O3 -march=native -mtune=native
+DEBUGFLAGS=-O0 -g -Werror -DISOSPEC_DEBUG -DDEBUG -D_GLIBCXX_DEBUG
+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
+
+unitylib:
+	$(CXX) $(CXXFLAGS) $(OPTFLAGS) unity-build.cpp -fPIC -shared -o libIsoSpec++.so
+
+debug:
+	$(CXX) $(CXXFLAGS) $(DEBUGFLAGS) unity-build.cpp -DDEBUG -fPIC -shared -o libIsoSpec++.so
+
+debug-gcc:
+	g++ $(CXXFLAGS) $(DEBUGFLAGS) unity-build.cpp -DDEBUG -fPIC -shared -o libIsoSpec++.so
+
+nonunity:
+	$(CXX) $(CXXFLAGS) $(OPTFLAGS) $(SRCFILES) -DDEBUG -fPIC -shared -o libIsoSpec++.so
+
+clean:
+	rm -f libIsoSpec++.so
+
+windows:
+	#g++ -O3 -std=gnu++1z -O3 -shared -static -static-libstdc++ -static-libgcc unity-build.cpp -o ../IsoSpecPy/IsoSpec++.dll
+	x86_64-w64-mingw32-g++.exe -std=c++11 -O3 -shared -static -static-libstdc++ unity-build.cpp -o ../IsoSpecPy/IsoSpecPy/prebuilt-libIsoSpec++-2.1.0-x64.dll
+	i686-w64-mingw32-g++.exe -std=c++11 -O3 -shared -static -static-libstdc++ unity-build.cpp -o ../IsoSpecPy/IsoSpecPy/prebuilt-libIsoSpec++-2.1.0-x32.dll
+check:
+	cpplint *.cpp *.h
+	#cppcheck --std=c++11 --language=c++ --enable=style,portability,missingInclude,performance -q --force *.cpp *.h --suppress=memleakOnRealloc:*:* --inline-suppr --template={file}:{line}\ \({severity}\)\ \<{id}\>:\ {message}
+
+check11:
+	$(CXX) -std=c++11 -Wall -pedantic -Wextra -Wshadow -fsyntax-only unity-build.cpp
+
+asm:
+	$(CXX) $(CXXFLAGS) $(OPTFLAGS) unity-build.cpp -S -o out.S

isospecpy-2.3.0.dev4/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-2.3.0.dev4/IsoSpec++/isoMath.cpp

@@ -0,0 +1,162 @@
+/*
+ *   This file has been released into public domain by John D. Cook
+ *   and is used here with some slight modifications (which are hereby
+ *   also released into public domain),
+ *
+ *   This file is part of IsoSpec.
+ */
+
+
+// NOLINT(legal/copyright)
+
+
+#include <cmath>
+#include <cstdlib>
+#include "isoMath.h"
+#include "platform.h"
+#include "btrd.h"
+
+namespace IsoSpec
+{
+
+
+void release_g_lfact_table()
+{
+#if ISOSPEC_GOT_MMAN
+    munmap(g_lfact_table, ISOSPEC_G_FACT_TABLE_SIZE*sizeof(double));
+#else
+    free(g_lfact_table);
+#endif
+}
+
+double* alloc_lfact_table()
+{
+    double* ret;
+# if ISOSPEC_GOT_MMAN
+    ret = reinterpret_cast<double*>(mmap(nullptr, sizeof(double)*ISOSPEC_G_FACT_TABLE_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+#else
+    ret = reinterpret_cast<double*>(calloc(ISOSPEC_G_FACT_TABLE_SIZE, sizeof(double)));
+#endif
+    std::atexit(release_g_lfact_table);
+    return ret;
+}
+
+double* g_lfact_table = alloc_lfact_table();
+
+
+double RationalApproximation(double t)
+{
+    // Abramowitz and Stegun formula 26.2.23.
+    // The absolute value of the error should be less than 4.5 e-4.
+    double c[] = {2.515517, 0.802853, 0.010328};
+    double d[] = {1.432788, 0.189269, 0.001308};
+    return t - ((c[2]*t + c[1])*t + c[0]) /
+               (((d[2]*t + d[1])*t + d[0])*t + 1.0);
+}
+
+double NormalCDFInverse(double p)
+{
+    if (p < 0.5)
+        return -RationalApproximation( sqrt(-2.0*log(p)) );
+    else
+        return RationalApproximation( sqrt(-2.0*log(1-p)) );
+}
+
+double NormalCDFInverse(double p, double mean, double stdev)
+{
+    return mean + stdev * NormalCDFInverse(p);
+}
+
+double NormalCDF(double x, double mean, double stdev)
+{
+    x = (x-mean)/stdev * 0.7071067811865476;
+
+    // constants
+    double a1 =  0.254829592;
+    double a2 = -0.284496736;
+    double a3 =  1.421413741;
+    double a4 = -1.453152027;
+    double a5 =  1.061405429;
+    double p  =  0.3275911;
+
+    // Save the sign of x
+    int sign = 1;
+    if (x < 0)
+        sign = -1;
+    x = fabs(x);
+
+    // A&S formula 7.1.26
+    double t = 1.0/(1.0 + p*x);
+    double y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x);
+
+    return 0.5*(1.0 + sign*y);
+}
+
+double NormalPDF(double x, double mean, double stdev)
+{
+    double two_variance = stdev * stdev * 2.0;
+    double delta = x-mean;
+    return exp( -delta*delta / two_variance )      /     sqrt( two_variance * pi );
+}
+
+const double sqrt_pi = 1.772453850905516027298167483341145182798;
+
+double LowerIncompleteGamma2(int a, double x)
+{
+    double base;
+    double exp_minus_x = exp(-x);
+    double current_s;
+    if(a % 2 == 0)
+    {
+        base = 1 - exp_minus_x;
+        current_s = 1.0;
+        a--;
+    }
+    else
+    {
+        base = sqrt_pi * erf(sqrt(x));
+        current_s = 0.5;
+    }
+
+    a = a/2;
+    for(; a; a--)
+    {
+        base = base * current_s - pow(x, current_s) * exp_minus_x;
+        current_s += 1.0;
+    }
+
+    return base;
+}
+
+double InverseLowerIncompleteGamma2(int a, double x)
+{
+    double l = 0.0;
+    double p = tgamma(a);
+    double s;
+
+    do {
+        s = (l+p) / 2.0;
+        double v = LowerIncompleteGamma2(a, s);
+        if (x < v)
+            p = s;
+        else
+            l = s;
+    } while((p-l)*1000.0 > p);
+
+    return s;
+}
+
+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)
+{
+    if (succ_prob >= 1.0)
+        return tries;
+    return IsoSpec::boost_binomial_distribution_variate(tries, succ_prob, rgen);
+}
+
+
+
+}  // namespace IsoSpec
+

isospecpy-2.3.0.dev4/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