effspm 0.1.5__cp312-cp312-macosx_11_0_arm64.whl → 0.2.6__cp312-cp312-macosx_11_0_arm64.whl

effspm/largebm/src/load_inst.cpp

@@ -0,0 +1,230 @@
+
+#include <sstream>
+#include <algorithm>
+#include <cmath>
+#include <ctime>
+#include <iostream>      // for std::cout, std::endl
+#include <fstream>
+#include <vector>
+#include <string>
+
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
+
+namespace largebm {
+
+// ── global definitions ────────────────────────────────────────────
+bool use_list      = false;
+bool b_disp        = false;
+bool b_write       = false;
+bool use_dic       = false;
+bool just_build    = false;
+bool pre_pro       = false;
+bool itmset_exists = false;
+
+unsigned int        M = 0, L = 0, time_limit = 0;
+unsigned long long  N = 0, num_nodes = 0, theta = 0, E = 0;
+std::clock_t        start_time = 0;
+
+std::vector<int>              item_dic;
+std::vector<Pattern>          DFS;
+std::vector<std::vector<int>> items;
+std::vector<std::vector<int>> collected;
+std::vector<int>              inv_item_dic;
+
+std::string out_file, folder;
+
+// ───────────── helper for list‐mode DB build ─────────────────────
+static void Load_items_list(const std::string& fname) {
+    std::ifstream in(fname);
+    if (!in.good()) return;
+    std::string line;
+    while (std::getline(in, line)) {
+        std::istringstream iss(line);
+        std::vector<int> seq;
+        int x;
+        while (iss >> x) {
+            int a = std::abs(x);
+            if (a < 1 || a > static_cast<int>(item_dic.size())) continue;
+            if (item_dic[a - 1] == -1) continue;
+            seq.push_back(x);
+        }
+        if (!seq.empty()) items.push_back(std::move(seq));
+    }
+}
+
+// ─────────────── main loader ─────────────────────────────────────
+bool Load_instance(const std::string& items_file, double minsup) {
+    // reset state
+    N = L = num_nodes = theta = M = E = 0;
+    start_time = std::clock();
+
+    DFS.clear();
+    Tree.clear();
+    items.clear();
+    collected.clear();
+    item_dic.clear();
+    inv_item_dic.clear();
+    itmset_exists = false;
+
+    std::clock_t kk = start_time;
+    Tree.emplace_back(0, 0, 0);  // root
+
+    if (use_list) {
+        if (!Preprocess(items_file, minsup)) return false;
+        inv_item_dic.assign(L + 1, 0);
+        for (int old = 1; old <= static_cast<int>(item_dic.size()); ++old) {
+            int cid = item_dic[old - 1];
+            if (cid > 0) inv_item_dic[cid] = old;
+        }
+        Load_items_list(items_file);
+        N = items.size();
+        theta = (minsup < 1.0)
+                ? static_cast<unsigned long long>(std::ceil(minsup * N))
+                : static_cast<unsigned long long>(minsup);
+        return true;
+    }
+
+    // MDD build mode
+    if (pre_pro) {
+        if (!Preprocess(items_file, minsup)) return false;
+        std::cout << "\nPreprocess done in "
+                  << give_time(std::clock() - kk)
+                  << " seconds\n\n";
+        DFS.clear();
+        DFS.reserve(L);
+        for (unsigned int i = 0; i < L; ++i)
+            DFS.emplace_back(-int(i) - 1);
+        kk = std::clock();
+        Load_items_pre(items_file);
+    } else {
+        if (!Preprocess(items_file, 0.0)) return false;
+        kk = std::clock();
+        Load_items(items_file);
+    }
+
+    std::cout << "\nMDD Database built in "
+              << give_time(std::clock() - kk)
+              << " seconds\n\n";
+    std::cout << "Found " << N
+              << " sequences, with max line len " << M
+              << ", and " << L << " items, and " << E << " entries\n";
+    std::cout << "Total MDD nodes: " << Tree.size() << std::endl;
+
+    return true;
+}
+
+// ────────────── Preprocess (list mode) ───────────────────────────
+bool Preprocess(const std::string& inst, double thresh) {
+    std::ifstream file(inst);
+    if (!file.good()) return false;
+
+    std::vector<unsigned long long> freq(1000000);
+    std::vector<unsigned long long> counted(1000000, 0);
+    std::string line;
+    while (std::getline(file, line)) {
+        ++N;
+        std::istringstream iss(line);
+        int x;
+        while (iss >> x) {
+            int a = std::abs(x);
+            L = std::max(L, static_cast<unsigned int>(a));
+            if (freq.size() < L) {
+                freq.resize(L);
+                counted.resize(L);
+            }
+            if (counted[a - 1] != N) {
+                freq[a - 1]++;
+                counted[a - 1] = N;
+            }
+        }
+    }
+
+    theta = (thresh < 1.0)
+            ? static_cast<unsigned long long>(std::ceil(thresh * N))
+            : static_cast<unsigned long long>(thresh);
+
+    item_dic.assign(L, -1);
+    unsigned int newid = 0;
+    for (unsigned int old = 1; old <= L; ++old) {
+        if (freq[old - 1] >= theta) {
+            ++newid;
+            item_dic[old - 1] = static_cast<int>(newid);
+        }
+    }
+
+    return true;
+}
+
+// Load_items_pre: MDD insert from file
+void Load_items_pre(const std::string& inst_name) {
+    std::ifstream file(inst_name);
+    if (!file.good()) return;
+
+    std::string line;
+    while (std::getline(file, line)) {
+        std::istringstream word(line);
+        std::string itm;
+        std::vector<int> temp_vec;
+        bool sgn = false;
+        while (word >> itm) {
+            int ditem;
+            try { ditem = std::stoi(itm); } catch (...) { continue; }
+            int absidx = std::abs(ditem) - 1;
+            if (absidx < 0 || absidx >= static_cast<int>(item_dic.size())) {
+                if (!sgn && ditem < 0) sgn = true;
+                continue;
+            }
+            if (item_dic[absidx] == -1) {
+                if (!sgn && ditem < 0) sgn = true;
+                continue;
+            }
+            if (ditem > 0) { ditem = item_dic[ditem - 1]; itmset_exists = true; }
+            else { ditem = -item_dic[-ditem - 1]; }
+            if (sgn) { if (ditem > 0) ditem = -ditem; sgn = false; }
+            temp_vec.push_back(ditem);
+        }
+        if (temp_vec.empty()) continue;
+        ++N;
+        M = std::max<unsigned>(M, temp_vec.size());
+        Build_MDD(temp_vec);
+    }
+}
+
+// Load_items: full MDD build
+bool Load_items(const std::string& inst_name) {
+    std::ifstream file(inst_name);
+    if (!file.good()) return false;
+
+    std::string line;
+    while (std::getline(file, line)) {
+        ++N;
+        std::istringstream word(line);
+        std::string itm;
+        std::vector<int> temp_vec;
+        while (word >> itm) {
+            int ditem;
+            try { ditem = std::stoi(itm); } catch (...) { continue; }
+            if (ditem > 0) itmset_exists = true;
+            unsigned int ad = static_cast<unsigned int>(std::abs(ditem));
+            if (L < ad) {
+                L = ad;
+                DFS.reserve(L);
+                while (DFS.size() < L)
+                    DFS.emplace_back(-int(DFS.size()) - 1);
+            }
+            temp_vec.push_back(ditem);
+        }
+        if (temp_vec.size() > M) M = temp_vec.size();
+        Build_MDD(temp_vec);
+    }
+    return true;
+}
+
+void ClearCollected()   { collected.clear(); }
+const std::vector<std::vector<int>>& GetCollected() { return collected; }
+
+} // namespace largebm
+

effspm/largebm/src/load_inst.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <cmath>
+#include <ctime>
+
+
+namespace largebm {
+    using namespace std;
+
+    // forward-declare Pattern (defined in freq_miner.hpp)
+    class Pattern;
+    
+     struct Arc; 
+    extern std::vector<Arc> Tree;                   // <-- add this
+    void Build_MDD(const std::vector<int>& seq);   
+    // ─── Entry points ─────────────────────────────────────────────────────────
+    bool Load_instance(const string& items_file, double thresh);
+    bool Preprocess(const string& fname, double thresh);
+    void Load_items_pre(const string& fname);
+    bool Load_items(const string& fname);
+    extern std::vector<int> inv_item_dic;
+    // Called by the Python‐wrapper when passing a Python list of lists
+    
+
+    // ─── Config globals (must match btminer types exactly) ────────────────────
+    extern string        out_file, folder;
+    extern bool          use_list;
+    extern bool          b_disp, b_write, use_dic, just_build, pre_pro, itmset_exists;
+    extern unsigned int  M, L, time_limit;
+    extern unsigned long long N, num_nodes, theta, E;
+    extern clock_t       start_time;
+   // extern std::vector<Arc>                 Tree;
+    // ─── Data for list-based (LargeBTMiner) mode ───────────────────────────────
+    extern std::vector<std::vector<int>> items;
+    extern std::vector<int>              item_dic;
+    extern std::vector<Pattern>          DFS;        // Pattern is now declared
+    extern std::vector<std::vector<int>> collected;
+        void ClearCollected();
+    const std::vector<std::vector<int>>& GetCollected();
+
+
+} // namespace largebm

effspm/largebm/src/utility.cpp

@@ -0,0 +1,45 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "load_inst.hpp"
+
+#include <vector>
+#include <ctime>
+#include <algorithm>
+
+namespace largebm {
+
+bool check_parent(unsigned long long cur_arc,
+                  unsigned long long str_pnt,
+                  unsigned long long start,
+                  std::vector<unsigned long long>& strpnt_vec)
+{
+    std::vector<unsigned long long> ancestors;
+    
+    unsigned long long cur_anct = Tree[cur_arc].anct;
+
+    while (Tree[cur_anct].itmset > Tree[str_pnt].itmset) {
+        if (Tree[cur_anct].item > 0)
+            ancestors.push_back(cur_anct);
+        cur_anct = Tree[cur_anct].anct;
+    }
+
+    if (Tree[cur_anct].itmset == Tree[str_pnt].itmset)
+        return true;
+    else {
+        for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+            for (unsigned long long i = start; i < strpnt_vec.size(); ++i) {
+                if (strpnt_vec[i] == *it)
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+// return elapsed time in seconds
+double give_time(std::clock_t ticks) {
+    return static_cast<double>(ticks) / CLOCKS_PER_SEC;
+}
+
+} // namespace largebm

effspm/largebm/src/utility.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <time.h>
+#include <string>
+#include "build_mdd.hpp"
+#include <ctime>
+
+namespace largebm {
+using namespace std;
+
+double give_time(std::clock_t kk);
+
+
+
+bool check_parent(unsigned long long int cur_arc, unsigned long long int str_pnt, unsigned long long int start, vector<unsigned long long int>& strpnt_vec);
+
+}

effspm/largehm/src/build_mdd.cpp

@@ -0,0 +1,174 @@
+// ─── effspm/largehm/src/build_mdd.cpp ─────────────────────────────────────────
+
+#include "build_mdd.hpp"
+
+// ─── Definitions of the extern globals declared in build_mdd.hpp ─────────────
+std::vector<largehm::Arc>       largehm::Tree;
+std::vector<largehm::VArc>      largehm::VTree;
+std::vector<largehm::CArc>      largehm::CTree;
+
+#include <vector>
+#include <iostream>
+#include <cmath>           // for std::abs
+#include <unordered_map>
+#include <cstdint>         // for std::uint64_t
+#include "load_inst.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+
+namespace largehm {
+
+//
+// ─── Build the MDD by sequentially calling Add_arc() then possibly Add_vec() ──
+//
+void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
+    // SANITY CHECK: show sizes before building
+    
+    std::unordered_map<int, std::uint64_t> ancest_map;
+    std::uint64_t last_arc = 0;
+    int itmset = 0;
+
+    // Insert each prefix item as an arc
+    for (auto it = items.begin(); it != items.end(); ++it) {
+        last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
+    }
+
+    // If there is a suffix beyond mlim, attach it via Add_vec()
+    if (!items_lim.empty()) {
+        Add_vec(items_lim, ancest_map, last_arc, itmset);
+    }
+}
+
+
+//
+// ─── Add_arc: insert a single “item” into the MDD under parent last_arc. ──────
+//
+int Add_arc(int item,
+            std::uint64_t last_arc,
+            int& itmset,
+            std::unordered_map<int, std::uint64_t>& ancest_map)
+{
+    // Ensure DFS is at least size |item|
+    size_t needed = static_cast<size_t>(std::abs(item));
+    if (DFS.size() < needed) {
+        size_t old = DFS.size();
+        DFS.resize(needed);
+        for (size_t i = old; i < needed; ++i) {
+            DFS[i] = Pattern(-static_cast<int>(i) - 1);
+        }
+    }
+
+    unsigned int anct = 0;
+    auto p = ancest_map.find(std::abs(item));
+    if (p != ancest_map.end()) {
+        anct = p->second;
+    }
+
+    if (item < 0) {
+        ++itmset;
+    }
+
+    std::uint64_t last_sibl = Tree[last_arc].chld;
+    if (last_sibl == 0) {
+        // No child yet: create a new Arc
+        Tree.emplace_back(item, itmset, anct);
+        last_sibl = Tree.size() - 1;
+        Tree[last_arc].chld = last_sibl;
+        if (anct == 0) {
+            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+        }
+    }
+    else {
+        // Traverse siblings until we find a match or append
+        while (Tree[last_sibl].item != item) {
+            if (Tree[last_sibl].sibl == 0) {
+                Tree.emplace_back(item, itmset, anct);
+                Tree[last_sibl].sibl = Tree.size() - 1;
+                last_sibl = Tree.size() - 1;
+                if (anct == 0) {
+                    DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+                }
+                break;
+            }
+            last_sibl = Tree[last_sibl].sibl;
+        }
+    }
+
+    if (anct == 0) {
+        ++DFS[std::abs(item) - 1].freq;
+    }
+    ++Tree[last_sibl].freq;
+    ancest_map[std::abs(item)] = last_sibl;
+    return static_cast<int>(last_sibl);
+}
+
+
+//
+// ─── Add_vec: attach the “items_lim” vector as children/vertical arcs ─────────
+//
+void Add_vec(std::vector<int>& items_lim,
+             std::unordered_map<int, std::uint64_t>& ancest_map,
+             std::uint64_t last_arc,
+             int itmset)
+{
+    // Ensure VDFS and DFS are at least size L
+    if (VDFS.size() < static_cast<size_t>(L)) {
+        size_t old = VDFS.size();
+        VDFS.resize(static_cast<size_t>(L));
+        for (size_t i = old; i < VDFS.size(); ++i) {
+            VDFS[i] = VPattern(static_cast<int>(i));
+        }
+    }
+    if (DFS.size() < static_cast<size_t>(L)) {
+        size_t old = DFS.size();
+        DFS.resize(static_cast<size_t>(L));
+        for (size_t i = old; i < DFS.size(); ++i) {
+            DFS[i] = Pattern(-static_cast<int>(i) - 1);
+        }
+    }
+
+    items_lim.shrink_to_fit();
+    std::vector<bool> counted(L, false);
+
+    // If this node has positive itmset (>0) or no CTree child yet, create first child entry
+    if (Tree[last_arc].itmset > 0 || Tree[last_arc].chld == 0) {
+        std::vector<std::uint64_t> ancest(L + 1, 0ULL);
+        for (auto& kv : ancest_map) {
+            ancest[kv.first - 1] = kv.second;
+            counted[kv.first - 1] = true;
+        }
+        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
+            int cur_itm = std::abs(items_lim[i]);
+            if (!counted[cur_itm - 1]) {
+                if (i + 1 < static_cast<int>(items_lim.size())) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1);
+                    VDFS[cur_itm - 1].seq_ID.push_back(CTree.size());
+                }
+                ++DFS[cur_itm - 1].freq;
+                counted[cur_itm - 1] = true;
+            }
+        }
+        CTree.emplace_back(ancest, items_lim);
+        Tree[last_arc].chld  = CTree.size() - 1;
+        Tree[last_arc].itmset = -itmset;
+    }
+    else {
+        // Normal “existing CTree child” path
+        auto& ancest = CTree[ Tree[last_arc].chld ].ancest;
+        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
+            int cur_itm = std::abs(items_lim[i]);
+            if (!counted[cur_itm - 1] && ancest[cur_itm - 1] == 0ULL) {
+                if (i + 1 < static_cast<int>(items_lim.size())) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(i + 1);
+                    VDFS[cur_itm - 1].seq_ID.push_back(VTree.size());
+                }
+                ++DFS[cur_itm - 1].freq;
+                counted[cur_itm - 1] = true;
+            }
+        }
+        VTree.emplace_back(items_lim, CTree[ Tree[last_arc].chld ].ancest.back());
+        CTree[ Tree[last_arc].chld ].ancest.back() = VTree.size();
+    }
+}
+
+} // namespace largehm

effspm/largehm/src/build_mdd.hpp

@@ -0,0 +1,93 @@
+#ifndef LARGEHM_BUILD_MDD_HPP
+#define LARGEHM_BUILD_MDD_HPP
+
+#include <vector>
+#include <unordered_map>
+#include <cstddef>          // for size_t
+#include <cstdint>          // for uint64_t
+
+#include "load_inst.hpp"    // defines L, DFS, VDFS, Tree, etc.
+#include "freq_miner.hpp"   // for Pattern, VPattern
+#include "utility.hpp"      // if you need check_parent or collected
+
+namespace largehm {
+
+//
+// ─── Types & Globals ─────────────────────────────────────────────────────────
+//
+
+struct Arc;
+struct VArc;
+struct CArc;
+
+extern std::vector<Arc>       Tree;
+extern std::vector<VArc>      VTree;
+extern std::vector<CArc>      CTree;
+
+//
+// ─── Public API ───────────────────────────────────────────────────────────────
+//
+
+void Build_MDD(std::vector<int>& items,
+               std::vector<int>& items_lim);
+
+//
+// ─── Internal Helpers ─────────────────────────────────────────────────────────
+//
+
+int Add_arc(int item,
+            std::uint64_t last_arc,
+            int& itmset,
+            std::unordered_map<int, std::uint64_t>& ancest_map);
+
+void Add_vec(std::vector<int>& items_lim,
+             std::unordered_map<int, std::uint64_t>& ancest_map,
+             std::uint64_t last_arc,
+             int itmset);
+
+//
+// ─── Struct Definitions ───────────────────────────────────────────────────────
+//
+
+struct Arc {
+    int                item;
+    int                itmset;
+    std::uint64_t      anct;
+    std::uint64_t      chld;
+    std::uint64_t      sibl;
+    unsigned long long freq;
+
+    Arc(int _item, int _itmset, std::uint64_t _anct)
+      : item(_item), itmset(_itmset), anct(_anct),
+        chld(0), sibl(0), freq(0u) {}
+};
+
+struct VArc {
+    std::vector<int>            seq;
+    std::uint64_t               sibl;
+    unsigned long long          freq;
+
+    explicit VArc(std::vector<int>& items, std::uint64_t _sibl)
+      : seq(), sibl(_sibl), freq(0u)
+    {
+        seq.swap(items);
+    }
+};
+
+struct CArc {
+    std::vector<std::uint64_t>  ancest;
+    std::vector<int>            seq;
+    unsigned long long          freq;
+
+    explicit CArc(std::vector<std::uint64_t>& _anc,
+                  std::vector<int>& items)
+      : ancest(), seq(), freq(0u)
+    {
+        ancest.swap(_anc);
+        seq.swap(items);
+    }
+};
+
+} // namespace largehm
+
+#endif // LARGEHM_BUILD_MDD_HPP