IsoSpecPy 2.3.4__tar.gz → 2.4.0__tar.gz

isospecpy-2.4.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: IsoSpecPy
+Version: 2.4.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
+
+IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
+
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+
+## Installation
+
+### Python
+
+```bash
+pip install IsoSpecPy
+```
+
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.6.
+
+To build from source: `pip install .` from a checkout. A C++20 compiler is required.
+
+### R
+
+```r
+install.packages("IsoSpecR")
+```
+
+From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
+
+### C++ library
+
+```bash
+cd src/IsoSpec++
+make            # produces libIsoSpec++.so
+```
+
+Or via CMake from the repo root:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+sudo cmake --install build
+```
+
+Requires a C++20 compiler. CMake produces both shared and static libraries and installs headers under `${CMAKE_INSTALL_INCLUDEDIR}/IsoSpec++`.
+
+## Quick start
+
+The most common usage is `IsoTotalProb`: ask for the smallest set of isotopologues whose summed probability covers a chosen fraction of the spectrum (typically 0.99–0.9999). The result is a materialized envelope — arrays of masses and probabilities you can read directly.
+
+### Python
+
+```python
+import IsoSpecPy
+
+# Isotopologues covering at least 99.9% of the probability mass of water.
+iso = IsoSpecPy.IsoTotalProb(formula="H2O1", prob_to_cover=0.999)
+
+for mass, prob in zip(iso.masses, iso.probs):
+    print(mass, prob)
+
+# From an amino-acid FASTA sequence:
+iso = IsoSpecPy.IsoTotalProb(fasta="AAAPPGQAAC", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+```
+
+See `Examples/Python/` for radiolabelling, custom elements, binned spectra, and FASTA modifications.
+
+### C++
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb("H2O1", 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+Quickest way to build:
+
+```bash
+clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
+```
+
+(`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
+
+### R
+
+```r
+library(IsoSpecR)
+water <- c(H = 2, O = 1)
+IsoSpecify(molecule = water, stopCondition = 0.999)
+```
+
+See `Examples/R/` for radiolabelling and full-spectrum extraction.
+
+## Advanced features
+
+- **Alternative algorithms** — for cases where `IsoTotalProb` isn't the right shape:
+  - `IsoThreshold` — all isotopologues with probability above a fixed threshold.
+  - `IsoStochastic` — simulate a measured spectrum by sampling integer ion counts.
+  - `IsoBinned` — histogram-style envelope at a chosen bin width.
+- **FASTA support** — build an `Iso` directly from an amino-acid sequence; optionally include the N/C-terminal water.
+- **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+
+Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
+
+## Repository layout
+
+```
+src/IsoSpec++/    C++ core library (the algorithms live here)
+src/IsoSpecPy/    Python binding, loaded via cffi
+src/IsoSpecR/     R binding, via Rcpp
+Examples/         Working examples in each language
+tests/            C, C++, and Python test suites
+skbuild/          scikit-build-core entry point used when installing the Python wheel
+```
+
+## Citation
+
+If IsoSpec is useful in your research, please cite:
+
+- Łącki, M. K.; Valkenborg, D.; Startek, M. P. *IsoSpec2: Ultrafast Fine Structure Calculator.* Analytical Chemistry **2020**, *92* (14), 9472–9475. <https://doi.org/10.1021/acs.analchem.0c00959>
+- Łącki, M. K.; Startek, M.; Valkenborg, D.; Gambin, A. *IsoSpec: Hyperfast Fine Structure Calculator.* Analytical Chemistry **2017**, *89* (6), 3272–3277. <https://doi.org/10.1021/acs.analchem.6b01459>
+
+The Supporting Information of each paper has the algorithmic detail.
+
+## License
+
+2-clause BSD (see `LICENCE`). If you need different licensing terms, contact the authors. The authors appreciate (but do not require) being told when IsoSpec is used in other software.

isospecpy-2.4.0/README.md

@@ -0,0 +1,137 @@
+# IsoSpec
+
+IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
+
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+
+## Installation
+
+### Python
+
+```bash
+pip install IsoSpecPy
+```
+
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.6.
+
+To build from source: `pip install .` from a checkout. A C++20 compiler is required.
+
+### R
+
+```r
+install.packages("IsoSpecR")
+```
+
+From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
+
+### C++ library
+
+```bash
+cd src/IsoSpec++
+make            # produces libIsoSpec++.so
+```
+
+Or via CMake from the repo root:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+sudo cmake --install build
+```
+
+Requires a C++20 compiler. CMake produces both shared and static libraries and installs headers under `${CMAKE_INSTALL_INCLUDEDIR}/IsoSpec++`.
+
+## Quick start
+
+The most common usage is `IsoTotalProb`: ask for the smallest set of isotopologues whose summed probability covers a chosen fraction of the spectrum (typically 0.99–0.9999). The result is a materialized envelope — arrays of masses and probabilities you can read directly.
+
+### Python
+
+```python
+import IsoSpecPy
+
+# Isotopologues covering at least 99.9% of the probability mass of water.
+iso = IsoSpecPy.IsoTotalProb(formula="H2O1", prob_to_cover=0.999)
+
+for mass, prob in zip(iso.masses, iso.probs):
+    print(mass, prob)
+
+# From an amino-acid FASTA sequence:
+iso = IsoSpecPy.IsoTotalProb(fasta="AAAPPGQAAC", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+```
+
+See `Examples/Python/` for radiolabelling, custom elements, binned spectra, and FASTA modifications.
+
+### C++
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb("H2O1", 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+Quickest way to build:
+
+```bash
+clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
+```
+
+(`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
+
+### R
+
+```r
+library(IsoSpecR)
+water <- c(H = 2, O = 1)
+IsoSpecify(molecule = water, stopCondition = 0.999)
+```
+
+See `Examples/R/` for radiolabelling and full-spectrum extraction.
+
+## Advanced features
+
+- **Alternative algorithms** — for cases where `IsoTotalProb` isn't the right shape:
+  - `IsoThreshold` — all isotopologues with probability above a fixed threshold.
+  - `IsoStochastic` — simulate a measured spectrum by sampling integer ion counts.
+  - `IsoBinned` — histogram-style envelope at a chosen bin width.
+- **FASTA support** — build an `Iso` directly from an amino-acid sequence; optionally include the N/C-terminal water.
+- **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+
+Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
+
+## Repository layout
+
+```
+src/IsoSpec++/    C++ core library (the algorithms live here)
+src/IsoSpecPy/    Python binding, loaded via cffi
+src/IsoSpecR/     R binding, via Rcpp
+Examples/         Working examples in each language
+tests/            C, C++, and Python test suites
+skbuild/          scikit-build-core entry point used when installing the Python wheel
+```
+
+## Citation
+
+If IsoSpec is useful in your research, please cite:
+
+- Łącki, M. K.; Valkenborg, D.; Startek, M. P. *IsoSpec2: Ultrafast Fine Structure Calculator.* Analytical Chemistry **2020**, *92* (14), 9472–9475. <https://doi.org/10.1021/acs.analchem.0c00959>
+- Łącki, M. K.; Startek, M.; Valkenborg, D.; Gambin, A. *IsoSpec: Hyperfast Fine Structure Calculator.* Analytical Chemistry **2017**, *89* (6), 3272–3277. <https://doi.org/10.1021/acs.analchem.6b01459>
+
+The Supporting Information of each paper has the algorithmic detail.
+
+## License
+
+2-clause BSD (see `LICENCE`). If you need different licensing terms, contact the authors. The authors appreciate (but do not require) being told when IsoSpec is used in other software.

isospecpy-2.4.0/VERSION

@@ -0,0 +1 @@
+2.4.0

{isospecpy-2.3.4 → isospecpy-2.4.0}/pyproject.toml

@@ -2,6 +2,15 @@
 requires = ["setuptools", "scikit-build-core"]
 build-backend = "scikit_build_core.build"
 
+# Single source of truth for the version: the VERSION file at the top of the
+# tree, which CMakeLists.txt reads too (see the note there). Keep that file to
+# one bare version number on one line.
+[[tool.dynamic-metadata]]
+field = "version"
+provider = "scikit_build_core.metadata.regex"
+input = "VERSION"
+regex = "^\\s*(?P<value>[0-9]+(?:\\.[0-9]+)*)"
+
 [tool.scikit-build]
 cmake.source-dir = "skbuild"
 
@@ -9,7 +18,7 @@ cmake.source-dir = "skbuild"
 name = "IsoSpecPy"
 dependencies = ["cffi"]
 description = "IsoSpecPy is a Python library for computing isotopic distributions of molecules."
-version = "2.3.4"
+dynamic = ["version"]
 license = "BSD-2-Clause"
 license-files = ["LICENCE"]
 authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]
@@ -38,11 +47,17 @@ testpaths = ["tests/Python"]
 
 [tool.cibuildwheel]
 enable = ["pypy"]
-skip = ["cp36-*", "cp37-*", "pp37-*"]
-test-command = "python -m pytest {project}/tests/Python"
+test-command = "python -m pytest -o faulthandler_timeout=600 {project}/tests/Python"
 #test-sources = ["tests/Python"]
 test-extras = ["testing"]
 
+# Apple Clang's libc++ has no <experimental/simd>; build with Homebrew GCC instead.
+[tool.cibuildwheel.macos]
+before-all = "brew install gcc"
+# NB: cibuildwheel evaluates these with bashlex, which supports command
+# substitution but *not* pipelines - hence the `sh -c` wrapper.
+environment = { CC = "$(sh -c 'ls $(brew --prefix gcc)/bin/gcc-* | sort -V | tail -1')", CXX = "$(sh -c 'ls $(brew --prefix gcc)/bin/g++-* | sort -V | tail -1')" }
+
 [tool.scikit-build.sdist]
 exclude = ["**/*"]
 include = [
@@ -51,6 +66,10 @@ include = [
     "/src/IsoSpec++/*.h",
     "/src/IsoSpec++/*.hpp",
     "/src/IsoSpec++/*.cpp",
+    # skbuild/CMakeLists.txt include()s IsaDispatch.cmake; without this the
+    # sdist configures no further than that line.
+    "/src/IsoSpec++/*.cmake",
+    "/VERSION",
     "/LICENCE",
     "/README.md",
     "/pyproject.toml",

isospecpy-2.4.0/skbuild/CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(IsoSpecPy CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+#find_package(PythonExtensions REQUIRED)
+#find_package(Python COMPONENTS Interpreter Development REQUIRED)
+
+# Runtime ISA dispatch. This matters most here: the wheel is built with no
+# -march at all, so without it every user gets the x86-64 baseline -- 2-double
+# vectors -- no matter what their CPU can do.
+include(${CMAKE_CURRENT_LIST_DIR}/../src/IsoSpec++/IsaDispatch.cmake)
+
+add_library(IsoSpecCppPy SHARED ../src/IsoSpec++/unity-build.cpp ${isospec_ISA_SRCS})
+target_compile_features(IsoSpecCppPy PRIVATE cxx_std_20)
+
+# macOS wheels are built with Homebrew GCC (Apple's libc++ has no
+# <experimental/simd>), and Homebrew bottles its libstdc++.6.dylib for the
+# *current* macOS -- minos 26.0 today. delocate refuses to bundle a dylib whose
+# minimum target is newer than the wheel's (11.0 on arm64), and hard-fails the
+# build. Linking the C++ runtime statically leaves libSystem as the only
+# dependency, so there is nothing for delocate to reject. The
+# "built for newer macOS version" warnings this draws from ld are the archive
+# members' own load commands and are harmless.
+#
+# Plain -static-libstdc++ is not enough, though: the archive members keep
+# default visibility, so the dylib would re-export ~2000 libstdc++ symbols.
+# Mach-O coalesces weak definitions (templates, inline functions, vtables)
+# across *all* loaded images regardless of two-level namespace, so a process
+# that also loads anything built against Homebrew's libstdc++.6.dylib ends up
+# with two copies of that runtime spliced together and aborts inside dlopen --
+# silently, with no dyld message and nothing Python can catch. A seven-line
+# extension whose static initialiser touches std::locale is enough to trigger
+# it; OldIsoSpecPy, which the wheel test suite installs, is one such consumer.
+# -load_hidden links the archive with all of its symbols hidden, so our private
+# copy of the runtime stays private. It replaces -static-libstdc++ (which would
+# otherwise pull the same archive in again, visibly).
+if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libstdc++.a
+                  OUTPUT_VARIABLE ISOSPEC_LIBSTDCXX_A
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(NOT IS_ABSOLUTE "${ISOSPEC_LIBSTDCXX_A}" OR NOT EXISTS "${ISOSPEC_LIBSTDCXX_A}")
+    message(FATAL_ERROR
+      "${CMAKE_CXX_COMPILER} could not locate a static libstdc++.a "
+      "(-print-file-name returned '${ISOSPEC_LIBSTDCXX_A}'). The macOS wheel "
+      "needs one: linking libstdc++ dynamically makes delocate reject the "
+      "Homebrew bottle, and linking it visibly breaks other libstdc++ users "
+      "in the same process.")
+  endif()
+  # -load_hidden needs a reasonably modern ld64; an older one rejects the
+  # option outright, which is a loud failure rather than a silent regression.
+  #
+  # The archive is only half of it: our own translation units instantiate std::
+  # templates (std::to_string, sorts, the Mersenne twister), and those weak
+  # definitions coalesce across images just as readily. std:: is not part of
+  # this library's ABI -- callers reach it through cwrapper's extern "C"
+  # interface -- so none of it has any business being exported.
+  # tests/Python/test_cxx_runtime.py fails if any of this comes undone.
+  target_link_options(IsoSpecCppPy PRIVATE
+    -static-libgcc "-Wl,-load_hidden,${ISOSPEC_LIBSTDCXX_A}"
+    "-Wl,-unexported_symbol,__ZNSt*" "-Wl,-unexported_symbol,__ZNKSt*"
+    "-Wl,-unexported_symbol,__ZSt*")
+endif()
+#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.4.0/src/IsoSpec++/IsaDispatch.cmake

@@ -0,0 +1,78 @@
+# Runtime ISA dispatch, for the CMake builds.
+#
+# The two batched fill kernels are compiled once per instruction-set level, each
+# into its own translation unit with its own -march, and the one to run is chosen
+# from the CPU at startup. They must never share a compilation with the rest of
+# the library: a raised -march would otherwise reach every inline function in the
+# headers, and the linker could then pick an AVX-512 copy of one for a code path
+# reached on a CPU without it. See isa_kernels.h for the full reasoning.
+#
+# Include this, then add ${isospec_ISA_SRCS} to your target's sources. It sets
+# the per-source flags and defines ISOSPEC_ISA_DISPATCH=1 for the directory.
+#
+# The kernel sources deliberately get no -march of their own beyond the level
+# they implement: the baseline level has to stay runnable on any CPU of the
+# target architecture, since it is what dispatch falls back to.
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+set(_isa_dir ${CMAKE_CURRENT_LIST_DIR})
+
+# Worth turning off when building exclusively for the machine that will run the
+# result (-march=native, say): dispatching costs an indirect call per marginal-0
+# run -- measured at 0.5-3% on the binned fill and 2-7% on the threshold fill --
+# which a single-level build compiled for the actual CPU does not pay.
+option(ISOSPEC_ISA_DISPATCH "Build several instruction-set levels and select at run time" ON)
+
+if(NOT ISOSPEC_ISA_DISPATCH)
+	set(isospec_ISA_SRCS "")
+	message(STATUS "IsoSpec: runtime ISA dispatch disabled; single-level build")
+	return()
+endif()
+
+set(isospec_ISA_SRCS
+	${_isa_dir}/isa_kernels_baseline.cpp
+	${_isa_dir}/isa_kernels_avx.cpp
+	${_isa_dir}/isa_kernels_v3.cpp
+	${_isa_dir}/isa_kernels_v4.cpp
+	)
+
+set(_isa_avx_flags -mavx)
+set(_isa_v3_flags -mavx2 -mfma)
+set(_isa_v4_flags -mavx512f -mavx512bw -mavx512dq -mavx512vl)
+
+# Only offer a level its flags where the compiler will take them; they are
+# meaningless off x86, and older toolchains may not know the AVX-512 ones. The
+# .cpp files then self-check the predefined macros those flags produce, so a
+# level whose flags did not arrive publishes an empty table and dispatch simply
+# never selects it -- rather than it being quietly built at the wrong width.
+check_cxx_compiler_flag("-mavx" ISOSPEC_CXX_ACCEPTS_AVX)
+check_cxx_compiler_flag("-mavx2 -mfma" ISOSPEC_CXX_ACCEPTS_V3)
+check_cxx_compiler_flag("-mavx512f -mavx512bw -mavx512dq -mavx512vl" ISOSPEC_CXX_ACCEPTS_V4)
+
+if(ISOSPEC_CXX_ACCEPTS_AVX)
+	set_source_files_properties(${_isa_dir}/isa_kernels_avx.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_avx_flags}")
+	message(STATUS "IsoSpec: building ISA level avx (AVX, no FMA)")
+else()
+	message(STATUS "IsoSpec: ISA level avx not available with this compiler/target")
+endif()
+
+if(ISOSPEC_CXX_ACCEPTS_V3)
+	set_source_files_properties(${_isa_dir}/isa_kernels_v3.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_v3_flags}")
+	message(STATUS "IsoSpec: building ISA level v3 (AVX2+FMA)")
+else()
+	message(STATUS "IsoSpec: ISA level v3 not available with this compiler/target")
+endif()
+
+if(ISOSPEC_CXX_ACCEPTS_V4)
+	set_source_files_properties(${_isa_dir}/isa_kernels_v4.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_v4_flags}")
+	message(STATUS "IsoSpec: building ISA level v4 (AVX-512)")
+else()
+	message(STATUS "IsoSpec: ISA level v4 not available with this compiler/target")
+endif()
+
+add_definitions(-DISOSPEC_ISA_DISPATCH=1)