IsoSpecPy 2.5.0__py3-none-win_amd64.whl

IsoSpecPy/IsoSpec++/pod_vector.h

@@ -0,0 +1,400 @@
+/*!
+    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 <type_traits>
+#include <cstdlib>
+#include <cstddef>
+#include <utility>
+#include <new>
+#include <algorithm>
+#include "platform.h"
+#include "conf.h"
+
+
+
+template<typename T> class unsafe_pod_vector;
+
+template<typename T> class pod_vector
+{
+    T* backend_past_end;
+    T* first_free;
+    T* store;
+
+ public:
+    explicit pod_vector(size_t initial_size = 16)
+    {
+    #if !ISOSPEC_BUILDING_R
+        static_assert(std::is_trivially_copyable<T>::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
+    #endif
+
+        store = reinterpret_cast<T*>(malloc(sizeof(T) * initial_size));
+        if(store == NULL)
+            throw std::bad_alloc();
+        first_free = store;
+        backend_past_end = store + initial_size;
+    }
+
+    pod_vector(const pod_vector<T>& other) = delete;
+    pod_vector& operator=(const pod_vector<T>& other) = delete;
+    pod_vector& operator=(pod_vector<T>&& other)
+    {
+        free(store);
+        backend_past_end = other.backend_past_end;
+        first_free = other.first_free;
+        store = other.store;
+        other.backend_past_end = other.first_free = other.store = NULL;
+        return *this;
+    }
+
+    pod_vector(pod_vector<T>&& other)
+    {
+        backend_past_end = other.backend_past_end;
+        first_free = other.first_free;
+        store = other.store;
+        other.backend_past_end = other.first_free = other.store = NULL;
+    }
+
+    ~pod_vector() { free(store); backend_past_end = first_free = store = NULL; }
+
+    explicit pod_vector(unsafe_pod_vector<T>&& other)
+    {
+        backend_past_end = other.backend_past_end;
+        first_free = other.first_free;
+        store = other.store;
+       other.backend_past_end = other.first_free = other.store = NULL;
+    }
+
+    void fast_reserve(size_t n)
+    {
+        ISOSPEC_IMPOSSIBLE(n < static_cast<size_t>(backend_past_end - store));
+        const std::ptrdiff_t store_used_size = first_free - store;
+        T* new_store = reinterpret_cast<T*>(realloc(store, n * sizeof(T)));
+        if(new_store == NULL)
+            throw std::bad_alloc();
+        first_free = new_store + store_used_size;
+        backend_past_end = new_store + n;
+        store = new_store;
+    }
+
+    void reserve(size_t n)
+    {
+        if (n > static_cast<size_t>(backend_past_end - store))
+            fast_reserve(n);
+    }
+
+    void resize(size_t new_size)
+    {
+        ISOSPEC_IMPOSSIBLE(static_cast<std::ptrdiff_t>(new_size) < first_free - store);
+        size_t cap = capacity();
+        if(cap < new_size)
+        {
+            cap = (std::max<size_t>)(4, cap);
+            do {
+            cap = cap * 2;
+            } while(cap < new_size);
+            fast_reserve(cap);
+        }
+        first_free = store + new_size;
+    }
+
+    void resize_and_wipe(size_t new_size)
+    {
+        size_t old_size = size();
+        ISOSPEC_IMPOSSIBLE(new_size <= old_size);
+        resize(new_size);
+        memset(store+old_size, 0, (new_size-old_size) * sizeof(T));
+    }
+
+    ISOSPEC_FORCE_INLINE void nocheck_push_back(const T& val) noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(first_free >= backend_past_end);
+        *first_free = val;
+        first_free++;
+    }
+
+    ISOSPEC_FORCE_INLINE void push_back(const T& val)
+    {
+        if(first_free >= backend_past_end)
+            fast_reserve((std::max<std::ptrdiff_t>)(4, (backend_past_end-store)) * 2);
+        *first_free = val;
+        first_free++;
+    }
+
+    ISOSPEC_FORCE_INLINE T& operator[](size_t n) noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store + n >= first_free);
+        return store[n];
+    }
+
+    ISOSPEC_FORCE_INLINE const T& operator[](size_t n) const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store + n >= first_free);
+        return store[n];
+    }
+
+    ISOSPEC_FORCE_INLINE size_t size() const noexcept
+    {
+        return first_free - store;
+    }
+
+    ISOSPEC_FORCE_INLINE size_t capacity() const noexcept
+    {
+        return backend_past_end - store;
+    }
+
+    ISOSPEC_FORCE_INLINE T* data() noexcept
+    {
+        return store;
+    }
+
+    ISOSPEC_FORCE_INLINE const T* data() const noexcept
+    {
+        return store;
+    }
+
+    ISOSPEC_FORCE_INLINE bool empty() const noexcept
+    {
+        return first_free == store;
+    }
+
+    ISOSPEC_FORCE_INLINE const T& back() const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(first_free == store);
+        return *(first_free-1);
+    }
+
+    ISOSPEC_FORCE_INLINE void pop_back() noexcept
+    {
+        // Unlike std::vector we do not ever shrink backend storage unless explicitly requested.
+        ISOSPEC_IMPOSSIBLE(first_free == store);
+        first_free--;
+    }
+
+    void swap(pod_vector<T>& other) noexcept
+    {
+        std::swap(backend_past_end, other.backend_past_end);
+        std::swap(first_free, other.first_free);
+        std::swap(store, other.store);
+    }
+
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    typedef T value_type;
+    typedef size_t size_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+
+    iterator begin() noexcept { return store; };
+    const_iterator begin() const noexcept { return store; }
+    const_iterator cbegin() const noexcept { return store; }
+    iterator end() noexcept { return first_free; }
+    const_iterator end() const noexcept { return first_free; }
+    const_iterator cend() const noexcept { return first_free; }
+
+    ISOSPEC_FORCE_INLINE const T& front() const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store == first_free);
+        return *store;
+    }
+
+    void clear()
+    {
+        free(store);
+        first_free = store = backend_past_end = NULL;
+    }
+
+    friend class unsafe_pod_vector<T>;
+};
+
+
+template<typename T> class unsafe_pod_vector
+{
+    T* backend_past_end;
+    T* first_free;
+    T* store;
+
+ public:
+    unsafe_pod_vector() = default;
+
+    void init() {
+    #if !ISOSPEC_BUILDING_R
+        static_assert(std::is_trivially_copyable<T>::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
+        static_assert(std::is_trivially_copyable<unsafe_pod_vector<T> >::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
+    #endif
+        memset(this, 0, sizeof(*this));
+    }
+
+    void init(size_t initial_size)
+    {
+    #if !ISOSPEC_BUILDING_R
+        static_assert(std::is_trivially_copyable<T>::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
+        static_assert(std::is_trivially_copyable<unsafe_pod_vector<T> >::value, "Cannot use a pod_vector with a non-Plain Old Data type.");
+    #endif
+        store = reinterpret_cast<T*>(malloc(sizeof(T) * initial_size));
+        if(store == NULL)
+            throw std::bad_alloc();
+        first_free = store;
+        backend_past_end = store + initial_size;
+    }
+
+    unsafe_pod_vector(const pod_vector<T>& other) = delete;  // NOLINT(runtime/explicit) - seriously? Deleted constructors have to be marked explicit?
+    unsafe_pod_vector& operator=(const pod_vector<T>& other) = delete;
+    // unsafe_pod_vector(unsafe_pod_vector<T>&& other) = default;
+
+    ~unsafe_pod_vector() = default;
+
+    void fast_reserve(size_t n)
+    {
+        ISOSPEC_IMPOSSIBLE(n < static_cast<size_t>(backend_past_end - store));
+        T* new_store = reinterpret_cast<T*>(realloc(store, n * sizeof(T)));
+        if(new_store == NULL)
+            throw std::bad_alloc();
+        first_free = new_store + (first_free - store);
+        backend_past_end = new_store + n;
+        store = new_store;
+    }
+
+    void reserve(size_t n)
+    {
+        if (n > static_cast<size_t>(backend_past_end - store))
+            fast_reserve(n);
+    }
+
+    void resize(size_t new_size)
+    {
+        ISOSPEC_IMPOSSIBLE(static_cast<std::ptrdiff_t>(new_size) < first_free - store);
+        size_t cap = capacity();
+        if(cap < new_size)
+        {
+            cap = (std::max<size_t>)(4, cap);
+            do {
+            cap = cap * 2;
+            } while(cap < new_size);
+            fast_reserve(cap);
+        }
+        first_free = store + new_size;
+    }
+
+    void resize_and_wipe(size_t new_size)
+    {
+        size_t old_size = size();
+        ISOSPEC_IMPOSSIBLE(new_size <= old_size);
+        resize(new_size);
+        memset(store+old_size, 0, (new_size-old_size) * sizeof(T));
+    }
+
+    ISOSPEC_FORCE_INLINE void nocheck_push_back(const T& val) noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(first_free >= backend_past_end);
+        *first_free = val;
+        first_free++;
+    }
+
+    ISOSPEC_FORCE_INLINE void push_back(const T& val)
+    {
+        if(first_free >= backend_past_end)
+            fast_reserve((std::max<std::ptrdiff_t>)(4, (backend_past_end-store)) * 2);
+        *first_free = val;
+        first_free++;
+    }
+
+    ISOSPEC_FORCE_INLINE T& operator[](size_t n) noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store + n >= first_free);
+        return store[n];
+    }
+
+    ISOSPEC_FORCE_INLINE const T& operator[](size_t n) const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store + n >= first_free);
+        return store[n];
+    }
+
+    ISOSPEC_FORCE_INLINE size_t size() const noexcept
+    {
+        return first_free - store;
+    }
+
+    ISOSPEC_FORCE_INLINE size_t capacity() const noexcept
+    {
+        return backend_past_end - store;
+    }
+
+    ISOSPEC_FORCE_INLINE T* data() noexcept
+    {
+        return store;
+    }
+
+    ISOSPEC_FORCE_INLINE const T* data() const noexcept
+    {
+        return store;
+    }
+
+    ISOSPEC_FORCE_INLINE bool empty() const noexcept
+    {
+        return first_free == store;
+    }
+
+    ISOSPEC_FORCE_INLINE const T& back() const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(first_free == store);
+        return *(first_free-1);
+    }
+
+    ISOSPEC_FORCE_INLINE void pop_back() noexcept
+    {
+        // Unlike std::vector we do not ever shrink backend storage unless explicitly requested.
+        ISOSPEC_IMPOSSIBLE(first_free == store);
+        first_free--;
+    }
+
+    void swap(unsafe_pod_vector<T>& other) noexcept
+    {
+        std::swap(backend_past_end, other.backend_past_end);
+        std::swap(first_free, other.first_free);
+        std::swap(store, other.store);
+    }
+
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    typedef T value_type;
+    typedef size_t size_type;
+    typedef T& reference;
+    typedef const T& const_reference;
+
+    iterator begin() noexcept { return store; };
+    const_iterator begin() const noexcept { return store; }
+    const_iterator cbegin() const noexcept { return store; }
+    iterator end() noexcept { return first_free; }
+    const_iterator end() const noexcept { return first_free; }
+    const_iterator cend() const noexcept { return first_free; }
+
+    ISOSPEC_FORCE_INLINE const T& front() const noexcept
+    {
+        ISOSPEC_IMPOSSIBLE(store == first_free);
+        return *store;
+    }
+
+    void clear()
+    {
+        free(store);
+        first_free = store = backend_past_end = NULL;
+    }
+
+    friend class pod_vector<T>;
+};

IsoSpecPy/IsoSpec++/summator.h

@@ -0,0 +1,118 @@
+/*
+ *   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 <vector>
+#include <utility>
+
+namespace IsoSpec
+{
+
+class SSummator
+{
+    // Shewchuk algorithm
+    std::vector<double> partials;
+    int maxpart;
+ public:
+    inline SSummator()
+    { maxpart = 0; }
+
+    inline SSummator(const SSummator& other) :
+        partials(other.partials),
+        maxpart(other.maxpart) {}
+
+    inline void add(double x)
+    {
+        unsigned int i = 0;
+        for(int pidx = 0; pidx < maxpart; pidx++)
+        {
+            double y = partials[pidx];
+            if(std::abs(x) < std::abs(y))
+                std::swap(x, y);
+            double hi = x+y;
+            double lo = y-(hi-x);
+            if(lo != 0.0)
+            {
+                partials[i] = lo;
+                i += 1;
+            }
+            x = hi;
+        }
+        while(partials.size() <= i)
+            partials.push_back(0.0);
+        partials[i] = x;
+        maxpart = i+1;
+    }
+    inline double get()
+    {
+        double ret = 0.0;
+        for(int i = 0; i < maxpart; i++)
+            ret += partials[i];
+        return ret;
+    }
+};
+
+
+
+
+
+
+
+class Summator{
+    // Kahan algorithm
+    double sum;
+    double c;
+
+ public:
+    inline Summator()
+    { sum = 0.0; c = 0.0;}
+
+    inline void add(double what)
+    {
+        double y = what - c;
+        double t = sum + y;
+        c = (t - sum) - y;
+        sum = t;
+    }
+
+    inline double get()
+    {
+        return sum;
+    }
+};
+
+class TSummator
+{
+    // Trivial algorithm, for testing only
+    double sum;
+ public:
+    inline TSummator()
+    { sum = 0.0; }
+
+    inline void add(double what)
+    {
+        sum += what;
+    }
+    inline double get()
+    {
+        return sum;
+    }
+};
+
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/unimod.h

@@ -0,0 +1,80 @@
+/*
+ *   Copyright (C) 2015-2026 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 <string>
+#include <vector>
+
+namespace IsoSpec {
+
+//! One Unimod modification's resolved, ready-to-merge atomic composition
+//! delta: parallel arrays over each element it touches, `element_first_index`
+//! being that element's row in element_tables.h's flat arrays (see
+//! element_lookup.h) and `element_delta_count` its signed atom-count change.
+struct UnimodEntry {
+    bool present = false;
+    std::string name;
+    double mono_mass = 0.0;
+    std::vector<int> element_first_index;
+    std::vector<int> element_delta_count;
+};
+
+//! Unimod ids -> resolved compositions, dense: a plain `vector<UnimodEntry>`
+//! indexed directly by id (sized one past the largest shipped id), not a
+//! map -- `lookup(id)` is a bounds check plus a `present` flag, matching
+//! Unimod's own id space (ids are assigned once and never reused).
+class UnimodTable {
+ public:
+    size_t size() const { return entries_.size(); }
+
+    //! nullptr for an id that is out of range, or in range but not shipped
+    //! (deliberately excluded -- isotope-labeled or glycan/derivatization
+    //! "brick" entries, see scripts/build_unimod_table.py) -- both cases are
+    //! the same "unknown to this table" outcome, no need to distinguish them.
+    const UnimodEntry* lookup(unsigned int id) const {
+        if (id >= entries_.size() || !entries_[id].present)
+            return nullptr;
+        return &entries_[id];
+    }
+
+ private:
+    std::vector<UnimodEntry> entries_;
+
+    friend UnimodTable parse_unimod_csv(const std::string& csv_text);
+};
+
+//! Parses a `data/unimod.csv`-shaped CSV (`id,name,mono_mass,composition`,
+//! composition in IsoSpec's own native formula-string grammar -- see
+//! scripts/build_unimod_table.py) into a UnimodTable. Throws
+//! std::invalid_argument on a malformed row or composition.
+UnimodTable parse_unimod_csv(const std::string& csv_text);
+
+//! The default table, embedded at compile time (src/IsoSpec++/
+//! unimod_table_data.h) and parsed once, lazily.
+const UnimodTable& embedded_unimod_table();
+
+//! Loads and parses `path` (same CSV shape as the embedded default),
+//! overriding it. `unimod_db_path == nullptr` or `""` should use
+//! `embedded_unimod_table()` instead -- callers check that, not this
+//! function. Caches a single (path, table) pair -- not a map: a process
+//! realistically uses 0 or 1 distinct override paths, so a full path-keyed
+//! map buys nothing over remembering just the last one. IsoSpec is
+//! single-threaded by design (see this repo's CLAUDE.md), so this cache is
+//! not synchronized; do not call it from more than one thread.
+const UnimodTable& unimod_table_for_path(const std::string& path);
+
+}  // namespace IsoSpec