Merge pull request #113 from SGSSGene/fix/search_ng26/besthit

Fix/search ng26/besthit

Author: SGSSGene

cpm.dependencies

@@ -134,7 +134,7 @@
     },
     {
       "name": "mmser",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "github_repository": "SGSSGene/mmser",
     },
   ]

src/fmindex-collection/DenseMultiVector.h

@@ -0,0 +1,159 @@
+// SPDX-FileCopyrightText: 2025 Simon Gene Gottlieb
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include "DenseVector.h"
+
+#include <array>
+#include <variant>
+
+namespace fmc {
+
+template <typename Ts>
+struct DenseMultiVector;
+
+template <>
+struct DenseMultiVector<std::monostate> {
+    DenseMultiVector() = default;
+
+    static auto concat(DenseMultiVector const& lhs, DenseMultiVector const& rhs) {
+        (void)lhs;
+        (void)rhs;
+        return DenseMultiVector{};
+    }
+
+    DenseMultiVector(DenseMultiVector const&) = default;
+    DenseMultiVector(DenseMultiVector&&) noexcept = default;
+    DenseMultiVector& operator=(DenseMultiVector const&) = default;
+    DenseMultiVector& operator=(DenseMultiVector&&) noexcept = default;
+
+    void reserve(size_t) {}
+    void push_back(std::monostate) {}
+    auto operator[](size_t) const -> std::monostate { return {}; }
+    auto access(size_t) const -> std::monostate { return {}; }
+    size_t size() const { return 0; }
+
+    template <typename Archive>
+    void serialize(this auto&& self, Archive& ar) {
+        (void)self;
+        (void)ar;
+    }
+};
+
+
+/* Like DenseVector but stores multiple values per entry
+ */
+template <typename ...Ts>
+    requires (std::convertible_to<Ts, size_t> && ...)
+        && (std::convertible_to<size_t, Ts> && ...)
+struct DenseMultiVector<std::tuple<Ts...>> {
+    std::array<DenseVector, sizeof...(Ts)> data;
+
+    DenseMultiVector() = default;
+
+    static auto concat(DenseMultiVector const& lhs, DenseMultiVector const& rhs) {
+        auto v = DenseMultiVector{};
+        for (size_t i{0}; i < lhs.data.size(); ++i) {
+            v.data[i] = DenseVector::concat(lhs.data[i], rhs.data[i]);
+        }
+        return v;
+    }
+
+
+    DenseMultiVector(DenseMultiVector const&) = default;
+    DenseMultiVector(DenseMultiVector&&) noexcept = default;
+    DenseMultiVector& operator=(DenseMultiVector const&) = default;
+    DenseMultiVector& operator=(DenseMultiVector&&) noexcept = default;
+
+    template <std::ranges::range range_t>
+        requires std::convertible_to<std::ranges::range_value_t<range_t>, std::tuple<Ts...>>
+    DenseMultiVector(range_t const& _range) {
+        auto largestValue = std::array<size_t, sizeof...(Ts)>{};
+        auto commonDivisor = std::array<size_t, sizeof...(Ts)>{};
+        size_t ct{};
+
+        // find largest value
+        for (auto const& t : _range) {
+            // using template magic to spread a single entry into multiple vectors
+            map<sizeof...(Ts)>([&]<size_t I>() {
+                auto const v = static_cast<size_t>(std::get<I>(t));
+                largestValue[I]  = std::max<size_t>(largestValue[I], v);
+                commonDivisor[I] = std::gcd(commonDivisor[I], v);
+            });
+            ct += 1;
+        }
+
+        // make sure commonDivisor and largestValue are at least 1
+        map<sizeof...(Ts)>([&]<size_t I>() {
+            if (commonDivisor[I] == 0) {
+                commonDivisor[I] = 1;
+            }
+            if (largestValue[I] == 0) {
+                largestValue[I] = 1;
+            }
+        });
+
+        // Initialize each vector accordinlgy
+        map<sizeof...(Ts)>([&]<size_t I>() {
+            data[I] = DenseVector(/*.largestValue = */ largestValue[I], /*.commonDivisor = */commonDivisor[I]);
+            data[I].reserve(ct);
+        });
+        for (auto const& t : _range) {
+            push_back(t);
+        }
+    }
+
+
+    /** Reserve memory for a certain number of integers.
+     *
+     * \param s number of integer
+     */
+    void reserve(size_t s) {
+        for (size_t i{0}; i < data.size(); ++i) {
+            data[i].reserve(s);
+        }
+    }
+
+    template <size_t End>
+    static void map(auto const& cb) {
+        if constexpr (End > 0) {
+            cb.template operator()<End-1>();
+            map<End-1>(cb);
+        }
+    }
+
+    /** Push a value to the end of the vector
+     */
+    void push_back(std::tuple<Ts...> const& value) {
+        map<sizeof...(Ts)>([&]<size_t I>() {
+            data[I].push_back(std::get<I>(value));
+        });
+    }
+
+    /** Read integer at a certain position
+     */
+    auto operator[](size_t i) const -> std::tuple<Ts...> {
+        return access(i);
+    }
+
+    /** Read integer at a certain position
+     */
+    auto access(size_t i) const -> std::tuple<Ts...> {
+        auto ret = std::tuple<Ts...>{};
+        map<sizeof...(Ts)>([&]<size_t I>() {
+            std::get<I>(ret) = data[I].access(i);
+        });
+        return ret;
+    }
+
+    size_t size() const {
+        return data[0].size();
+    }
+
+    template <typename Archive>
+    void serialize(this auto&& self, Archive& ar) {
+        ar(self.data);
+    }
+};
+
+}

src/fmindex-collection/VectorBool.h

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2025 Simon Gene Gottlieb
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <mmser/mmser.h>
+
+namespace fmc {
+
+struct VectorBool {
+    struct Proxy {
+        uint8_t& value;
+        size_t   offset;
+        operator bool() const {
+            return (value >> offset) & 1;
+        }
+        void operator=(bool b) {
+            //       value     clears value at offset |   sets value at offset
+            value = (value & ~(uint8_t{1} << offset)) | (uint8_t{b} << offset);
+        }
+    };
+
+    mmser::vector<uint8_t> values;
+    size_t used_capacity{};
+
+
+    void reserve(size_t i) {
+        values.reserve((i+7)/8);
+    }
+    void resize(size_t i) {
+        values.resize((i+7)/8, 0);
+        used_capacity = i;
+    }
+
+    auto unused_capacity() const {
+        return values.size()*8 - used_capacity;
+    }
+    void resize(size_t newSize, bool value) {
+        values.resize((newSize+7)/8, 0);
+        for (size_t i{used_capacity}; i < newSize; ++i) {
+            at(i) = value;
+        }
+        used_capacity = newSize;
+    }
+
+    void push_back(bool b) {
+        if (unused_capacity() == 0) {
+            values.emplace_back(0);
+        }
+        at(size()) = b;
+        used_capacity += 1;
+    }
+
+    auto size() const -> size_t {
+        return used_capacity;
+    }
+
+    auto at(size_t idx) -> Proxy {
+        size_t block = idx/8;
+        size_t offset = idx%8;
+        return Proxy{values[block], offset};
+    }
+    auto at(size_t idx) const -> bool {
+        size_t block = idx/8;
+        size_t offset = idx%8;
+        return (values[block] >> offset) & 1;
+    }
+    auto operator[](this auto& self, size_t idx) {
+        return self.at(idx);
+    }
+
+    template <typename Archive>
+    void serialize(this auto&& self, Archive& ar) {
+        ar(self.used_capacity, self.values);
+    }
+};
+
+}