kernelforge 0.1.2__tar.gz

kernelforge-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  test:
+    name: pytest (${{ matrix.os }} / py${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04]   # add 'windows-2022' if desired
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Cache pip
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: pip-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('pyproject.toml') }}
+
+      # macOS: Accelerate, Linux: OpenBLAS from system or wheels; keep it simple for CI
+      - name: Install build deps
+        run: |
+          python -m pip install -U pip
+          python -m pip install -U build ".[test]"
+          # Optional: OpenBLAS dev on Ubuntu if you link system BLAS
+          if [[ "$RUNNER_OS" == "Linux" ]]; then sudo apt-get update && sudo apt-get install -y libopenblas-dev; fi
+
+      - name: Build & install (editable)
+        env:
+          # Make MKL/OpenBLAS behave in CI
+          OMP_NUM_THREADS: "1"
+          MKL_NUM_THREADS: "1"
+          MKL_THREADING_LAYER: "SEQUENTIAL"
+          MKL_INTERFACE_LAYER: "LP64"
+        run: |
+          python -m pip install -e . -v
+
+      - name: Pytest (fast)
+        env:
+          OMP_NUM_THREADS: "1"
+          MKL_NUM_THREADS: "1"
+          MKL_THREADING_LAYER: "SEQUENTIAL"
+          MKL_INTERFACE_LAYER: "LP64"
+        run: |
+          pytest -q -ra -k "not slow" -x

kernelforge-0.1.2/.github/workflows/release.yaml

@@ -0,0 +1,74 @@
+# .github/workflows/release.yml
+name: Build & Publish
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build-wheels:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04] # macos-14]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"   # host Python, cibuildwheel makes all others
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==2.*
+
+      - name: Build wheels
+        env:
+          CIBW_BUILD: "cp312-*"
+          CIBW_SKIP: "pp* *-musllinux_* cp*-manylinux_i686"
+          CIBW_TEST_COMMAND: "pytest -q {project}/tests -k 'not slow' -x"
+          CIBW_TEST_EXTRAS: "test"
+          CIBW_ENVIRONMENT: >
+            OMP_NUM_THREADS=1
+            OPENBLAS_NUM_THREADS=1
+          CIBW_BEFORE_BUILD_LINUX: |
+            curl -L https://anaconda.org/multibuild-wheels-staging/openblas-libs/v0.3.27/download/openblas-v0.3.27-manylinux2014_x86_64.tar.gz | tar xz
+            cp -r usr /opt/openblas
+            ls -l /opt/openblas/local/lib/libopenblas.so
+          CIBW_ENVIRONMENT_LINUX: >
+            LD_LIBRARY_PATH=/opt/openblas/local/lib:$LD_LIBRARY_PATH
+            CMAKE_ARGS="-DBLAS_LIBRARIES=/opt/openblas/local/lib/libopenblas.so -DBLAS_INCLUDE_DIR=/opt/openblas/local/include -DBLAS_VENDOR=OpenBLAS"
+            OPENBLAS_NUM_THREADS=1
+            OMP_NUM_THREADS=1
+          CIBW_ENVIRONMENT_PASS_LINUX: >
+            LD_LIBRARY_PATH
+            CMAKE_ARGS
+            OPENBLAS_NUM_THREADS
+            OMP_NUM_THREADS
+        run: python -m cibuildwheel --output-dir wheelhouse
+
+      - name: Build sdist
+        run: python -m pip install build && python -m build --sdist -o wheelhouse
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: wheelhouse/*
+
+  publish:
+    needs: build-wheels
+    runs-on: ubuntu-22.04
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@v1.11.0
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+

kernelforge-0.1.2/.gitignore

@@ -0,0 +1,210 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+CMakeFiles/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+CMakeCache.txt
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

kernelforge-0.1.2/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.18)
+project(kernelforge LANGUAGES C CXX Fortran)
+
+# Python + pybind11
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(pybind11 CONFIG REQUIRED)
+
+# Fortran kernels as an object library (for linking into the Python module)
+add_library(kf_fortran OBJECT src/kernel.f90)
+set_property(TARGET kf_fortran PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+# Build the Python extension module via pybind11 and link the Fortran objects
+pybind11_add_module(_kernelforge MODULE
+    src/bindings.cpp
+    $<TARGET_OBJECTS:kf_fortran>
+)
+# Ensure the built filename is exactly "_kernelforge.*"
+set_target_properties(_kernelforge PROPERTIES OUTPUT_NAME "_kernelforge")
+
+# Optional: OpenMP for Fortran if you use it
+find_package(OpenMP)
+if (OpenMP_Fortran_FOUND)
+  target_link_libraries(_kernelforge PRIVATE OpenMP::OpenMP_Fortran)
+endif()
+
+# Optional BLAS/LAPACK backends (enable later if needed)
+if(APPLE)
+  find_library(ACCELERATE Accelerate REQUIRED)
+  target_link_libraries(_kernelforge PRIVATE ${ACCELERATE})
+elseif(WIN32)
+  find_package(MKL CONFIG REQUIRED)
+  target_link_libraries(_kernelforge PRIVATE MKL::MKL)
+else()
+  find_package(BLAS REQUIRED)
+  target_link_libraries(_kernelforge PRIVATE BLAS::BLAS)
+endif()
+
+# Conservative optimization flags (portable wheels). Override via env if you want.
+if (CMAKE_Fortran_COMPILER_ID STREQUAL "IntelLLVM" OR CMAKE_Fortran_COMPILER_ID STREQUAL "Intel")
+  target_compile_options(kf_fortran PRIVATE -O3 -ipo -xHost -fp-model fast=2 -no-prec-div -fno-alias -qopenmp)
+elseif (CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+  target_compile_options(kf_fortran PRIVATE -O3 -fopenmp -mcpu=native -mtune=native -ffast-math -ftree-vectorize)
+endif()
+
+# Install the compiled extension into the Python package and the Python shim
+install(TARGETS _kernelforge
+  LIBRARY DESTINATION kernelforge   # Linux/macOS
+  RUNTIME DESTINATION kernelforge   # Windows (.pyd)
+)
+install(FILES python/kernelforge/__init__.py DESTINATION kernelforge)
+

kernelforge-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anders Steen Christensen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kernelforge-0.1.2/Makefile

@@ -0,0 +1,5 @@
+install:
+	pip install -e .[test] --verbose
+
+test:
+	pytest

kernelforge-0.1.2/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.2
+Name: kernelforge
+Version: 0.1.2
+Summary: Fortran kernels with C ABI and Python bindings (CMake/skbuild/pybind11)
+Author: Anders Christensen
+License: MIT
+Project-URL: Homepage, https://github.com/youruser/kernelforge
+Project-URL: Issues, https://github.com/youruser/kernelforge/issues
+Requires-Python: >=3.9
+Requires-Dist: numpy>=2.00
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Description-Content-Type: text/markdown
+
+# kernelforge
+Optimized kernels for ML
+
+- Without using F2PY or Meson
+
+# Installation
+
+```bash
+pip install -e .
+pytest -v -s
+```
+
+## Intel compilers and MKL
+
+GNU compilers will be used by default. If you want to use Intel compilers and MKL, you can set the environment variables:
+
+```bash
+source /opt/intel/oneapi/setvars.sh
+```
+In this case, MKL will be autodetected and used. If you additionally want to compile with Intel compilers, you can set the environment variables when running `pip install`:
+
+```bash
+CC=icx CXX=icpx FC=ifx make install
+```

kernelforge-0.1.2/README.md

@@ -0,0 +1,24 @@
+# kernelforge
+Optimized kernels for ML
+
+- Without using F2PY or Meson
+
+# Installation
+
+```bash
+pip install -e .
+pytest -v -s
+```
+
+## Intel compilers and MKL
+
+GNU compilers will be used by default. If you want to use Intel compilers and MKL, you can set the environment variables:
+
+```bash
+source /opt/intel/oneapi/setvars.sh
+```
+In this case, MKL will be autodetected and used. If you additionally want to compile with Intel compilers, you can set the environment variables when running `pip install`:
+
+```bash
+CC=icx CXX=icpx FC=ifx make install
+```

kernelforge-0.1.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["scikit-build-core>=0.9", "pybind11", "setuptools"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "kernelforge"
+version = "0.1.2"
+description = "Fortran kernels with C ABI and Python bindings (CMake/skbuild/pybind11)"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Anders Christensen"}]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=2.00",   # required at runtime
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-xdist", "pytest-cov", "pytest-timeout"]
+
+[project.urls]
+Homepage = "https://github.com/youruser/kernelforge"
+Issues = "https://github.com/youruser/kernelforge/issues"
+
+[tool.scikit-build]
+wheel.expand-macos-universal-tags = true
+wheel.py-api = "py3"
+cmake.build-type = "Release"
+cmake.verbose = true
+wheel.packages = ["python/kernelforge"]
+
+# optional: put compiled outputs under build/{tag}/ to avoid clashes
+# build-dir = "build/{wheel_tag}"
+
+[tool.scikit-build.cmake.define]
+CMAKE_VERBOSE_MAKEFILE = "ON"
+CMAKE_BUILD_TYPE = "Release"

kernelforge-0.1.2/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+addopts = -v --tb=short -rA --verbose

kernelforge-0.1.2/python/kernelforge/__init__.py

@@ -0,0 +1,2 @@
+from ._kernelforge import inverse_distance, kernel_symm_simple, kernel_symm_blas
+__all__ = ["inverse_distance", "kernel_symm_simple", "kernel_symm_blas"]

kernelforge-0.1.2/src/bindings.cpp

@@ -0,0 +1,89 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+extern "C" {
+  void compute_inverse_distance(const double* x_3_by_n, int n, double* d_packed);
+  void kernel_symm_simple(const double* x, int lda, int n, double* k, int ldk, double alpha);
+  void kernel_symm_blas(const double* x, int lda, int n, double* k, int ldk, double alpha);
+}
+
+namespace py = pybind11;
+
+py::array_t<double> inverse_distance(py::array_t<double, py::array::c_style | py::array::forcecast> X) {
+    auto buf = X.request();
+    if (buf.ndim != 2 || buf.shape[1] != 3) {
+        throw std::runtime_error("X must have shape (N,3)");
+    }
+    const int n = static_cast<int>(buf.shape[0]);
+
+    // D packed length
+    const ssize_t m = static_cast<ssize_t>(n) * (n - 1) / 2;
+    auto D = py::array_t<double>(m);
+
+    // Pass row-major (N,3) as transposed view (3,N) to Fortran without copy:
+    // NumPy will give a view; pybind11 exposes data pointer for the view.
+    py::array_t<double> XT({3, n}, {buf.strides[1], buf.strides[0]}, static_cast<double*>(buf.ptr), X);
+
+    compute_inverse_distance(static_cast<const double*>(XT.request().ptr), n,
+                                      static_cast<double*>(D.request().ptr));
+    return D;
+}
+
+py::array_t<double> kernel_symm_simple_py(
+    py::array_t<double, py::array::forcecast | py::array::f_style> X,
+    double alpha
+) {
+    // Require (rep_size, n) in Fortran order; forcecast|f_style will copy if needed.
+    auto xb = X.request();
+    if (xb.ndim != 2) {
+        throw std::runtime_error("X must be 2D with shape (rep_size, n) in column-major (Fortran) order");
+    }
+    const int lda = static_cast<int>(xb.shape[0]);
+    const int n   = static_cast<int>(xb.shape[1]);
+
+    // Allocate K as Fortran-order (n x n): stride0 = 8, stride1 = n*8
+    auto K = py::array_t<double>({n, n}, {sizeof(double), static_cast<ssize_t>(n)*sizeof(double)});
+
+    kernel_symm_simple(static_cast<const double*>(xb.ptr),
+                  lda, n,
+                  static_cast<double*>(K.request().ptr),
+                  /*ldk=*/n, alpha);
+
+    return K;
+}
+
+
+py::array_t<double> kernel_symm_blas_py(
+    py::array_t<double, py::array::forcecast | py::array::f_style> X,
+    double alpha
+) {
+    // Require (rep_size, n) in Fortran order; forcecast|f_style will copy if needed.
+    auto xb = X.request();
+    if (xb.ndim != 2) {
+        throw std::runtime_error("X must be 2D with shape (rep_size, n) in column-major (Fortran) order");
+    }
+    const int lda = static_cast<int>(xb.shape[0]);
+    const int n   = static_cast<int>(xb.shape[1]);
+
+    // Allocate K as Fortran-order (n x n): stride0 = 8, stride1 = n*8
+    auto K = py::array_t<double>({n, n}, {sizeof(double), static_cast<ssize_t>(n)*sizeof(double)});
+
+    kernel_symm_blas(static_cast<const double*>(xb.ptr),
+                  lda, n,
+                  static_cast<double*>(K.request().ptr),
+                  /*ldk=*/n, alpha);
+
+    return K;
+}
+
+PYBIND11_MODULE(_kernelforge, m) {
+    m.doc() = "kernelforge: Fortran kernels with C ABI and Python bindings";
+    m.def("inverse_distance", &inverse_distance, "Compute packed inverse distance matrix from (N,3) coordinates");
+    m.def("kernel_symm_simple", &kernel_symm_simple_py,
+      "Compute K (upper triangle) with Gaussian-like exp(alpha * ||xi-xj||^2). "
+      "X must be shape (rep_size, n), Fortran-order.");
+    m.def("kernel_symm_blas", &kernel_symm_blas_py,
+      "Compute K (upper triangle) with Gaussian-like exp(alpha * ||xi-xj||^2). "
+      "X must be shape (rep_size, n), Fortran-order.");
+
+}
+

kernelforge-0.1.2/src/kernel.f90

@@ -0,0 +1,108 @@
+module kernelforge_mod
+
+  use, intrinsic :: iso_c_binding
+  implicit none
+
+contains
+
+  ! Example kernel: inverse distance (packed upper triangle)
+subroutine compute_inverse_distance(x, n, d) bind(C, name="compute_inverse_distance")
+
+    implicit none
+
+    integer(c_int), value       :: n
+    real(c_double), intent(in)  :: x(3,n)               ! expect (3,n)
+    real(c_double), intent(out) :: d(n*(n-1)/2)         ! packed upper triangle
+
+    integer :: i, j, idx
+    real(c_double) :: dx, dy, dz, rij2, rij
+
+    idx = 0
+    do j = 2, n
+        do i = 1, j-1
+            idx = idx + 1
+            dx = x(1,i) - x(1,j)
+            dy = x(2,i) - x(2,j)
+            dz = x(3,i) - x(3,j)
+            rij2 = dx*dx + dy*dy + dz*dz
+            rij  = sqrt(rij2)
+            d(idx) = 1.0d0 / rij
+        end do
+    end do
+end subroutine compute_inverse_distance
+
+
+subroutine kernel_symm_simple(X, lda, n, K, ldk, alpha) bind(C, name="kernel_symm_simple")
+
+  integer(c_int), value       :: lda, n, ldk
+  real(c_double), intent(in)  :: X(lda, *)
+  real(c_double), intent(inout) :: K(ldk, *)
+  real(c_double), value       :: alpha
+
+  integer :: i, j, p
+  real(c_double) :: dx, rij2, dist2
+
+  !$omp parallel do private(i, j, dist2) shared(X, K, alpha, n) schedule(guided)
+  do j = 1, n
+      do i = 1, j
+          dist2 = sum((X(:, i) - X(:, j))**2)
+          K(i, j) = exp(alpha * dist2)
+      end do
+  end do
+  !$omp end parallel do
+
+end subroutine kernel_symm_simple
+
+
+subroutine kernel_symm_blas(X, lda, n, K, ldk, alpha) bind(C, name="kernel_symm_blas")
+
+  use, intrinsic :: iso_c_binding, only: c_int, c_double
+  use, intrinsic :: iso_fortran_env, only: dp => real64
+  use omp_lib
+
+  implicit none
+
+  ! C ABI args
+  integer(c_int), value        :: lda, n, ldk
+  real(c_double), intent(in)   :: X(lda,*)
+  real(c_double), intent(inout):: K(ldk,*)
+  real(c_double), value        :: alpha
+
+  ! Fortran default integers for BLAS calls
+  integer :: lda_f, n_f, ldk_f, rep_size_f
+  integer :: i, j
+  real(c_double), allocatable :: diag(:), onevec(:)
+
+  ! Copy c_int (by-value) to default INTEGERs for BLAS (expects default INTEGER by ref)
+  lda_f = int(lda)
+  n_f   = int(n)
+  ldk_f = int(ldk)
+
+  ! Rep size is the first dim of X; keep as default INTEGER
+  rep_size_f = lda_f
+
+  ! Gram matrix computation using DGEMM/DSYRK
+  call dsyrk('U', 'T', int(n), int(lda), -2.0_dp * alpha, X, int(lda), 0.0_dp, K, int(n))
+
+  allocate(diag(n_f), onevec(n_f))
+  diag(:) = -0.5_dp * [ (K(i,i), i = 1, n) ]
+  onevec(:) = 1.0_dp
+
+  ! Add the (diagonal) self-inner products the matrix to form the distance matrix
+  call dsyr2('U', n_f, 1.0_dp, onevec, 1, diag, 1, K, n_f)
+  deallocate(diag, onevec)
+
+  ! EXP double loop is fast compared to dsyrk anyway.
+  !$omp parallel do private(i, j) shared(K, n) schedule(guided)
+  do j = 1, n
+      do i = 1, j
+          K(i, j) = exp(K(i, j))
+      end do
+  end do
+  !$omp end parallel do
+
+end subroutine kernel_symm_blas
+
+
+end module kernelforge_mod
+

kernelforge-0.1.2/tests/test_basic.py

@@ -0,0 +1,99 @@
+import numpy as np
+from time import time
+import kernelforge as kf
+import pytest
+
+def test_inverse_distance_shapes():
+    X = np.random.rand(5, 3)
+    D = kf.inverse_distance(X)
+    assert D.shape == (5*4//2,)
+
+
+def test_kernel_simple_runs():
+    rep, n = 512, 64
+    rng = np.random.default_rng(0)
+    X = np.asfortranarray(rng.random((rep, n)))
+    alpha = -1.0 / rep
+
+    K = kf.kernel_symm_simple(X, alpha)
+    assert K.shape == (n, n)
+
+    # Symmetrize since only upper triangle is written
+    iu = np.triu_indices(n, 1)
+    K[(iu[1], iu[0])] = K[iu]
+    # Check diagonal ~ 1.0
+    assert np.allclose(np.diag(K), 1.0)
+
+    # Off-diagonal entries should be between 0 and 1
+    off_diag = K[iu]
+    assert np.all((off_diag >= 0.0) & (off_diag <= 1.0))
+
+
+def test_kernel_blas_runs():
+    rep, n = 512, 64
+    rng = np.random.default_rng(0)
+    X = np.asfortranarray(rng.random((rep, n)))
+    alpha = -1.0 / rep
+
+    K = kf.kernel_symm_blas(X, alpha)
+    assert K.shape == (n, n)
+
+    # Symmetrize since only upper triangle is written
+    iu = np.triu_indices(n, 1)
+    K[(iu[1], iu[0])] = K[iu]
+
+    # Check diagonal ~ 1.0
+    assert np.allclose(np.diag(K), 1.0)
+
+    # Off-diagonal entries should be between 0 and 1
+    off_diag = K[iu]
+    assert np.all((off_diag >= 0.0) & (off_diag <= 1.0))
+
+@pytest.mark.slow
+def test_kernel_simple_time():
+    rep, n = 512, 16000
+    rng = np.random.default_rng(0)
+    X = np.asfortranarray(rng.random((rep, n)))
+    alpha = -1.0 / rep
+
+    start = time()
+    K = kf.kernel_symm_simple(X, alpha)
+    end = time()
+    print(f"Kernel SIMPLE took {end - start:.2f} seconds for {n} points.")
+    assert K.shape == (n, n)
+
+    # Symmetrize since only upper triangle is written
+    iu = np.triu_indices(n, 1)
+    K[(iu[1], iu[0])] = K[iu]
+    # Check diagonal ~ 1.0
+    assert np.allclose(np.diag(K), 1.0)
+
+    # Off-diagonal entries should be between 0 and 1
+    off_diag = K[iu]
+    assert np.all((off_diag >= 0.0) & (off_diag <= 1.0))
+
+
+@pytest.mark.slow
+def test_kernel_blas_time():
+    rep, n = 512, 16000
+    rng = np.random.default_rng(0)
+    X = np.asfortranarray(rng.random((rep, n)))
+    alpha = -1.0 / rep
+
+    start = time()
+    K = kf.kernel_symm_blas(X, alpha)
+
+    end = time()
+    print(f"Kernel BLAS took {end - start:.2f} seconds for {n} points.")
+    assert K.shape == (n, n)
+
+    # Symmetrize since only upper triangle is written
+    iu = np.triu_indices(n, 1)
+    K[(iu[1], iu[0])] = K[iu]
+
+    # Check diagonal ~ 1.0
+    assert np.allclose(np.diag(K), 1.0)
+
+    # Off-diagonal entries should be between 0 and 1
+    off_diag = K[iu]
+    assert np.all((off_diag >= 0.0) & (off_diag <= 1.0))