IsoSpecPy 2.2.2__tar.gz → 2.3.0__tar.gz

{IsoSpecPy-2.2.2 → isospecpy-2.3.0}/LICENCE

@@ -8,7 +8,7 @@ your own software, but you are under no legal obligation to do so.
 -------------------------------------------------------------------------
 
 
-Copyright (c) 2015-2020, Micha� Startek and Mateusz ��cki
+Copyright (c) 2015-2025, Michał Startek and Mateusz Łącki
 
 All rights reserved.
 

isospecpy-2.3.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: IsoSpecPy
+Version: 2.3.0
+Summary: IsoSpecPy is a Python library for computing isotopic distributions of molecules.
+Keywords: isotopic distribution,mass spectrometry,chemistry,isotopic envelope,isotopologues
+Author: Michał Startek, Mateusz Łącki
+License-Expression: BSD-2-Clause
+License-File: LICENCE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/MatteoLacki/IsoSpec
+Project-URL: Repository, https://github.com/MatteoLacki/IsoSpec
+Requires-Python: >=3.6
+Requires-Dist: cffi
+Provides-Extra: testing
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: OldIsoSpecPy; extra == "testing"
+Description-Content-Type: text/markdown
+
+IsoSpec, the isotopic fine structure calculator
+===============================================
+
+The main purpose of this software package is to be used as a library, 
+mostly in mass spectrometry software. We do not provide any standalone
+programs, except for those in Examples directory which are intended to
+showcase the usage of the library.
+
+Please see the code in Examples directory for example usage.
+
+The software is publically available under a 2-clause BSD licence. If 
+you require other licensing terms, please contact the authors. See 
+LICENCE file for more details.
+
+More details about the program may be found in the following Analytical
+Chemistry publications:
+
+https://pubs.acs.org/doi/10.1021/acs.analchem.0c00959
+https://pubs.acs.org/doi/abs/10.1021/acs.analchem.6b01459
+
+See especially the Supporting Information for details about the algorithm.

isospecpy-2.3.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools", "scikit-build-core"]
+build-backend = "scikit_build_core.build"
+
+[tool.scikit-build]
+cmake.source-dir = "skbuild"
+
+[project]
+name = "IsoSpecPy"
+dependencies = ["cffi"]
+description = "IsoSpecPy is a Python library for computing isotopic distributions of molecules."
+version = "2.3.0"
+license = "BSD-2-Clause"
+license-files = ["LICENCE"]
+authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]
+readme = "README.md"
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.6",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: OS Independent",
+]
+keywords = ["isotopic distribution", "mass spectrometry", "chemistry", "isotopic envelope", "isotopologues"]
+
+[project.urls]
+Homepage = "https://github.com/MatteoLacki/IsoSpec"
+Repository = "https://github.com/MatteoLacki/IsoSpec"
+
+
+
+[project.optional-dependencies]
+testing = ["pytest", "OldIsoSpecPy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests/Python"]
+
+[tool.cibuildwheel]
+enable = ["pypy"]
+skip = ["cp36-*", "cp37-*", "pp37-*"]
+test-command = "python -m pytest {project}/tests/Python"
+#test-sources = ["tests/Python"]
+test-extras = ["testing"]
+
+[tool.scikit-build.sdist]
+exclude = ["**/*"]
+include = [
+    "/src/IsoSpecPy/*.py",
+    "/src/IsoSpec++/*.c",
+    "/src/IsoSpec++/*.h",
+    "/src/IsoSpec++/*.hpp",
+    "/src/IsoSpec++/*.cpp",
+    "/LICENCE",
+    "/README.md",
+    "/pyproject.toml",
+    "/skbuild/CMakeLists.txt"
+]

isospecpy-2.3.0/skbuild/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(IsoSpecPy CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+#find_package(PythonExtensions REQUIRED)
+#find_package(Python COMPONENTS Interpreter Development REQUIRED)
+
+add_library(IsoSpecCppPy SHARED ../src/IsoSpec++/unity-build.cpp)
+target_compile_features(IsoSpecCppPy PRIVATE cxx_std_17)
+#python_extension_module(IsoSpecCppPy)
+install(TARGETS IsoSpecCppPy LIBRARY DESTINATION IsoSpecPy)
+install(DIRECTORY ../src/IsoSpec++/ DESTINATION IsoSpecPy/IsoSpec++
+        FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp" PATTERN "*.hxx"
+)

{IsoSpecPy-2.2.2 → isospecpy-2.3.0/src}/IsoSpec++/cwrapper.h

@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "platform.h"
+
 #define ISOSPEC_ALGO_LAYERED 0
 #define ISOSPEC_ALGO_ORDERED 1
 #define ISOSPEC_ALGO_THRESHOLD_ABSOLUTE 2
@@ -50,22 +52,6 @@ ISOSPEC_C_API double* getMarginalLogSizeEstimates(void* iso, double target_total
 
 ISOSPEC_C_API void deleteIso(void* iso);
 
-#define ISOSPEC_C_FN_HEADER(generatorType, dataType, method)\
-ISOSPEC_C_API dataType method##generatorType(void* generator);
-
-#define ISOSPEC_C_FN_HEADER_GET_CONF_SIGNATURE(generatorType)\
-ISOSPEC_C_API void method##generatorType(void* generator);
-
-#define ISOSPEC_C_FN_HEADERS(generatorType)\
-ISOSPEC_C_FN_HEADER(generatorType, double, mass) \
-ISOSPEC_C_FN_HEADER(generatorType, double, lprob) \
-ISOSPEC_C_FN_HEADER(generatorType, double, prob) \
-ISOSPEC_C_FN_HEADER_GET_CONF_SIGNATURE(generatorType) \
-ISOSPEC_C_FN_HEADER(generatorType, bool, advanceToNextConfiguration) \
-ISOSPEC_C_FN_HEADER(generatorType, void, delete)
-
-
-
 
 // ______________________________________________________THRESHOLD GENERATOR
 ISOSPEC_C_API void* setupIsoThresholdGenerator(void* iso,
@@ -74,7 +60,12 @@ ISOSPEC_C_API void* setupIsoThresholdGenerator(void* iso,
                                  int _tabSize,
                                  int _hashSize,
                                  bool reorder_marginals);
-ISOSPEC_C_FN_HEADERS(IsoThresholdGenerator)
+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
@@ -83,20 +74,35 @@ ISOSPEC_C_API void* setupIsoLayeredGenerator(void* iso,
                                int _hashSize,
                                bool reorder_marginals,
                                double t_prob_hint);
-ISOSPEC_C_FN_HEADERS(IsoLayeredGenerator)
+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_FN_HEADERS(IsoOrderedGenerator)
-
+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_FN_HEADERS(IsoStochasticGenerator)
-
+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,
@@ -143,7 +149,7 @@ ISOSPEC_C_API double orientedWassersteinDistance(void* tabulator1, void* tabulat
 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);
 
-ISOSPEC_C_API struct ws_match_res{
+struct ws_match_res{
 double res1;
 double res2;
 double flow;

{IsoSpecPy-2.2.2 → isospecpy-2.3.0/src}/IsoSpec++/element_tables.cpp

@@ -23,7 +23,7 @@ namespace IsoSpec
 extern "C" {
 #endif
 
-const size_t isospec_number_of_isotopic_entries = ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES;
+const ::size_t isospec_number_of_isotopic_entries = ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES;
 
 const int elem_table_ID [ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES] = {
 1,

{IsoSpecPy-2.2.2/IsoSpecR/src → isospecpy-2.3.0/src/IsoSpec++}/element_tables.h

@@ -18,6 +18,8 @@
 
 #include <stddef.h>
 
+#include "platform.h"
+
 namespace IsoSpec
 {
 

{IsoSpecPy-2.2.2 → isospecpy-2.3.0/src}/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.2.2 → isospecpy-2.3.0/src}/IsoSpec++/fixedEnvelopes.cpp

@@ -16,6 +16,7 @@
 
 #include "fixedEnvelopes.h"
 #include <limits>
+#include <cassert>
 #include "isoMath.h"
 
 namespace IsoSpec

{IsoSpecPy-2.2.2/IsoSpecR/src → isospecpy-2.3.0/src/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.2.2/IsoSpecR/src → isospecpy-2.3.0/src/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.2.2/IsoSpecR/src → isospecpy-2.3.0/src/IsoSpec++}/isoSpec++.cpp

@@ -650,22 +650,22 @@ IsoThresholdGenerator::~IsoThresholdGenerator()
  * ------------------------------------------------------------------------------------------------------------------------
  */
 
-
-IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, bool reorder_marginals, double t_prob_hint)
+template <typename MarginalType>
+IsoLayeredGeneratorTemplate<MarginalType>::IsoLayeredGeneratorTemplate(Iso&& iso, int tabSize, int hashSize, bool reorder_marginals, double t_prob_hint)
 : IsoGenerator(std::move(iso))
 {
     counter = new int[dimNumber];
     maxConfsLPSum = new double[dimNumber-1];
     currentLThreshold = nextafter(mode_lprob, -std::numeric_limits<double>::infinity());
     lastLThreshold = (std::numeric_limits<double>::min)();
-    marginalResultsUnsorted = new LayeredMarginal*[dimNumber];
+    marginalResultsUnsorted = new MarginalType*[dimNumber];
     resetPositions = new const double*[dimNumber];
     marginalsNeedSorting = doMarginalsNeedSorting();
 
     memset(counter, 0, sizeof(int)*dimNumber);
 
     for(int ii = 0; ii < dimNumber; ii++)
-        marginalResultsUnsorted[ii] = new LayeredMarginal(std::move(*(marginals[ii])), tabSize, hashSize);
+        marginalResultsUnsorted[ii] = new MarginalType(std::move(*(marginals[ii])), tabSize, hashSize);
 
     if(reorder_marginals && dimNumber > 1)
     {
@@ -681,7 +681,7 @@ IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, b
         TableOrder<double> TO(marginal_priorities);
 
         std::sort(tmpMarginalOrder, tmpMarginalOrder + dimNumber, TO);
-        marginalResults = new LayeredMarginal*[dimNumber];
+        marginalResults = new MarginalType*[dimNumber];
 
         for(int ii = 0; ii < dimNumber; ii++)
             marginalResults[ii] = marginalResultsUnsorted[tmpMarginalOrder[ii]];
@@ -715,10 +715,11 @@ IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, b
     counter[0]--;
     lProbs_ptr--;
     lastLThreshold = 10.0;
-    IsoLayeredGenerator::nextLayer(-0.00001);
+    IsoLayeredGeneratorTemplate<MarginalType>::nextLayer(-0.00001);
 }
 
-bool IsoLayeredGenerator::nextLayer(double offset)
+template <typename MarginalType>
+bool IsoLayeredGeneratorTemplate<MarginalType>::nextLayer(double offset)
 {
     size_t first_mrg_size = marginalResults[0]->get_no_confs();
 
@@ -746,7 +747,8 @@ bool IsoLayeredGenerator::nextLayer(double offset)
     return true;
 }
 
-bool IsoLayeredGenerator::carry()
+template <typename MarginalType>
+bool IsoLayeredGeneratorTemplate<MarginalType>::carry()
 {
     // If we reached this point, a carry is needed
 
@@ -781,8 +783,8 @@ bool IsoLayeredGenerator::carry()
     return false;
 }
 
-
-void IsoLayeredGenerator::terminate_search()
+template<typename MarginalType>
+void IsoLayeredGeneratorTemplate<MarginalType>::terminate_search()
 {
     for(int ii = 0; ii < dimNumber; ii++)
     {
@@ -793,7 +795,8 @@ void IsoLayeredGenerator::terminate_search()
     lProbs_ptr = lProbs_ptr_start + marginalResults[0]->get_no_confs()-1;
 }
 
-IsoLayeredGenerator::~IsoLayeredGenerator()
+template<typename MarginalType>
+IsoLayeredGeneratorTemplate<MarginalType>::~IsoLayeredGeneratorTemplate()
 {
     delete[] counter;
     delete[] maxConfsLPSum;
@@ -805,33 +808,35 @@ IsoLayeredGenerator::~IsoLayeredGenerator()
       delete[] marginalOrder;
 }
 
+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();
@@ -851,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;
@@ -914,22 +918,32 @@ bool IsoOrderedGenerator::advanceToNextConfiguration()
     return true;
 }
 
+template class IsoOrderedGeneratorTemplate<MarginalTrek>;
+template class IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>;
+
 
 /*
  * ---------------------------------------------------------------------------------------------------
  */
 
-
-IsoStochasticGenerator::IsoStochasticGenerator(Iso&& iso, size_t no_molecules, double _precision, double _beta_bias) :
+template<typename IsoType>
+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<IsoLayeredGeneratorTemplate<SingleAtomMarginal<true>>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<MarginalTrek>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>>;
+//template class IsoStochasticGeneratorTemplate<IsoThresholdGenerator>;
+
 /*
  * ---------------------------------------------------------------------------------------------------
  */