mtrc 0.3.4__tar.gz

mtrc-0.3.4/CMakeLists.txt

@@ -0,0 +1,152 @@
+cmake_minimum_required(VERSION 3.15)
+
+if (POLICY CMP0025)
+    cmake_policy(SET CMP0025 NEW)
+endif ()
+if (POLICY CMP0074)
+    cmake_policy(SET CMP0074 NEW)
+endif()
+if (POLICY CMP0169)
+    cmake_policy(SET CMP0169 OLD)
+endif ()
+if (POLICY CMP0167)
+    cmake_policy(SET CMP0167 OLD)
+endif ()
+
+# TODO
+if(CMAKE_SYSTEM_NAME MATCHES Windows)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES ".*64$")
+        message("Build architecture: x64")
+        set(CMAKE_GENERATOR_PLATFORM x64)
+    else()
+        message("Build architecture: x86")
+        set(CMAKE_GENERATOR_PLATFORM Win32)
+    endif()
+endif()
+
+# TODO: check compiler, not OS
+project(metric_py DESCRIPTION "metric python binding" LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+include(FetchContent)
+option(METRIC_PYTHON_BUILD_FULL "Build legacy mapping and correlation Python bindings that require Boost" OFF)
+option(METRIC_PYTHON_FETCH_DEPS "Fetch missing C++ header dependencies for Python bindings" ON)
+option(METRIC_PYTHON_USE_BLAS "Link Python bindings to BLAS when available" ON)
+
+# Keep paths relative to this file so the Python build works both standalone and
+# when included by the top-level METRIC project.
+SET(SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src)
+if(NOT DEFINED ENV{METRIC_SOURCE_PATH})
+    if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/metric_cpp/metric")
+        SET(METRIC_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/metric_cpp)
+    else ()
+        SET(METRIC_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/..)
+    endif ()
+else ()
+    SET(METRIC_SOURCE_PATH $ENV{METRIC_SOURCE_PATH})
+endif()
+
+if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+    find_package(Python3 COMPONENTS Interpreter Development.Module REQUIRED)
+else ()
+    find_package(Python3 COMPONENTS Interpreter Development REQUIRED)
+endif ()
+if (METRIC_PYTHON_USE_BLAS)
+    find_package(BLAS QUIET)
+endif ()
+
+find_package(nlohmann_json QUIET)
+if (NOT nlohmann_json_FOUND AND METRIC_PYTHON_FETCH_DEPS)
+    FetchContent_Declare(
+        nlohmann_json
+        GIT_REPOSITORY https://github.com/nlohmann/json.git
+        GIT_TAG v3.11.3
+        GIT_SHALLOW TRUE)
+    FetchContent_GetProperties(nlohmann_json)
+    if (NOT nlohmann_json_POPULATED)
+        FetchContent_Populate(nlohmann_json)
+    endif ()
+    set(METRIC_PYTHON_NLOHMANN_JSON_INCLUDE_DIR ${nlohmann_json_SOURCE_DIR}/include)
+endif ()
+
+find_package(blaze 3.8 QUIET)
+if (NOT blaze_FOUND AND METRIC_PYTHON_FETCH_DEPS)
+    FetchContent_Declare(
+        blaze
+        GIT_REPOSITORY https://bitbucket.org/blaze-lib/blaze.git
+        GIT_TAG v3.8
+        GIT_SHALLOW TRUE)
+    FetchContent_GetProperties(blaze)
+    if (NOT blaze_POPULATED)
+        FetchContent_Populate(blaze)
+    endif ()
+    set(METRIC_PYTHON_BLAZE_INCLUDE_DIR ${blaze_SOURCE_DIR})
+endif ()
+
+find_package(cereal QUIET)
+if (NOT cereal_FOUND AND METRIC_PYTHON_FETCH_DEPS)
+    FetchContent_Declare(
+        cereal
+        GIT_REPOSITORY https://github.com/USCiLab/cereal.git
+        GIT_TAG v1.3.2
+        GIT_SHALLOW TRUE)
+    FetchContent_GetProperties(cereal)
+    if (NOT cereal_POPULATED)
+        FetchContent_Populate(cereal)
+    endif ()
+    set(METRIC_PYTHON_CEREAL_INCLUDE_DIR ${cereal_SOURCE_DIR}/include)
+endif ()
+
+if (METRIC_PYTHON_BUILD_FULL)
+    find_package(Boost REQUIRED)
+endif ()
+
+add_library(base_python_module INTERFACE)
+target_include_directories(base_python_module INTERFACE
+    ${SOURCE_PATH}
+    ${METRIC_SOURCE_PATH}
+)
+if (METRIC_PYTHON_NLOHMANN_JSON_INCLUDE_DIR)
+    target_include_directories(base_python_module INTERFACE ${METRIC_PYTHON_NLOHMANN_JSON_INCLUDE_DIR})
+endif ()
+if (TARGET nlohmann_json::nlohmann_json)
+    target_link_libraries(base_python_module INTERFACE nlohmann_json::nlohmann_json)
+endif ()
+if (METRIC_PYTHON_BLAZE_INCLUDE_DIR)
+    target_include_directories(base_python_module INTERFACE ${METRIC_PYTHON_BLAZE_INCLUDE_DIR})
+endif ()
+if (TARGET blaze::blaze)
+    target_link_libraries(base_python_module INTERFACE blaze::blaze)
+endif ()
+if (METRIC_PYTHON_CEREAL_INCLUDE_DIR)
+    target_include_directories(base_python_module INTERFACE ${METRIC_PYTHON_CEREAL_INCLUDE_DIR})
+endif ()
+if (TARGET cereal::cereal)
+    target_link_libraries(base_python_module INTERFACE cereal::cereal)
+endif ()
+if (Boost_FOUND)
+    target_include_directories(base_python_module INTERFACE ${Boost_INCLUDE_DIR})
+endif ()
+
+if (BLAS_FOUND)
+    target_link_libraries(base_python_module INTERFACE ${BLAS_LIBRARIES})
+endif ()
+
+if (MSVC)
+    target_compile_options(base_python_module INTERFACE
+        /wd"4267" /wd"4305" /wd"4244" /wd"4996"
+    )
+endif ()
+
+find_package(pybind11 CONFIG QUIET)
+if (NOT pybind11_FOUND)
+    FetchContent_Declare(
+        pybind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+        GIT_TAG v3.0.1
+        GIT_SHALLOW TRUE)
+    FetchContent_MakeAvailable(pybind11)
+endif ()
+add_subdirectory(src)

mtrc-0.3.4/MANIFEST.in

@@ -0,0 +1,3 @@
+include CMakeLists.txt
+include cmake_ext.py
+graft src

mtrc-0.3.4/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: mtrc
+Version: 0.3.4
+Summary: Python bindings and helpers for finite metric-space numerics
+Author: METRIC contributors
+License-Expression: MPL-2.0
+Project-URL: Documentation, https://metric-space-ai.github.io/metric/docs.html
+Project-URL: Source, https://github.com/metric-space-ai/metric
+Project-URL: Release checklist, https://github.com/metric-space-ai/metric/blob/master/docs/release-checklist.md
+Keywords: distance-metrics,finite-metric-space,metric-space,mtrc,numerical-computing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+
+# METRIC Python Package
+
+Python bindings for METRIC metric-space numerics.
+
+The public Python distribution name is `mtrc`. The import package remains
+`metric`.
+
+The revived core package exposes the project concepts explicitly:
+
+- `metric.metrics`: metric constructors such as `Edit`
+- `metric.Space`: minimal intent-first finite metric space facade
+- `metric.spaces`: finite metric-space helpers such as `FiniteMetricSpace`
+- `metric.operators`: pairwise-distance, nearest-neighbor, range-neighbor, exact graph-result, graph-connectivity-diagnostics, graph-degree-diagnostics, graph-stretch-diagnostics, graph-symmetrization, graph-out-degree-pruning, exact graph-edge, representative-selection, medoid, separated-representative, and radius-coverage helpers
+- `metric.mappings`: beta compatibility bridge for installed mapping bindings
+- `metric.transforms`: beta compatibility bridge for installed transform bindings
+
+The same objects are also available as convenience imports from `metric` for short examples.
+
+# Installation
+
+The Python package is in revival. The current supported CPython targets for the core wheel are 3.10, 3.11, 3.12, 3.13, and 3.14.
+
+After the package is published to PyPI, install the core package with:
+
+```shell
+python -m pip install mtrc
+```
+
+Until PyPI publishing is completed, build from source with the instructions below.
+
+Packaging now uses `pyproject.toml` with isolated PEP 517 builds and PEP 621 project metadata. `setup.py` provides the CMake extension build hook and the source-distribution hook that carries the required C++ headers into the Python sdist. The build prefers the `pybind11` package from the build environment (`pybind11>=3.0.0`) and falls back to a current FetchContent copy when no CMake package is available.
+
+CI builds core wheel artifacts for Linux, macOS, and Windows across the supported CPython versions.
+
+# Build from the source
+
+```
+git clone --recurse-submodules https://github.com/metric-space-ai/metric
+```
+
+## Install Prerequisites
+
+### Ubuntu
+
+```
+sudo apt-get install cmake
+sudo apt-get install libboost-all-dev
+```
+
+OpenBLAS or another BLAS implementation is optional for the revived core wheel. It can improve broader linear-algebra paths, but the CI core wheel builds with `METRIC_PYTHON_USE_BLAS=OFF`.
+
+### Windows
+
+Install [Miniconda](https://docs.conda.io/en/latest/miniconda.html).
+In Conda CLI initialize your virtual environment with desired Python version:
+
+```bash
+conda create --name my_env -y python=3.12
+conda activate my_env
+```
+
+OpenBLAS is optional for the revived core wheel. For legacy full bindings or broader linear-algebra paths, install it from conda-forge:
+
+```bash
+conda config --add channels conda-forge
+conda update -n base conda -y
+conda install -c conda-forge libopenblas openblas -y
+```
+
+## Build package
+
+At least 2GB of RAM is required
+
+```
+python -m pip wheel . --no-deps -w dist
+```
+
+By default this builds the revived core bindings. At this stage the default wheel exposes the `Edit` distance binding, space bindings, transform bindings, and the pure Python package surface. The legacy standard-distance, utils, mapping, and correlation bindings still require restoration and can be attempted with:
+
+```shell
+CMAKE_COMMON_VARIABLES="-DMETRIC_PYTHON_BUILD_FULL=ON" python -m pip wheel . --no-deps -w dist
+```
+
+To force the portable core-wheel mode used by CI:
+
+```shell
+CMAKE_COMMON_VARIABLES="-DMETRIC_PYTHON_USE_BLAS=OFF" python -m pip wheel . --no-deps -w dist
+```
+
+### Install module
+
+```
+python -m pip install dist/*
+```
+
+## Examples
+
+```python
+from metric import Edit, Space
+
+records = ["cat", "cot", "coat", "dog"]
+space = Space(records, Edit())
+
+print("distance(cat, cot) =", space(0, 1))
+print("nearest:", space.neighbors("cut", 2))
+```
+
+The core-wheel example is also available at `examples/metric_space/string_edit_space.py`. Full correlation, mapping, and standard-distance examples remain part of the broader restoration path until their bindings are promoted into the default wheel.
+
+Small tutorial notebooks live under `notebooks/`. They are paired with
+`notebooks/smoke_notebooks.py`, which executes their code cells in CI after the
+wheel is installed.
+
+`metric.mappings` and `metric.transforms` are importable beta namespaces. They expose `available()` and `legacy_module()` so callers can inspect whether a wheel includes the broader legacy bindings without making those bindings part of the core-wheel contract.
+
+## NumPy records
+
+The revived Python facade treats NumPy rows as records when the metric callable accepts them:
+
+```python
+import numpy as np
+from metric import Space
+
+records = np.array([[0.0, 0.0], [3.0, 4.0], [6.0, 8.0]])
+space = Space(records, lambda lhs, rhs: float(np.linalg.norm(lhs - rhs)))
+print(space.distance(0, 1))
+```
+
+Pairwise distance helpers return Python lists of lists; call `np.asarray(...)` if an ndarray result is required.

mtrc-0.3.4/README.md

@@ -0,0 +1,129 @@
+# METRIC Python Package
+
+Python bindings for METRIC metric-space numerics.
+
+The public Python distribution name is `mtrc`. The import package remains
+`metric`.
+
+The revived core package exposes the project concepts explicitly:
+
+- `metric.metrics`: metric constructors such as `Edit`
+- `metric.Space`: minimal intent-first finite metric space facade
+- `metric.spaces`: finite metric-space helpers such as `FiniteMetricSpace`
+- `metric.operators`: pairwise-distance, nearest-neighbor, range-neighbor, exact graph-result, graph-connectivity-diagnostics, graph-degree-diagnostics, graph-stretch-diagnostics, graph-symmetrization, graph-out-degree-pruning, exact graph-edge, representative-selection, medoid, separated-representative, and radius-coverage helpers
+- `metric.mappings`: beta compatibility bridge for installed mapping bindings
+- `metric.transforms`: beta compatibility bridge for installed transform bindings
+
+The same objects are also available as convenience imports from `metric` for short examples.
+
+# Installation
+
+The Python package is in revival. The current supported CPython targets for the core wheel are 3.10, 3.11, 3.12, 3.13, and 3.14.
+
+After the package is published to PyPI, install the core package with:
+
+```shell
+python -m pip install mtrc
+```
+
+Until PyPI publishing is completed, build from source with the instructions below.
+
+Packaging now uses `pyproject.toml` with isolated PEP 517 builds and PEP 621 project metadata. `setup.py` provides the CMake extension build hook and the source-distribution hook that carries the required C++ headers into the Python sdist. The build prefers the `pybind11` package from the build environment (`pybind11>=3.0.0`) and falls back to a current FetchContent copy when no CMake package is available.
+
+CI builds core wheel artifacts for Linux, macOS, and Windows across the supported CPython versions.
+
+# Build from the source
+
+```
+git clone --recurse-submodules https://github.com/metric-space-ai/metric
+```
+
+## Install Prerequisites
+
+### Ubuntu
+
+```
+sudo apt-get install cmake
+sudo apt-get install libboost-all-dev
+```
+
+OpenBLAS or another BLAS implementation is optional for the revived core wheel. It can improve broader linear-algebra paths, but the CI core wheel builds with `METRIC_PYTHON_USE_BLAS=OFF`.
+
+### Windows
+
+Install [Miniconda](https://docs.conda.io/en/latest/miniconda.html).
+In Conda CLI initialize your virtual environment with desired Python version:
+
+```bash
+conda create --name my_env -y python=3.12
+conda activate my_env
+```
+
+OpenBLAS is optional for the revived core wheel. For legacy full bindings or broader linear-algebra paths, install it from conda-forge:
+
+```bash
+conda config --add channels conda-forge
+conda update -n base conda -y
+conda install -c conda-forge libopenblas openblas -y
+```
+
+## Build package
+
+At least 2GB of RAM is required
+
+```
+python -m pip wheel . --no-deps -w dist
+```
+
+By default this builds the revived core bindings. At this stage the default wheel exposes the `Edit` distance binding, space bindings, transform bindings, and the pure Python package surface. The legacy standard-distance, utils, mapping, and correlation bindings still require restoration and can be attempted with:
+
+```shell
+CMAKE_COMMON_VARIABLES="-DMETRIC_PYTHON_BUILD_FULL=ON" python -m pip wheel . --no-deps -w dist
+```
+
+To force the portable core-wheel mode used by CI:
+
+```shell
+CMAKE_COMMON_VARIABLES="-DMETRIC_PYTHON_USE_BLAS=OFF" python -m pip wheel . --no-deps -w dist
+```
+
+### Install module
+
+```
+python -m pip install dist/*
+```
+
+## Examples
+
+```python
+from metric import Edit, Space
+
+records = ["cat", "cot", "coat", "dog"]
+space = Space(records, Edit())
+
+print("distance(cat, cot) =", space(0, 1))
+print("nearest:", space.neighbors("cut", 2))
+```
+
+The core-wheel example is also available at `examples/metric_space/string_edit_space.py`. Full correlation, mapping, and standard-distance examples remain part of the broader restoration path until their bindings are promoted into the default wheel.
+
+Small tutorial notebooks live under `notebooks/`. They are paired with
+`notebooks/smoke_notebooks.py`, which executes their code cells in CI after the
+wheel is installed.
+
+`metric.mappings` and `metric.transforms` are importable beta namespaces. They expose `available()` and `legacy_module()` so callers can inspect whether a wheel includes the broader legacy bindings without making those bindings part of the core-wheel contract.
+
+## NumPy records
+
+The revived Python facade treats NumPy rows as records when the metric callable accepts them:
+
+```python
+import numpy as np
+from metric import Space
+
+records = np.array([[0.0, 0.0], [3.0, 4.0], [6.0, 8.0]])
+space = Space(records, lambda lhs, rhs: float(np.linalg.norm(lhs - rhs)))
+print(space.distance(0, 1))
+```
+
+Pairwise distance helpers return Python lists of lists; call `np.asarray(...)` if an ndarray result is required.

mtrc-0.3.4/cmake_ext.py

@@ -0,0 +1,95 @@
+import os
+import subprocess
+import shutil
+import sys
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+
+CMAKE_EXE = os.environ.get('CMAKE_EXE', shutil.which('cmake'))
+
+
+def check_for_cmake():
+    if not CMAKE_EXE:
+        print('cmake executable not found. '
+              'Set CMAKE_EXE environment or update your path')
+        sys.exit(1)
+
+
+def pybind11_cmake_dir():
+    try:
+        import pybind11
+    except ImportError:
+        return None
+
+    get_cmake_dir = getattr(pybind11, 'get_cmake_dir', None)
+    if get_cmake_dir:
+        return get_cmake_dir()
+
+    try:
+        return subprocess.check_output(
+            [sys.executable, '-m', 'pybind11', '--cmakedir'],
+            text=True
+        ).strip()
+    except (subprocess.CalledProcessError, OSError):
+        return None
+
+
+class CMakeExtension(Extension):
+    """
+    setuptools.Extension for cmake
+    """
+
+    def __init__(self, name, source_dir='', output_dir=''):
+        check_for_cmake()
+        Extension.__init__(self, name, sources=[])
+        self.source_dir = os.path.abspath(source_dir)
+        self.output_dir = output_dir
+
+
+class CMakeBuildExt(build_ext):
+    """
+    setuptools build_exit which builds using cmake & make
+    You can add cmake args with the CMAKE_COMMON_VARIABLES environment variable
+    """
+
+    def build_extension(self, ext):
+        check_for_cmake()
+        if isinstance(ext, CMakeExtension):
+            output_dir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+
+            build_type = 'Debug' if self.debug else 'Release'
+            cmake_args = [CMAKE_EXE,
+                          ext.source_dir,
+                          '-DPYTHON_EXECUTABLE:FILEPATH=' + sys.executable,
+                          '-DPython_EXECUTABLE:FILEPATH=' + sys.executable,
+                          '-DPython3_EXECUTABLE:FILEPATH=' + sys.executable,
+                          '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + os.path.join(output_dir, ext.output_dir),
+                          '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG=' + os.path.join(output_dir, ext.output_dir),
+                          '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE=' + os.path.join(output_dir, ext.output_dir),
+                          '-DCMAKE_BUILD_TYPE=' + build_type]
+            pybind11_dir = pybind11_cmake_dir()
+            if pybind11_dir:
+                cmake_args.append('-Dpybind11_DIR:PATH=' + pybind11_dir)
+            cmake_args.extend(
+                [x for x in
+                 os.environ.get('CMAKE_COMMON_VARIABLES', '').split(' ')
+                 if x])
+
+            env = os.environ.copy()
+            if not os.path.exists(self.build_temp):
+                os.makedirs(self.build_temp)
+
+            subprocess.check_call(cmake_args,
+                                  cwd=self.build_temp,
+                                  env=env)
+            build_args = [CMAKE_EXE, '--build', '.', '--config', build_type]
+            if ext.name != 'all':
+                build_args.extend(['--target', ext.name])
+            subprocess.check_call(build_args,
+                                  cwd=self.build_temp,
+                                  env=env)
+        else:
+            super().build_extension(ext)
+
+
+__all__ = ['CMakeBuildExt', 'CMakeExtension']

mtrc-0.3.4/metric_cpp/metric/3rdparty/DCT/fast-dct-lee.c

@@ -0,0 +1,107 @@
+/*
+ * Fast discrete cosine transform algorithms (C)
+ *
+ * Copyright (c) 2019 Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-discrete-cosine-transform-algorithms
+ *
+ * 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.
+ */
+
+#include "fast-dct-lee.h"
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+static void forwardTransform(double vector[], double temp[], size_t len);
+static void inverseTransform(double vector[], double temp[], size_t len);
+
+// DCT type II, unscaled. Algorithm by Byeong Gi Lee, 1984.
+// See: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.118.3056&rep=rep1&type=pdf#page=34
+inline bool FastDctLee_transform(double vector[], size_t len)
+{
+	if (len <= 0 || (len & (len - 1)) != 0)
+		return false; // Length is not power of 2
+	if (SIZE_MAX / sizeof(double) < len)
+		return false;
+	// double *temp = malloc(len * sizeof(double));
+	double *temp = (double *)malloc(len * sizeof(double)); // added by Max F for compatibility with c++
+	if (temp == NULL)
+		return false;
+	forwardTransform(vector, temp, len);
+	free(temp);
+	return true;
+}
+
+static void forwardTransform(double vector[], double temp[], size_t len)
+{
+	if (len == 1)
+		return;
+	size_t halfLen = len / 2;
+	for (size_t i = 0; i < halfLen; i++) {
+		double x = vector[i];
+		double y = vector[len - 1 - i];
+		temp[i] = x + y;
+		temp[i + halfLen] = (x - y) / (cos((i + 0.5) * M_PI / len) * 2);
+	}
+	forwardTransform(temp, vector, halfLen);
+	forwardTransform(&temp[halfLen], vector, halfLen);
+	for (size_t i = 0; i < halfLen - 1; i++) {
+		vector[i * 2 + 0] = temp[i];
+		vector[i * 2 + 1] = temp[i + halfLen] + temp[i + halfLen + 1];
+	}
+	vector[len - 2] = temp[halfLen - 1];
+	vector[len - 1] = temp[len - 1];
+}
+
+// DCT type III, unscaled. Algorithm by Byeong Gi Lee, 1984.
+// See: https://www.nayuki.io/res/fast-discrete-cosine-transform-algorithms/lee-new-algo-discrete-cosine-transform.pdf
+inline bool FastDctLee_inverseTransform(double vector[], size_t len)
+{
+	if (len <= 0 || (len & (len - 1)) != 0)
+		return false; // Length is not power of 2
+	if (SIZE_MAX / sizeof(double) < len)
+		return false;
+	// double *temp = malloc(len * sizeof(double));
+	double *temp = (double *)malloc(len * sizeof(double)); // added by Max F for compatibility with c++
+	if (temp == NULL)
+		return false;
+	vector[0] /= 2;
+	inverseTransform(vector, temp, len);
+	free(temp);
+	return true;
+}
+
+static void inverseTransform(double vector[], double temp[], size_t len)
+{
+	if (len == 1)
+		return;
+	size_t halfLen = len / 2;
+	temp[0] = vector[0];
+	temp[halfLen] = vector[1];
+	for (size_t i = 1; i < halfLen; i++) {
+		temp[i] = vector[i * 2];
+		temp[i + halfLen] = vector[i * 2 - 1] + vector[i * 2 + 1];
+	}
+	inverseTransform(temp, vector, halfLen);
+	inverseTransform(&temp[halfLen], vector, halfLen);
+	for (size_t i = 0; i < halfLen; i++) {
+		double x = temp[i];
+		double y = temp[i + halfLen] / (cos((i + 0.5) * M_PI / len) * 2);
+		vector[i] = x + y;
+		vector[len - 1 - i] = x - y;
+	}
+}

mtrc-0.3.4/metric_cpp/metric/3rdparty/DCT/fast-dct-lee.h

@@ -0,0 +1,39 @@
+/*
+ * Fast discrete cosine transform algorithms (C)
+ *
+ * Copyright (c) 2018 Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-discrete-cosine-transform-algorithms
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool FastDctLee_transform(double vector[], size_t len);
+
+bool FastDctLee_inverseTransform(double vector[], size_t len);
+
+#ifdef __cplusplus
+}
+#endif