IsoSpecPy 2.5.0__py3-none-win32.whl

IsoSpecPy/IsoSpec++/misc.h

@@ -0,0 +1,229 @@
+/*
+ *   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 <iostream>
+#include <vector>
+#include <cstring>
+#include <algorithm>
+#include "isoMath.h"
+#include "pod_vector.h"
+
+namespace IsoSpec
+{
+
+inline double combinedSum(
+    const int* conf, const std::vector<double>** valuesContainer, int dimNumber
+){
+    double res = 0.0;
+    for(int i = 0; i < dimNumber; i++)
+        res += (*(valuesContainer[i]))[conf[i]];
+    return res;
+}
+
+inline double combinedSum(
+    const int* conf, const pod_vector<double>** valuesContainer, int dimNumber
+){
+    double res = 0.0;
+    for(int i = 0; i < dimNumber; i++)
+        res += (*(valuesContainer[i]))[conf[i]];
+    return res;
+}
+
+inline int* getConf(void* conf)
+{
+    return reinterpret_cast<int*>(
+        reinterpret_cast<char*>(conf) + sizeof(double)
+    );
+}
+
+inline double getLProb(void* conf)
+{
+    double ret = *reinterpret_cast<double*>(conf);
+    return ret;
+}
+
+
+inline double unnormalized_logProb(const int* conf, const double* logProbs, int dim)
+{
+    double  res = 0.0;
+
+    for(int i = 0; i < dim; i++)
+        res += minuslogFactorial(conf[i]) + conf[i] * logProbs[i];
+
+    return res;
+}
+
+inline double calc_mass(const int* conf, const double* masses, int dim)
+{
+    double res = 0.0;
+
+    for(int i = 0; i < dim; i++)
+    {
+        res += conf[i] * masses[i];
+    }
+
+    return res;
+}
+
+
+
+template<typename T> void printArray(const T* array, size_t size, const char* prefix = "")
+{
+    if (strlen(prefix) > 0)
+        std::cout << prefix << " ";
+    for (size_t i = 0; i < size; i++)
+        std::cout << array[i] << " ";
+    std::cout << std::endl;
+}
+
+template<typename T> void printVector(const std::vector<T>& vec)
+{
+    printArray<T>(vec.data(), vec.size());
+}
+
+template<typename T> void printVector(const pod_vector<T>& vec)
+{
+    printArray<T>(vec.data(), vec.size());
+}
+
+template<typename T> void printOffsets(const T** array, size_t size, const T* offset, const char* prefix = "")
+{
+    if (strlen(prefix) > 0)
+        std::cout << prefix << " ";
+    for (size_t i = 0; i < size; i++)
+        std::cout << array[i] - offset << " ";
+    std::cout << std::endl;
+}
+
+template<typename T> void printNestedArray(const T** array, const int* shape, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+        printArray(array[i], shape[i]);
+    std::cout << std::endl;
+}
+
+//! Quickly select the n'th positional statistic, including the weights.
+void* quickselect(void** array, size_t n, size_t start, size_t end);
+
+
+template <typename T> inline static T* array_copy(const T* A, size_t size)
+{
+    T* ret = new T[size];
+    // memcpy() is declared with __attribute__((nonnull)), so a zero-length copy
+    // from a null source is undefined behaviour even though it moves no bytes.
+    // A zero-dimensional Iso (e.g. setupIso(0, NULL, ...)) reaches exactly that.
+    if(size > 0)
+        memcpy(ret, A, size*sizeof(T));
+    return ret;
+}
+
+template <typename T> inline static T* array_copy_malloc(const T* A, size_t size)
+{
+    T* ret = reinterpret_cast<T*>(malloc(size * sizeof(T)));
+    if(ret == nullptr)
+        throw std::bad_alloc();
+    memcpy(ret, A, size*sizeof(T));
+    return ret;
+}
+
+
+template <typename T> static T* array_copy_nptr(const T* A, size_t size)
+{
+    if(A == nullptr)
+        return nullptr;
+    return array_copy(A, size);
+}
+
+template <typename T> static T* array_copy_nptr_malloc(const T* A, size_t size)
+{
+    if(A == nullptr)
+        return nullptr;
+    return array_copy_malloc(A, size);
+}
+
+
+template<typename T> void dealloc_table(T* tbl, int dim)
+{
+    for(int i = 0; i < dim; i++)
+    {
+        delete tbl[i];
+    }
+    delete[] tbl;
+}
+
+template<typename T> void realloc_append(T** array, T what, size_t old_array_size)
+{
+    T* newT = new T[old_array_size+1];
+    // *array may be nullptr when old_array_size == 0 (a default-constructed
+    // Iso), and memcpy from a null pointer is undefined even for zero bytes.
+    if(old_array_size > 0)
+        memcpy(newT, *array, old_array_size*sizeof(T));
+    newT[old_array_size] = what;
+    delete[] *array;
+    *array = newT;
+}
+
+template<typename T> size_t* get_order(T* order_array, size_t N)
+{
+    size_t* arr = new size_t[N];
+    for(size_t ii = 0; ii < N; ii++)
+        arr[ii] = ii;
+
+    std::sort(arr, arr + N, [&](size_t i, size_t j) { return order_array[i] < order_array[j]; });
+
+    return arr;
+}
+
+template<typename T> size_t* get_inverse_order(T* order_array, size_t N)
+{
+    size_t* arr = new size_t[N];
+    for(size_t ii = 0; ii < N; ii++)
+        arr[ii] = ii;
+
+    std::sort(arr, arr + N, [&](size_t i, size_t j) { return order_array[i] > order_array[j]; });
+
+    return arr;
+}
+
+template<typename TA, typename TB> void impose_order(size_t* O, size_t N, TA* A, TB* B)
+{
+    for(size_t ii = 0; ii < N; ii++)
+    {
+        if(ii != O[ii])
+        {
+            size_t curr_ii = ii;
+            TA ta = A[ii];
+            TB tb = B[ii];
+            size_t next_ii = O[ii];
+            while(next_ii != ii)
+            {
+                A[curr_ii] = A[next_ii];
+                B[curr_ii] = B[next_ii];
+                O[curr_ii] = curr_ii;
+                curr_ii = next_ii;
+                next_ii = O[next_ii];
+            }
+            A[curr_ii] = ta;
+            B[curr_ii] = tb;
+            O[curr_ii] = curr_ii;
+        }
+    }
+}
+
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/mman.h

@@ -0,0 +1,67 @@
+/*
+ * NOLINT(legal/copyright) - the original authors did not slap a (C) notice in here,
+ * for whatever reason, and I'm in no position to do that for them.
+ *
+ * sys/mman.h
+ * mman-win32
+ *
+ * This file has been included as a part of IsoSpec project, under a MIT licence. It
+ * comes from the repository:
+ *
+ * https://github.com/witwall/mman-win32
+ *
+ * which itself is a mirror of:
+ *
+ * https://code.google.com/archive/p/mman-win32/
+ */
+
+#pragma once
+
+#ifndef _WIN32_WINNT            // Allow use of features specific to Windows XP or later.
+#define _WIN32_WINNT 0x0501     // Change this to the appropriate value to target other versions of Windows.
+#endif
+
+/* All the headers include this file. */
+#ifndef _MSC_VER
+#include <_mingw.h>
+#endif
+
+/* Determine offset type */
+#include <stdint.h>
+#if defined(_WIN64)
+typedef int64_t OffsetType;
+#else
+typedef uint32_t OffsetType;
+#endif
+
+#include <sys/types.h>
+
+
+#define PROT_NONE       0
+#define PROT_READ       1
+#define PROT_WRITE      2
+#define PROT_EXEC       4
+
+#define MAP_FILE        0
+#define MAP_SHARED      1
+#define MAP_PRIVATE     2
+#define MAP_TYPE        0xf
+#define MAP_FIXED       0x10
+#define MAP_ANONYMOUS   0x20
+#define MAP_ANON        MAP_ANONYMOUS
+
+#define MAP_FAILED      ((void *)-1)
+
+/* Flags for msync. */
+#define MS_ASYNC        1
+#define MS_SYNC         2
+#define MS_INVALIDATE   4
+
+void*   mmap(void *addr, size_t len, int prot, int flags, int fildes, OffsetType off);
+int     munmap(void *addr, size_t len);
+int     _mprotect(void *addr, size_t len, int prot);
+int     msync(void *addr, size_t len, int flags);
+int     mlock(const void *addr, size_t len);
+int     munlock(const void *addr, size_t len);
+
+

IsoSpecPy/IsoSpec++/operators.h

@@ -0,0 +1,150 @@
+/*
+ *   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 <string.h>
+#include "platform.h"
+#include "conf.h"
+#include "isoMath.h"
+#include "misc.h"
+
+namespace IsoSpec
+{
+
+class KeyHasher
+{
+ private:
+    int dim;
+
+ public:
+    explicit KeyHasher(int dim);
+
+    inline std::size_t operator()(const int* conf) const noexcept
+    {
+        std::size_t seed = conf[0];
+        for(int i = 1; i < dim; ++i )
+        {
+            constexpr_if(sizeof(std::size_t) == 8)
+                seed = seed << 6;
+            else  // Assuming 32 bit arch. If not, well, there will be
+                  // more hash collisions but it still should run OK
+                seed = seed << 3;
+            seed ^= conf[i];
+        }
+        return seed;
+    };
+};
+
+
+class ConfEqual
+{
+ private:
+    int size;
+
+ public:
+    explicit ConfEqual(int dim);
+
+    inline bool operator()(const int* conf1, const int* conf2) const
+    {
+        // The memcmp() function returns zero if the two strings are identical, oth-
+        // erwise returns the difference between the first two differing bytes
+        // (treated as unsigned char values, so that `\200' is greater than `\0',
+        // for example).  Zero-length strings are always identical.  This behavior
+        // is not required by C and portable code should only depend on the sign of
+        // the returned value.
+        //                                          sacred man of memcmp.
+        return memcmp(conf1, conf2, size) == 0;
+    }
+};
+
+
+class ConfOrder
+{
+// configurations comparator
+ public:
+    inline bool operator()(void* conf1, void* conf2) const
+    {
+        return *reinterpret_cast<double*>(conf1) < *reinterpret_cast<double*>(conf2);
+    };
+};
+
+
+
+class ConfOrderMarginal
+{
+// configurations comparator
+    const double*  logProbs;
+    int dim;
+ public:
+    ConfOrderMarginal(const double* logProbs, int dim);
+
+    inline bool operator()(const Conf conf1, const Conf conf2)
+    {
+        // Return true if conf1 is less probable than conf2.
+        return unnormalized_logProb(conf1, logProbs, dim) < unnormalized_logProb(conf2, logProbs, dim);
+    };
+};
+
+class ConfOrderMarginalDescending
+{
+// configurations comparator
+    const double*  logProbs;
+    int dim;
+ public:
+    ConfOrderMarginalDescending(const double* logProbs, int dim);
+
+    inline bool operator()(const Conf conf1, const Conf conf2)
+    {
+        // Return true if conf1 is less probable than conf2.
+        return unnormalized_logProb(conf1, logProbs, dim) > unnormalized_logProb(conf2, logProbs, dim);
+    };
+};
+
+template<typename T> class ReverseOrder
+{
+ public:
+    inline ReverseOrder() {}
+    inline bool operator()(const T a, const T b) const { return a > b; }
+};
+
+template<typename T> class TableOrder
+{
+        const T* tbl;
+ public:
+        inline explicit TableOrder(const T* _tbl) : tbl(_tbl) {}
+        inline bool operator()(size_t i, size_t j) { return tbl[i] < tbl[j]; }
+};
+
+}  // namespace IsoSpec
+
+#include "marginalTrek++.h"
+
+class PrecalculatedMarginal;  // In case marginalTrek++.h us including us, and can't be included again...
+
+namespace IsoSpec
+{
+
+template<typename T> class OrderMarginalsBySizeDecresing
+{
+    T const* const* const MT;
+ public:
+    explicit OrderMarginalsBySizeDecresing(T const* const * const MT_) : MT(MT_) {};
+    inline bool operator()(size_t m1, size_t m2) { return MT[m1]->get_no_confs() > MT[m2]->get_no_confs(); }
+};
+
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/platform.h

@@ -0,0 +1,180 @@
+/*
+ *   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_incl.h"
+
+#if defined(__unix__) || defined(__unix) || \
+        (defined(__APPLE__) && defined(__MACH__))
+#define ISOSPEC_TEST_WE_ARE_ON_UNIX_YAY true
+#define ISOSPEC_TEST_WE_ARE_ON_WINDOWS false /* CYGWIN doesn't really count as Windows for our purposes, we'll be using UNIX API anyway */
+#define ISOSPEC_TEST_GOT_SYSTEM_MMAN true
+#define ISOSPEC_TEST_GOT_MMAN true
+#elif defined(__MINGW32__) || defined(_WIN32)
+#define ISOSPEC_TEST_WE_ARE_ON_UNIX_YAY false
+#define ISOSPEC_TEST_WE_ARE_ON_WINDOWS true
+#define ISOSPEC_TEST_GOT_SYSTEM_MMAN false
+#define ISOSPEC_TEST_GOT_MMAN true
+#else
+#define ISOSPEC_TEST_WE_ARE_ON_UNIX_YAY false /* Well, probably... */
+#define ISOSPEC_TEST_WE_ARE_ON_WINDOWS false
+#define ISOSPEC_TEST_GOT_SYSTEM_MMAN false
+#define ISOSPEC_TEST_GOT_MMAN false
+#endif
+
+#if !defined(ISOSPEC_WE_ARE_ON_UNIX_YAY)
+#define ISOSPEC_WE_ARE_ON_UNIX_YAY ISOSPEC_TEST_WE_ARE_ON_UNIX_YAY
+#endif
+
+#if !defined(ISOSPEC_WE_ARE_ON_WINDOWS)
+#define ISOSPEC_WE_ARE_ON_WINDOWS ISOSPEC_TEST_WE_ARE_ON_WINDOWS
+#endif
+
+#if !defined(ISOSPEC_GOT_SYSTEM_MMAN)
+#define ISOSPEC_GOT_SYSTEM_MMAN ISOSPEC_TEST_GOT_SYSTEM_MMAN
+#endif
+
+#if !defined(ISOSPEC_GOT_MMAN)
+#define ISOSPEC_GOT_MMAN ISOSPEC_TEST_GOT_MMAN
+#endif
+
+
+// Note: __GNUC__ is defined by clang and gcc
+#ifdef __GNUC__
+#define ISOSPEC_IMPOSSIBLE(condition) if(condition) __builtin_unreachable();
+#define ISOSPEC_LIKELY(condition) __builtin_expect(static_cast<bool>(condition), 1)
+#define ISOSPEC_UNLIKELY(condition) __builtin_expect(static_cast<bool>(condition), 0)
+// For aggressive inlining
+#define ISOSPEC_FORCE_INLINE __attribute__ ((always_inline)) inline
+#elif defined _MSC_VER
+#define ISOSPEC_IMPOSSIBLE(condition) __assume(!(condition));
+#define ISOSPEC_LIKELY(condition) condition
+#define ISOSPEC_UNLIKELY(condition) condition
+#define ISOSPEC_FORCE_INLINE __forceinline
+#else
+#define ISOSPEC_IMPOSSIBLE(condition)
+#define ISOSPEC_LIKELY(condition) condition
+#define ISOSPEC_UNLIKELY(condition) condition
+#define ISOSPEC_FORCE_INLINE inline
+#endif
+
+#ifdef ISOSPEC_DEBUG
+#undef ISOSPEC_IMPOSSIBLE
+#include <cassert>
+#define ISOSPEC_IMPOSSIBLE(condition) assert(!(condition));
+#endif /* ISOSPEC_DEBUG */
+
+
+#if ISOSPEC_GOT_MMAN
+    #if ISOSPEC_GOT_SYSTEM_MMAN
+        #include <sys/mman.h>
+    #else
+        #include "mman.h"
+    #endif
+#else
+    #include <stdlib.h>     /* malloc, free, rand */
+#endif
+
+
+#if defined(OPENMS_DLLAPI) /* IsoSpec is being built as a part of OpenMS: use their visibility macros */
+#define ISOSPEC_EXPORT_SYMBOL OPENMS_DLLAPI
+#else /* it's a can of worms we don't yet want to open ourselves though... */
+#define ISOSPEC_EXPORT_SYMBOL
+#endif
+
+#if (defined(_WIN32) || defined(_WIN64)) && !defined(MXE)
+#define ISOSPEC_C_API __declspec(dllexport)
+#else
+#define ISOSPEC_C_API
+#endif
+
+#if !defined(__cpp_if_constexpr)
+#define constexpr_if if
+#define ISOSPEC_MAYBE_UNUSED
+#else
+#define constexpr_if if constexpr
+#define ISOSPEC_MAYBE_UNUSED [[maybe_unused]]
+#endif
+
+
+/* Is this an x86 target, i.e. one where several instruction-set levels exist to
+   choose between at run time? Everywhere else there is nothing to dispatch on:
+   on AArch64, NEON is architecturally guaranteed and is what the baseline
+   kernels already compile to. */
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+#define ISOSPEC_ISA_BUILD_X86 1
+#else
+#define ISOSPEC_ISA_BUILD_X86 0
+#endif
+
+/* Build several instruction-set levels of the batched kernels into the binary
+   and pick one at run time? Off by default, so a plain `c++ unity-build.cpp`
+   (and the R package, which compiles its own sources under CRAN's flags) keeps
+   the single-level behaviour; the Makefile, the CMake builds and the Python
+   wheel all turn it on. Turning it on requires the isa_kernels_*.cpp files to
+   be compiled and linked in -- see isa_kernels.h. */
+#if !defined(ISOSPEC_ISA_DISPATCH)
+#define ISOSPEC_ISA_DISPATCH 0
+#endif
+
+// C++-only from here on: cwrapper.h includes this header, and that one must
+// stay includable from a C translation unit (it is the C ABI's header).
+#ifdef __cplusplus
+
+#include <cstddef>  // std::size_t, used below whether or not SIMD is available
+
+#ifdef __has_include
+    // Deliberately NOT preferring <simd>: the standardized std::simd (P1928,
+    // landing piecemeal in libstdc++/libc++) does not expose the experimental
+    // TS's native_simd alias, so __has_include(<simd>) can be true while the
+    // header provides none of the API this codebase uses. GCC 16's <simd> is
+    // exactly this case (compiles under -std=c++2c, not under our -std=c++20)
+    // and silently broke the macOS build when given priority here. Revisit
+    // once std::simd's actual shipped API is verified against our usage.
+    //
+    // Also exclude libc++ (_LIBCPP_VERSION) explicitly: on Apple Clang,
+    // __has_include(<experimental/simd>) is true -- the header exists -- but
+    // it doesn't define std::experimental::native_simd, so the include below
+    // compiles yet fails at the alias/constexpr lines just past it. Measured
+    // on spot (Apple clang 21 / macOS 26): the same TU builds fine with
+    // Homebrew g++-16 (real libstdc++), so this is specifically a libc++
+    // limitation, not a general Apple/arm64 one -- use Homebrew GCC there
+    // instead if the SIMD path matters.
+    #if __has_include(<experimental/simd>) && !defined(_LIBCPP_VERSION)
+        #define ISOSPEC_HAS_SIMD 1
+        #include <experimental/simd>
+        namespace simd_ns = std::experimental;
+        using simd_double = simd_ns::native_simd<double>;
+    #endif
+#endif
+
+#if !defined(ISOSPEC_HAS_SIMD)
+    #define ISOSPEC_HAS_SIMD 0
+#endif
+
+// Alignment for the double arrays the batched kernels read and write.
+//
+// Deliberately a constant, and not alignof(native_simd<double>): with runtime
+// ISA dispatch the kernel that ends up running is chosen from the CPU, not from
+// the -march this translation unit saw, so the layout has to satisfy the widest
+// kernel that could be selected -- 64 bytes, for AVX-512's 8 doubles. Anything
+// derived from the ambient -march would under-align the arrays for a wider
+// kernel. (It is also a cache line on every target we build for, which the
+// arrays want anyway.)
+constexpr std::size_t DOUBLE_SIMD_ALIGNMENT = 64;
+
+#endif  /* __cplusplus */

IsoSpecPy/IsoSpec++/platform_incl.h

@@ -0,0 +1,33 @@
+/*
+ *   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
+
+#if !defined(ISOSPEC_BUILDING_R)
+#define ISOSPEC_BUILDING_R false
+#endif
+
+#if !defined(ISOSPEC_BUILDING_CPP)
+#define ISOSPEC_BUILDING_CPP true
+#endif
+
+#if !defined(ISOSPEC_BUILDING_PYTHON)
+#define ISOSPEC_BUILDING_PYTHON false
+#endif
+
+#if !defined(ISOSPEC_BUILDING_OPENMS)
+#define ISOSPEC_BUILDING_OPENMS false
+#endif