sequenzo 0.1.24__cp311-cp311-macosx_10_9_x86_64.whl

sequenzo/dissimilarity_measures/src/dp_utils.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#ifdef _OPENMP
+    #include <omp.h>
+#endif
+#include <cstdlib>
+#include <new>
+
+namespace dp_utils {
+
+// Cross-platform aligned allocation for double buffers
+#ifdef _WIN32
+inline double* aligned_alloc_double(size_t size, size_t align = 64) {
+    return reinterpret_cast<double*>(_aligned_malloc(size * sizeof(double), align));
+}
+inline void aligned_free_double(double* ptr) {
+    _aligned_free(ptr);
+}
+#else
+inline double* aligned_alloc_double(size_t size, size_t align = 64) {
+    void* ptr = nullptr;
+    if (posix_memalign(&ptr, align, size * sizeof(double)) != 0) throw std::bad_alloc();
+    return reinterpret_cast<double*>(ptr);
+}
+inline void aligned_free_double(double* ptr) { free(ptr); }
+#endif
+
+// Generic pairwise symmetric computation helper
+// ComputeFn signature: double(int i, int j, double* prev, double* curr)
+template <typename ComputeFn>
+inline pybind11::array_t<double> compute_all_distances(
+    int nseq,
+    int fmatsize,
+    pybind11::array_t<double>& dist_matrix,
+    ComputeFn&& compute_fn
+) {
+    auto buffer = dist_matrix.mutable_unchecked<2>();
+
+    #pragma omp parallel
+    {
+        double* prev = aligned_alloc_double(static_cast<size_t>(fmatsize));
+        double* curr = aligned_alloc_double(static_cast<size_t>(fmatsize));
+
+        #pragma omp for schedule(static)
+        for (int i = 0; i < nseq; i++) {
+            for (int j = i; j < nseq; j++) {
+                buffer(i, j) = compute_fn(i, j, prev, curr);
+            }
+        }
+
+        aligned_free_double(prev);
+        aligned_free_double(curr);
+    }
+
+    #pragma omp parallel for schedule(static)
+    for (int i = 0; i < nseq; i++) {
+        for (int j = i + 1; j < nseq; j++) {
+            buffer(j, i) = buffer(i, j);
+        }
+    }
+
+    return dist_matrix;
+}
+
+// Generic pairwise symmetric computation helper (no buffers)
+// ComputeFn signature: double(int i, int j)
+template <typename ComputeFn>
+inline pybind11::array_t<double> compute_all_distances_simple(
+    int nseq,
+    pybind11::array_t<double>& dist_matrix,
+    ComputeFn&& compute_fn
+) {
+    auto buffer = dist_matrix.mutable_unchecked<2>();
+
+    #pragma omp parallel
+    {
+        #pragma omp for schedule(static)
+        for (int i = 0; i < nseq; i++) {
+            for (int j = i; j < nseq; j++) {
+                buffer(i, j) = compute_fn(i, j);
+            }
+        }
+    }
+
+    #pragma omp parallel for schedule(static)
+    for (int i = 0; i < nseq; ++i) {
+        for (int j = i + 1; j < nseq; ++j) {
+            buffer(j, i) = buffer(i, j);
+        }
+    }
+
+    return dist_matrix;
+}
+
+// Generic reference-sequence computation helper (no buffers)
+// ComputeFn signature: double(int is, int rseq)
+template <typename ComputeFn>
+inline pybind11::array_t<double> compute_refseq_distances_simple(
+    int nseq,
+    int rseq1,
+    int rseq2,
+    pybind11::array_t<double>& refdist_matrix,
+    ComputeFn&& compute_fn
+) {
+    auto buffer = refdist_matrix.mutable_unchecked<2>();
+
+    #pragma omp parallel
+    {
+        #pragma omp for schedule(guided)
+        for (int rseq = rseq1; rseq < rseq2; rseq++) {
+            for (int is = 0; is < nseq; is++) {
+                buffer(is, rseq - rseq1) = (is == rseq) ? 0.0 : compute_fn(is, rseq);
+            }
+        }
+    }
+
+    return refdist_matrix;
+}
+
+// Generic reference-sequence computation helper (with DP buffers)
+// ComputeFn signature: double(int is, int rseq, double* prev, double* curr)
+template <typename ComputeFn>
+inline pybind11::array_t<double> compute_refseq_distances_buffered(
+    int nseq,
+    int rseq1,
+    int rseq2,
+    int fmatsize,
+    pybind11::array_t<double>& refdist_matrix,
+    ComputeFn&& compute_fn
+) {
+    auto buffer = refdist_matrix.mutable_unchecked<2>();
+
+    #pragma omp parallel
+    {
+        double* prev = aligned_alloc_double(static_cast<size_t>(fmatsize));
+        double* curr = aligned_alloc_double(static_cast<size_t>(fmatsize));
+
+        #pragma omp for schedule(static)
+        for (int rseq = rseq1; rseq < rseq2; rseq++) {
+            for (int is = 0; is < nseq; is++) {
+                double cmpres = 0.0;
+                if (is != rseq) {
+                    cmpres = compute_fn(is, rseq, prev, curr);
+                }
+                buffer(is, rseq - rseq1) = cmpres;
+            }
+        }
+
+        aligned_free_double(prev);
+        aligned_free_double(curr);
+    }
+
+    return refdist_matrix;
+}
+
+} // namespace dp_utils
+
+

sequenzo/dissimilarity_measures/src/module.cpp

@@ -0,0 +1,34 @@
+#include <pybind11/pybind11.h>
+#include "OMdistance.cpp"
+#include "OMspellDistance.cpp"
+#include "dist2matrix.cpp"
+#include "DHDdistance.cpp"
+#include "LCPdistance.cpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(c_code, m) {
+    py::class_<dist2matrix>(m, "dist2matrix")
+            .def(py::init<int, py::array_t<int>, py::array_t<double>>())
+            .def("padding_matrix", &dist2matrix::padding_matrix);
+
+    py::class_<LCPdistance>(m, "LCPdistance")
+            .def(py::init<py::array_t<int>, int, int, py::array_t<int>>())
+            .def("compute_all_distances", &LCPdistance::compute_all_distances)
+            .def("compute_refseq_distances", &LCPdistance::compute_refseq_distances);
+
+    py::class_<DHDdistance>(m, "DHDdistance")
+            .def(py::init<py::array_t<int>, py::array_t<double>, int, double, py::array_t<int>>())
+            .def("compute_all_distances", &DHDdistance::compute_all_distances)
+            .def("compute_refseq_distances", &DHDdistance::compute_refseq_distances);
+
+    py::class_<OMspellDistance>(m, "OMspellDistance")
+            .def(py::init<py::array_t<int>, py::array_t<double>, double, int, py::array_t<int>, double, py::array_t<double>, py::array_t<double>, py::array_t<int>>())
+            .def("compute_all_distances", &OMspellDistance::compute_all_distances)
+            .def("compute_refseq_distances", &OMspellDistance::compute_refseq_distances);
+
+    py::class_<OMdistance>(m, "OMdistance")
+            .def(py::init<py::array_t<int>, py::array_t<double>, double, int, py::array_t<int>, py::array_t<int>>())
+            .def("compute_all_distances", &OMdistance::compute_all_distances)
+            .def("compute_refseq_distances", &OMdistance::compute_refseq_distances);
+}

sequenzo/dissimilarity_measures/src/setup.py

@@ -0,0 +1,30 @@
+"""
+@Author  : 李欣怡
+@File    : setup.py
+@Time    : 2025/3/30 18:55
+@Desc    : 
+"""
+from setuptools import setup, Extension
+import pybind11
+
+pybind11_include = pybind11.get_include()
+
+ext_modules = [
+    Extension(
+        'c_code',
+        [r'/home/xinyi_test/test/module.cpp'],
+        include_dirs=[
+            pybind11_include,
+            r'/home/xinyi_test/test/xsimd/include'
+        ],
+        language='c++',
+        extra_compile_args=['-O2', '-std=c++17'],
+    ),
+]
+
+setup(
+    name='c_code',
+    version='0.1',
+    ext_modules=ext_modules,
+    zip_safe=False,
+)

sequenzo/dissimilarity_measures/src/utils.h

@@ -0,0 +1,25 @@
+#ifndef CC_CODE_UTILS_H
+#define CC_CODE_UTILS_H
+
+#include <cmath>
+
+static inline double normalize_distance(double rawdist, double maxdist, double l1, double l2, int norm){
+    if (rawdist == 0.0) return 0.0;
+    switch (norm) {
+        case 0:
+            return rawdist;
+        case 1:
+            return l1 > l2 ? rawdist / l1 : l2 > 0.0 ? rawdist / l2 : 0.0;
+        case 2:
+            return (l1 * l2 == 0.0) ? (l1 != l2 ? 1.0 : 0.0)
+                                    : 1.0 - ((maxdist - rawdist) / (2.0 * std::sqrt(l1) * std::sqrt(l2)));
+        case 3:
+            return maxdist == 0.0 ? 1.0 : rawdist / maxdist;
+        case 4:
+            return maxdist == 0.0 ? 1.0 : (2.0 * rawdist) / (rawdist + maxdist);
+        default:
+            return rawdist;
+    }
+}
+
+#endif //CC_CODE_UTILS_H

sequenzo/dissimilarity_measures/src/xsimd/.github/cmake-test/main.cpp

@@ -0,0 +1,6 @@
+#include "xsimd/xsimd.hpp"
+
+int main()
+{
+    return 0;
+}

sequenzo/dissimilarity_measures/src/xsimd/benchmark/main.cpp

@@ -0,0 +1,159 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#include "xsimd_benchmark.hpp"
+#include <map>
+
+void benchmark_operation()
+{
+    // std::size_t size = 9984;
+    std::size_t size = 20000;
+    xsimd::run_benchmark_2op(xsimd::add_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_2op(xsimd::sub_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_2op(xsimd::mul_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_2op(xsimd::div_fn(), std::cout, size, 1000);
+}
+
+void benchmark_exp_log()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_1op(xsimd::exp_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::exp2_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::expm1_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::log_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::log2_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::log10_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::log1p_fn(), std::cout, size, 1000);
+}
+
+void benchmark_trigo()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_1op(xsimd::sin_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::cos_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::tan_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::asin_fn(), std::cout, size, 1000, xsimd::init_method::arctrigo);
+    xsimd::run_benchmark_1op(xsimd::acos_fn(), std::cout, size, 1000, xsimd::init_method::arctrigo);
+    xsimd::run_benchmark_1op(xsimd::atan_fn(), std::cout, size, 1000, xsimd::init_method::arctrigo);
+}
+
+void benchmark_hyperbolic()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_1op(xsimd::sinh_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::cosh_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::tanh_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::asinh_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::acosh_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::atanh_fn(), std::cout, size, 100);
+}
+
+void benchmark_power()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_2op(xsimd::pow_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::sqrt_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::cbrt_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_2op(xsimd::hypot_fn(), std::cout, size, 1000);
+}
+
+void benchmark_rounding()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_1op(xsimd::ceil_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::floor_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::trunc_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::round_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::nearbyint_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op(xsimd::rint_fn(), std::cout, size, 100);
+}
+
+#ifdef XSIMD_POLY_BENCHMARKS
+void benchmark_poly_evaluation()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_1op(xsimd::horner_5_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::estrin_5_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::horner_10_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::estrin_10_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::horner_12_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::estrin_12_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::horner_14_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::estrin_14_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::horner_16_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_1op(xsimd::estrin_16_fn(), std::cout, size, 1000);
+}
+#endif
+
+void benchmark_basic_math()
+{
+    std::size_t size = 20000;
+    xsimd::run_benchmark_2op(xsimd::fmod_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_2op(xsimd::remainder_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_2op(xsimd::fdim_fn(), std::cout, size, 1000);
+    xsimd::run_benchmark_3op(xsimd::clip_fn(), std::cout, size, 1000);
+#if 0
+    xsimd::run_benchmark_1op_pred(xsimd::isfinite_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op_pred(xsimd::isinf_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op_pred(xsimd::is_flint_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op_pred(xsimd::is_odd_fn(), std::cout, size, 100);
+    xsimd::run_benchmark_1op_pred(xsimd::is_even_fn(), std::cout, size, 100);
+#endif
+}
+
+int main(int argc, char* argv[])
+{
+    const std::map<std::string, std::pair<std::string, void (*)()>> fn_map = {
+        { "op", { "arithmetic", benchmark_operation } },
+        { "exp", { "exponential and logarithm", benchmark_exp_log } },
+        { "trigo", { "trigonometric", benchmark_trigo } },
+        { "hyperbolic", { "hyperbolic", benchmark_hyperbolic } },
+        { "power", { "power", benchmark_power } },
+        { "basic_math", { "basic math", benchmark_basic_math } },
+        { "rounding", { "rounding", benchmark_rounding } },
+#ifdef XSIMD_POLY_BENCHMARKS
+        { "utils", { "polynomial evaluation", benchmark_poly_evaluation } },
+#endif
+    };
+
+    if (argc > 1)
+    {
+        if (std::string(argv[1]) == "--help" || std::string(argv[1]) == "-h")
+        {
+            std::cout << "Available options:" << std::endl;
+            for (auto const& kv : fn_map)
+            {
+                std::cout << kv.first << ": run benchmark on " << kv.second.first << " functions" << std::endl;
+            }
+        }
+        else
+        {
+            std::cout << "############################" << std::endl
+                      << "# " << xsimd::default_arch::name() << std::endl
+                      << "############################" << std::endl;
+            for (int i = 1; i < argc; ++i)
+            {
+                fn_map.at(argv[i]).second();
+            }
+        }
+    }
+    else
+    {
+        std::cout << "############################" << std::endl
+                  << "# " << xsimd::default_arch::name() << std::endl
+                  << "############################" << std::endl;
+        for (auto const& kv : fn_map)
+        {
+            kv.second.second();
+        }
+    }
+    return 0;
+}