Merge pull request #94 from SGSSGene/feat/new_searches

Feat/new searches

Author: SGSSGene

src/fmindex-collection/bitvector/Bitvector.h

@@ -95,10 +95,11 @@ struct Bitvector {
                 break;
             }
 
-            l1[l1_id+1] = l1[l1_id] + std::popcount(bits);
+            auto ct = size_t{l1[l1_id]} + std::popcount(bits);
+            l1[l1_id+1] = ct;
             // check if next superblock is full
             if (totalLength % 256 == 0) {
-                l0[l0_id+1] = l0[l0_id] + l1[l1_id+1];
+                l0[l0_id+1] = l0[l0_id] + ct;
                 l1[l1_id+1] = 0;
             }
         }
@@ -121,10 +122,11 @@ struct Bitvector {
         }
         totalLength += 1;
         if (totalLength % 64 == 0) { // new block
-            blocks.emplace_back(blocks.back() + std::popcount(bits.back()));
+            auto ct = size_t{blocks.back()} + std::popcount(bits.back());
+            blocks.emplace_back(ct);
             bits.emplace_back();
             if (totalLength % 256 == 0) { // new super block + new block
-                superblocks.emplace_back(superblocks.back() + blocks.back());
+                superblocks.emplace_back(superblocks.back() + ct);
                 blocks.back() = 0;
             }
         }

src/fmindex-collection/fmindex/LinearFMIndex.h

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2025 Simon Gene Gottlieb
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include "FMIndex.h"
+
+namespace fmc {
+
+/** Special FMIndex, that
+ * only carries entries with the same length.
+ *
+ * It always searches for the first character and then the next in a fixed order and no overlappings
+ *
+ */
+template <size_t TSigma, template <size_t> typename String = string::FlattenedBitvectors_512_64k>
+    requires String_c<String<TSigma>>
+struct LinearFMIndex {
+    static size_t constexpr Sigma = TSigma;
+
+    struct Column {
+        String<Sigma>               bwt;
+        std::array<size_t, Sigma+1> C{0};
+    };
+    std::vector<Column> columns;
+
+    size_t size_;
+    size_t depth_;
+
+    std::vector<size_t> ordered{};
+
+
+    LinearFMIndex(Sequences auto const& _inputs) {
+        auto lastOrder = std::vector<size_t>{};
+        for (size_t i{0}; i < _inputs.size(); ++i) {
+            lastOrder.push_back(i);
+        }
+
+        // counts characters in a column
+        auto countColumn = [&](size_t col, size_t begin, size_t end) {
+            auto count = std::array<size_t, 257>{};
+            for (auto i{begin}; i < end; ++i) {
+                auto row = lastOrder[i];
+                auto c = _inputs[row][col];
+                count[c] += 1;
+            }
+            return count;
+        };
+        auto accCount = [](std::array<size_t, 257>& count) {
+            for (size_t i{1}; i < count.size(); ++i) {
+                count[i] = count[i-1] + count[i];
+            }
+        };
+
+        auto target = std::vector<std::vector<uint8_t>>{};
+        target.resize(_inputs.size(), std::vector<uint8_t>(_inputs[0].size()));
+
+
+        auto sort = std::function<void(size_t, size_t, size_t)>{};
+
+        auto pos = std::vector<size_t>{};
+        pos.resize(lastOrder.size());
+
+        columns.resize(_inputs[0].size());
+
+        auto temp_input = std::vector<uint8_t>{};
+        temp_input.resize(_inputs.size());
+
+        for (size_t j{0}; j < _inputs[0].size(); ++j) {
+            size_t col = _inputs[0].size() - j - 1;
+            auto count = countColumn(col, 0, _inputs.size());
+            accCount(count);
+
+            for (size_t _i{0}; _i < _inputs.size(); ++_i) {
+                auto i = _inputs.size() - _i - 1;
+                auto row = lastOrder[i];
+                auto c = _inputs[row][col];
+                pos[--count[c]] = row;
+            }
+            std::swap(lastOrder, pos);
+            //fmt::print("pass {}\n", j);
+            //printPos(lastOrder);
+
+
+            // fill bwts + C
+            auto tcol = ((col == 0)?columns.size():col)-1;
+            auto& bwt = columns[tcol].bwt;
+            auto& C = columns[tcol].C;
+
+            // fill temp string for bwt
+            for (size_t i{0}; i < lastOrder.size(); ++i) {
+                auto row = lastOrder[i];
+                auto c = _inputs[row].back();
+                if (col > 0) c = _inputs[row][col-1];
+                temp_input[i] = c;
+            }
+            bwt = {temp_input};
+
+            // fill C
+            for (size_t i{0}; i <= Sigma; ++i) {
+                C[i] = bwt.prefix_rank(bwt.size(), i);
+            }
+        }
+        size_ = _inputs.size();
+        ordered = lastOrder;
+    }
+
+    auto size() const {
+        return size_;
+    }
+
+    auto depth() const {
+        return columns.size();
+    }
+
+    auto locate(size_t idx) const -> size_t {
+        return ordered[idx];
+    }
+};
+
+}

src/fmindex-collection/fmindex/LinearFMIndexCursor.h

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2025 Simon Gene Gottlieb
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include "LinearFMIndex.h"
+
+#include <compare>
+
+namespace fmc {
+
+template <typename Index>
+struct LinearFMIndexCursor {
+    static constexpr size_t Sigma    = Index::Sigma;
+    static constexpr bool   Reversed = false;
+
+    Index const* index{};
+    size_t lb;
+    size_t len{};
+    size_t col{};
+
+    LinearFMIndexCursor() noexcept = default;
+
+    LinearFMIndexCursor(Index const& index) noexcept
+        : LinearFMIndexCursor{index, 0, index.size(), index.columns.size()-1}
+    {}
+
+    LinearFMIndexCursor(Index const& index, size_t lb, size_t len, size_t col) noexcept
+        : index{&index}
+        , lb{lb}
+        , len{len}
+        , col{col}
+    {}
+
+    auto extendLeft(uint8_t symb) const -> LinearFMIndexCursor {
+        auto const& column = index->columns[col];
+        size_t newLb  = column.bwt.rank(lb, symb);
+        size_t newLen = column.bwt.rank(lb+len, symb) - newLb;
+        return {*index, newLb + column.C[symb], newLen, col-1};
+    }
+    auto extendLeft() const -> std::array<LinearFMIndexCursor, Sigma> {
+        auto const& column = index->columns[col];
+        auto [rs1, prs1] = column.bwt.all_ranks_and_prefix_ranks(lb);
+        auto [rs2, prs2] = column.bwt.all_ranks_and_prefix_ranks(lb+len);
+
+        for (size_t i{0}; i < rs1.size(); ++i) {
+            rs1[i] += column.C[i];
+            rs2[i] += column.C[i];
+        }
+
+        auto cursors = std::array<LinearFMIndexCursor, Sigma>{};
+        cursors[0] = LinearFMIndexCursor{*index, rs1[0], rs2[0] - rs1[0], col-1};
+        for (size_t i{1}; i < Sigma; ++i) {
+            cursors[i] = LinearFMIndexCursor{*index, rs1[i], rs2[i] - rs1[i], col-1};
+        }
+        return cursors;
+    }
+
+    bool empty() const {
+        return len == 0;
+    }
+
+    size_t count() const {
+        return len;
+    }
+
+};
+
+template <typename Index>
+auto begin(LinearFMIndexCursor<Index> const& _cursor) {
+    return IntIterator{_cursor.lb};
+}
+template <typename Index>
+auto end(LinearFMIndexCursor<Index> const& _cursor) {
+    return IntIterator{_cursor.lb + _cursor.len};
+}
+
+}

src/fmindex-collection/fmindex/all.h

@@ -7,6 +7,8 @@
 #include "fmindex/BiFMIndexCursor.h"
 #include "fmindex/FMIndex.h"
 #include "fmindex/FMIndexCursor.h"
+#include "fmindex/LinearFMIndex.h"
+#include "fmindex/LinearFMIndexCursor.h"
 #include "fmindex/MirroredBiFMIndex.h"
 #include "fmindex/MirroredBiFMIndexCursor.h"
 #include "fmindex/ReverseFMIndex.h"

src/fmindex-collection/search/Restore.h

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2025 Simon Gene Gottlieb
+// SPDX-License-Identifier: BSD-3-Clause
+#pragma once
+
+#include <cstddef>
+
+template <typename T, typename T2=std::nullptr_t>
+struct Restore {
+    T* value;
+    T oldValue;
+    Restore(T& _value)
+        : value{&_value}
+        , oldValue{*value}
+    {}
+    Restore(T& _value, T2 newValue)
+        : value{&_value}
+        , oldValue{*value}
+    {
+        *value = static_cast<T>(newValue);
+    }
+    Restore(Restore const&) = delete;
+    Restore(Restore&&) = delete;
+    ~Restore() {
+        *value = oldValue;
+    }
+};