sequenzo 0.1.31__cp310-cp310-macosx_10_9_x86_64.whl

sequenzo/dissimilarity_measures/src/OMspellDistance.cpp

@@ -0,0 +1,281 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <cmath>
+#include <iostream>
+#include "utils.h"
+#include "dp_utils.h"
+#ifdef _OPENMP
+    #include <omp.h>
+#endif
+#include <xsimd/xsimd.hpp>
+
+namespace py = pybind11;
+
+class OMspellDistance {
+public:
+    OMspellDistance(py::array_t<int> sequences, py::array_t<double> sm, double indel, int norm, py::array_t<int> refseqS,
+                    double timecost, py::array_t<double> seqdur, py::array_t<double> indellist, py::array_t<int> seqlength)
+            : indel(indel), norm(norm), timecost(timecost) {
+
+        py::print("[>] Starting Optimal Matching with spell(OMspell)...");
+        std::cout << std::flush;
+
+        try {
+            // ============================================
+            // parameter : sequences, sm, seqdur, indellist
+            // ============================================
+            this->sequences = sequences;
+            this->sm = sm;
+
+            this->seqdur = seqdur;
+            this->indellist = indellist;
+
+            this->seqlength = seqlength;
+
+            // ====================================================
+            // initialize nseq, seqlen, dist_matrix, fmatsize, fmat
+            // ====================================================
+            auto seq_shape = sequences.shape();
+            nseq = seq_shape[0];
+            len = seq_shape[1];
+
+            dist_matrix = py::array_t<double>({nseq, nseq});
+
+            fmatsize = len + 1;
+
+            // ====================
+            // initialize alphasize
+            // ====================
+            auto sm_shape = sm.shape();
+            alphasize = sm_shape[0];
+
+            // ==================
+            // initialize maxcost
+            // ==================
+            auto ptr = sm.mutable_unchecked<2>();
+
+            if(norm == 4){
+                maxscost = 2 * indel;
+            }else{
+                for(int i = 0; i < alphasize; i++){
+                    for(int j = i+1; j < alphasize; j++){
+                        if(ptr(i, j) > maxscost){
+                            maxscost = ptr(i, j);
+                        }
+                    }
+                }
+                maxscost = std::min(maxscost, 2 * indel);
+            }
+
+            // about reference sequences :
+            nans = nseq;
+
+            rseq1 = refseqS.at(0);
+            rseq2 = refseqS.at(1);
+            if(rseq1 < rseq2){
+                nseq = rseq1;
+                nans = nseq * (rseq2 - rseq1);
+            }else{
+                rseq1 = rseq1 - 1;
+            }
+            refdist_matrix = py::array_t<double>({nseq, (rseq2-rseq1)});
+        } catch (const std::exception& e) {
+            py::print("Error in constructor: ", e.what());
+            throw;
+        }
+    }
+
+    // 对齐分配函数 moved to dp_utils.h
+
+    double getIndel(int i, int j, int state){
+        auto ptr_indel = indellist.mutable_unchecked<1>();
+        auto ptr_dur = seqdur.mutable_unchecked<2>();
+
+        return ptr_indel(state) + timecost * ptr_dur(i, j);
+    }
+
+    double getSubCost(int i_state, int j_state, int i_x, int i_y, int j_x, int j_y){
+        auto ptr_dur = seqdur.mutable_unchecked<2>();
+
+        if(i_state == j_state){
+            double diffdur = ptr_dur(i_x, i_y) - ptr_dur(j_x, j_y);
+
+            return abs(timecost * diffdur);
+        }else{
+            auto ptr_sm = sm.mutable_unchecked<2>();
+
+            return ptr_sm(i_state, j_state) +
+                    (ptr_dur(i_x, i_y) + ptr_dur(j_x, j_y)) * timecost;
+        }
+    }
+
+    double compute_distance(int is, int js, double* prev, double* curr) {
+        try {
+            auto ptr_seq = sequences.unchecked<2>();
+            auto ptr_len = seqlength.unchecked<1>();
+            auto ptr_sm = sm.unchecked<2>();
+            auto ptr_dur = seqdur.unchecked<2>();
+            auto ptr_indel = indellist.unchecked<1>();
+
+            int i_state = 0, j_state = 0;
+            int mm = ptr_len(is);
+            int nn = ptr_len(js);
+            int mSuf = mm + 1;
+            int nSuf = nn + 1;
+
+            prev[0] = 0;
+            curr[0] = 0;
+
+            // initialize first row: cumulative insertions into js along columns
+            for (int jj = 1; jj < nSuf; jj++) {
+                int bj = ptr_seq(js, jj - 1);
+                prev[jj] = prev[jj - 1] + (ptr_indel(bj) + timecost * ptr_dur(js, jj - 1));
+            }
+
+            using batch_t = xsimd::batch<double>;
+            constexpr std::size_t B = batch_t::size;
+
+            for (int i = 1; i < mSuf; i++) {
+                i_state = ptr_seq(is, i - 1);
+                // per-row deletion cost (depends only on i_state and i position)
+                double dur_i = ptr_dur(is, i - 1);
+                double del_cost_i = ptr_indel(i_state) + timecost * dur_i;
+
+                // first column: cumulative deletions D[i][0] = D[i-1][0] + del_cost_i
+                curr[0] = prev[0] + del_cost_i;
+
+                int j = 1;
+                for (; j + (int)B <= nSuf; j += (int)B) {
+                    const double* prev_ptr = prev + j;
+                    const double* prevm1_ptr = prev + (j - 1);
+
+                    batch_t prevj = batch_t::load_unaligned(prev_ptr);
+                    batch_t prevjm1 = batch_t::load_unaligned(prevm1_ptr);
+
+                    alignas(64) double subs[B];
+                    alignas(64) double ins[B];
+                    for (std::size_t b = 0; b < B; ++b) {
+                        int jj_idx = j + (int)b - 1;
+                        int bj = ptr_seq(js, jj_idx);
+                        double dur_j = ptr_dur(js, jj_idx);
+
+                        if (i_state == bj) {
+                            subs[b] = std::abs(timecost * (dur_i - dur_j));
+                        } else {
+                            subs[b] = ptr_sm(i_state, bj) + (dur_i + dur_j) * timecost;
+                        }
+                        ins[b] = ptr_indel(bj) + timecost * dur_j;
+                    }
+
+                    batch_t sub_batch = batch_t::load_unaligned(subs);
+                    batch_t cand_del = prevj + batch_t(del_cost_i);
+                    batch_t cand_sub = prevjm1 + sub_batch;
+                    batch_t vert = xsimd::min(cand_del, cand_sub);
+
+                    double running = curr[j - 1] + ins[0];
+                    for (std::size_t b = 0; b < B; ++b) {
+                        double v = vert.get(b);
+                        double c = std::min(v, running);
+                        curr[j + (int)b] = c;
+                        if (b + 1 < B) running = c + ins[b + 1];
+                    }
+                }
+
+                // tail scalar handling
+                for (; j < nSuf; ++j) {
+                    j_state = ptr_seq(js, j - 1);
+                    double minimum = prev[j] + del_cost_i;
+                    double j_indel = curr[j - 1] + (ptr_indel(j_state) + timecost * ptr_dur(js, j - 1));
+                    double sub = prev[j - 1] + (
+                        (i_state == j_state)
+                        ? std::abs(timecost * (dur_i - ptr_dur(js, j - 1)))
+                        : (ptr_sm(i_state, j_state) + (dur_i + ptr_dur(js, j - 1)) * timecost)
+                    );
+                    curr[j] = std::min({ minimum, j_indel, sub });
+                }
+
+                std::swap(prev, curr);
+            }
+
+            double maxpossiblecost = std::abs(nn - mm) * indel + maxscost * std::min(mm, nn);
+            double ml = double(mm) * indel;
+            double nl = double(nn) * indel;
+
+            return normalize_distance(prev[nSuf - 1], maxpossiblecost, ml, nl, norm);
+        } catch (const std::exception& e) {
+            py::print("Error in compute_distance: ", e.what());
+            throw;
+        }
+    }
+
+    py::array_t<double> compute_all_distances() {
+        try {
+            return dp_utils::compute_all_distances(
+                nseq,
+                fmatsize,
+                dist_matrix,
+                [this](int i, int j, double* prev, double* curr) {
+                    return this->compute_distance(i, j, prev, curr);
+                }
+            );
+        } catch (const std::exception& e) {
+            py::print("Error in compute_all_distances: ", e.what());
+            throw;
+        }
+    }
+
+    py::array_t<double> compute_refseq_distances() {
+        try {
+            auto buffer = refdist_matrix.mutable_unchecked<2>();
+
+            #pragma omp parallel
+            {
+                double* prev = dp_utils::aligned_alloc_double(static_cast<size_t>(fmatsize));
+                double* curr = dp_utils::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;
+                        if(is != rseq){
+                            cmpres = compute_distance(is, rseq, prev, curr);
+                        }
+
+                        buffer(is, rseq - rseq1) = cmpres;
+                    }
+                }
+                dp_utils::aligned_free_double(prev);
+                dp_utils::aligned_free_double(curr);
+            }
+
+            return refdist_matrix;
+        } catch (const std::exception& e) {
+            py::print("Error in compute_all_distances: ", e.what());
+            throw;
+        }
+    }
+
+private:
+    py::array_t<int> sequences;
+    py::array_t<int> seqlength;
+    py::array_t<double> sm;
+    double indel;
+    int norm;
+    int nseq;
+    int len;
+    int alphasize;
+    int fmatsize;
+    py::array_t<double> dist_matrix;
+    double maxscost;
+
+    double timecost;
+    py::array_t<double> seqdur;
+    py::array_t<double> indellist;
+
+    // about reference sequences :
+    int nans = -1;
+    int rseq1 = -1;
+    int rseq2 = -1;
+    py::array_t<double> refdist_matrix;
+};

sequenzo/dissimilarity_measures/src/dist2matrix.cpp

@@ -0,0 +1,63 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <vector>
+#include <iostream>
+#ifdef _OPENMP
+    #include <omp.h>
+#endif
+
+namespace py = pybind11;
+
+class dist2matrix {
+public:
+    dist2matrix(int nseq, py::array_t<int> seqdata_didxs, py::array_t<double> dist_dseqs_num)
+            : nseq(nseq) {
+
+        py::print("[>] Computing all pairwise distances...");
+        std::cout << std::flush;
+
+        try {
+            this->seqdata_didxs = seqdata_didxs;
+            this->dist_dseqs_num = dist_dseqs_num;
+
+            dist_matrix = py::array_t<double>({nseq, nseq});
+        } catch (const std::exception& e) {
+            py::print("Error in constructor: ", e.what());
+            throw;
+        }
+    }
+
+    py::array_t<double> padding_matrix() {
+        try {
+           auto idxs_buf = seqdata_didxs.unchecked<1>();
+           auto dist_buf = dist_dseqs_num.unchecked<2>();
+           auto buffer = dist_matrix.mutable_unchecked<2>();
+
+           #pragma omp parallel for schedule(static)
+           for (int i = 0; i < nseq; ++i) {
+               for (int j = i; j < nseq; ++j) {
+                   buffer(i, j) = dist_buf(idxs_buf(i), idxs_buf(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;
+        } catch (const std::exception& e) {
+            py::print("Error in compute_all_distances: ", e.what());
+            throw;
+        }
+    }
+
+private:
+    py::array_t<int> seqdata_didxs;
+    py::array_t<double> dist_dseqs_num;
+    int nseq = 0;
+
+    py::array_t<double> dist_matrix;
+};

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,40 @@
+#include <pybind11/pybind11.h>
+#include "OMdistance.cpp"
+#include "OMspellDistance.cpp"
+#include "dist2matrix.cpp"
+#include "DHDdistance.cpp"
+#include "LCPdistance.cpp"
+#include "LCPspellDistance.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_<LCPspellDistance>(m, "LCPspellDistance")
+            .def(py::init<py::array_t<int>, py::array_t<double>, py::array_t<int>, int, int, py::array_t<int>, double>())
+            .def("compute_all_distances", &LCPspellDistance::compute_all_distances)
+            .def("compute_refseq_distances", &LCPspellDistance::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;
+}