effspm 0.1.5__cp310-cp310-win_amd64.whl → 0.3.0__cp310-cp310-win_amd64.whl

effspm/largebm/src/freq_miner.cpp

@@ -0,0 +1,299 @@
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstdlib>  // ensure std::abs(int)
+#include "freq_miner.hpp"
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+
+namespace largebm {
+
+unsigned long long int num_patt = 0;
+std::vector<bool> ilist;
+std::vector<bool> slist;
+std::vector<int>  DFS_numfound;
+Pattern            _patt;
+
+static void Out_patt(const std::vector<int>& seq, unsigned long long freq);
+static void Extend_patt(Pattern& patt);
+
+void Freq_miner() {
+    collected.clear();
+    num_patt = 0;
+
+    if (static_cast<int>(DFS.size()) < static_cast<int>(L)) {
+        DFS.resize(L);
+    }
+
+    std::vector<int> list;
+
+    if (use_list) {
+        std::vector<int> empty_pref;
+        Freq_miner_list(items, empty_pref, theta, collected);
+        return;
+    }
+
+    // seed candidates by DFS[i].freq
+    for (int i = 0; i < static_cast<int>(L); ++i) {
+        if (DFS[i].freq >= theta) {
+            list.push_back(-i - 1);
+            if (itmset_exists) list.push_back(i + 1);
+        }
+    }
+
+    for (size_t i = 0; i < DFS.size(); ++i) {
+        DFS[i].list = list;
+    }
+
+    while (!DFS.empty() && give_time(std::clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta) {
+            Extend_patt(DFS.back());
+        } else {
+            DFS.pop_back();
+        }
+    }
+}
+
+static void Extend_patt(Pattern& _pattern) {
+    std::swap(_patt, _pattern);
+    DFS.pop_back();
+
+    slist = std::vector<bool>(L, false);
+    bool ilist_nempty = false;
+
+    if (itmset_exists) {
+        ilist = std::vector<bool>(L, false);
+        for (size_t i = 0; i < _patt.list.size(); ++i) {
+            int v = _patt.list[i];
+            if (v < 0) slist[-v - 1] = true;
+            else { ilist[v - 1] = true; ilist_nempty = true; }
+        }
+    } else {
+        for (size_t i = 0; i < _patt.list.size(); ++i) {
+            int v = _patt.list[i];
+            slist[-v - 1] = true;
+        }
+    }
+
+    int itmset_size = 1;
+    int last_neg = static_cast<int>(_patt.seq.size()) - 1;
+    while (_patt.seq[last_neg] > 0) {
+        --last_neg;
+        ++itmset_size;
+    }
+
+    std::vector<Pattern>               pot_patt(L + (ilist_nempty ? L : 0));
+    std::vector<unsigned long long>    DFS_patt_init;
+    std::vector<unsigned long long>    DFS_patt;
+    if (ilist_nempty) DFS_numfound.clear();
+    std::vector<unsigned long long>    last_strpnt(L, 0);
+
+    for (unsigned long long pnt = 0; pnt < _patt.str_pnt.size(); ++pnt) {
+        DFS_patt_init.push_back(_patt.str_pnt[pnt]);
+        while (!DFS_patt_init.empty()) {
+            unsigned long long cur_sibl = Tree[DFS_patt_init.back()].chld;
+            DFS_patt_init.pop_back();
+            while (cur_sibl != 0) {
+                int cur_itm = Tree[cur_sibl].item;
+                if (cur_itm < 0) {
+                    cur_itm = -cur_itm;
+                    if (slist[cur_itm - 1]) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        if (Tree[cur_sibl].chld != 0)
+                            pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != static_cast<unsigned long long>(-1)) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (ilist_nempty) {
+                            DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                        }
+                    }
+                } else {
+                    if (ilist[cur_itm - 1]) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        if (Tree[cur_sibl].chld != 0)
+                            pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != static_cast<unsigned long long>(-1))
+                        DFS_patt_init.push_back(cur_sibl);
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+        if (ilist_nempty) {
+            for (int i = 0; i < static_cast<int>(L); ++i) {
+                if (ilist[i]) last_strpnt[i] = pot_patt[i + L].str_pnt.size();
+            }
+        }
+        while (!DFS_patt.empty()) {
+            unsigned long long cur_sibl = Tree[DFS_patt.back()].chld;
+            DFS_patt.pop_back();
+            int num_found = 0;
+            if (ilist_nempty) { num_found = DFS_numfound.back(); DFS_numfound.pop_back(); }
+            while (cur_sibl != 0) {
+                int cur_itm = Tree[cur_sibl].item;
+                if (cur_itm > 0) {
+                    if (num_found == itmset_size &&
+                        ilist[cur_itm - 1] &&
+                        (Tree[Tree[cur_sibl].anct].itmset < Tree[_patt.str_pnt[pnt]].itmset ||
+                         !check_parent(cur_sibl, _patt.str_pnt[pnt],
+                                       last_strpnt[cur_itm - 1],
+                                       pot_patt[cur_itm + L - 1].str_pnt))) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        if (Tree[cur_sibl].chld != 0)
+                            pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (slist[cur_itm - 1] &&
+                        Tree[Tree[cur_sibl].anct].itmset <= Tree[_patt.str_pnt[pnt]].itmset) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        if (Tree[cur_sibl].chld != 0)
+                            pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != static_cast<unsigned long long>(-1)) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (ilist_nempty) {
+                            if (num_found < itmset_size &&
+                                cur_itm == std::abs(_patt.seq[last_neg + num_found])) {
+                                DFS_numfound.push_back(num_found + 1);
+                            } else {
+                                DFS_numfound.push_back(num_found);
+                            }
+                        }
+                    }
+                } else {
+                    cur_itm = -cur_itm;
+                    if (slist[cur_itm - 1] &&
+                        Tree[Tree[cur_sibl].anct].itmset <= Tree[_patt.str_pnt[pnt]].itmset) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        if (Tree[cur_sibl].chld != 0)
+                            pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != static_cast<unsigned long long>(-1)) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (ilist_nempty) {
+                            DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                        }
+                    }
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+    }
+
+    std::vector<int> ilistp;
+    std::vector<int> slistp;
+    for (size_t i = 0; i < _patt.list.size(); ++i) {
+        int v = _patt.list[i];
+        int idx = (v < 0) ? (-v - 1) : (v - 1 + static_cast<int>(L));
+        if (v > 0 && pot_patt[idx].freq >= theta) {
+            ilistp.push_back(v);
+        } else if (v < 0 && pot_patt[-v - 1].freq >= theta) {
+            if (itmset_exists) slistp.push_back(-v);
+            ilistp.push_back(v);
+            slistp.push_back(v);
+        }
+    }
+
+    for (size_t i = 0; i < ilistp.size(); ++i) {
+        int v = ilistp[i];
+        int p = (v < 0) ? (-v - 1) : (v - 1 + static_cast<int>(L));
+        DFS.emplace_back();
+        std::swap(DFS.back(), pot_patt[p]);
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(v);
+        DFS.back().list = (v < 0) ? slistp : ilistp;
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+}
+
+static void Out_patt(const std::vector<int>& seq, unsigned long long freq) {
+    if (!(b_disp || b_write)) {
+        collected.push_back(seq);
+        return;
+    }
+    std::ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    for (size_t i = 0; i < seq.size(); ++i) {
+        int v = seq[i];
+        if (b_disp) std::cout << v << ' ';
+        if (b_write) file_o << v << ' ';
+    }
+    if (b_disp) std::cout << '\n';
+    if (b_write) file_o << '\n';
+
+    if (b_disp) std::cout << "************** Freq: " << freq << '\n';
+    if (b_write) {
+        file_o << "************** Freq: " << freq << '\n';
+        file_o.close();
+    }
+    collected.push_back(seq);
+}
+
+void Freq_miner_list(const std::vector<std::vector<int>>& db,
+                     std::vector<int>& prefix,
+                     unsigned long long minsup,
+                     std::vector<std::vector<int>>& out) {
+    std::unordered_map<int, unsigned long long> freq;
+    for (size_t sidx = 0; sidx < db.size(); ++sidx) {
+        const std::vector<int>& seq = db[sidx];
+        std::unordered_set<int> seen;
+        for (size_t i = 0; i < seq.size(); ++i) {
+            int x = seq[i];
+            if (seen.insert(x).second) ++freq[x];
+        }
+    }
+
+    std::vector<std::pair<int, unsigned long long> > cand;
+    cand.reserve(freq.size());
+    for (std::unordered_map<int, unsigned long long>::iterator it = freq.begin();
+         it != freq.end(); ++it) {
+        if (it->second >= minsup) cand.push_back(*it);
+    }
+
+    std::sort(cand.begin(), cand.end(),
+              [](const std::pair<int, unsigned long long>& a,
+                 const std::pair<int, unsigned long long>& b) {
+                  return std::abs(a.first) < std::abs(b.first);
+              });
+
+    for (size_t k = 0; k < cand.size(); ++k) {
+        int item = cand[k].first;
+        prefix.push_back(item);
+
+        if (use_dic) {
+            std::vector<int> unmapped;
+            unmapped.reserve(prefix.size());
+            for (size_t i = 0; i < prefix.size(); ++i) {
+                int cid = prefix[i];
+                int abs_id = std::abs(cid);
+                int o = inv_item_dic[abs_id];
+                unmapped.push_back(cid < 0 ? -o : o);
+            }
+            out.push_back(unmapped);
+        } else {
+            out.push_back(prefix);
+        }
+
+        std::vector<std::vector<int> > proj;
+        proj.reserve(db.size());
+        for (size_t s = 0; s < db.size(); ++s) {
+            const std::vector<int>& svec = db[s];
+            std::vector<int>::const_iterator it =
+                std::find(svec.begin(), svec.end(), item);
+            if (it != svec.end()) {
+                ++it;
+                if (it != svec.end()) proj.push_back(std::vector<int>(it, svec.end()));
+            }
+        }
+
+        if (!proj.empty()) Freq_miner_list(proj, prefix, minsup, out);
+        prefix.pop_back();
+    }
+}
+
+} // namespace largebm

effspm/largebm/src/freq_miner.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include <vector>
+
+namespace largebm {
+
+class Pattern {
+public:
+    std::vector<int> seq;
+    std::vector<unsigned long long> str_pnt;
+    std::vector<int> list;
+    unsigned long long freq = 0;
+
+    Pattern() = default;
+    Pattern(std::vector<int>& _seq, int item) {
+        seq.swap(_seq);
+        seq.push_back(item);
+        freq = 0;
+    }
+    Pattern(int item) {
+        seq.push_back(item);
+        freq = 0;
+    }
+};
+
+void Freq_miner();
+void Freq_miner_list(const std::vector<std::vector<int>>& db,
+                     std::vector<int>& prefix,
+                     unsigned long long theta,
+                     std::vector<std::vector<int>>& out);
+
+extern unsigned long long int num_patt;
+extern std::vector<bool> ilist;
+extern std::vector<bool> slist;
+extern std::vector<int>  DFS_numfound;
+extern Pattern            _patt;
+
+} // namespace largebm

effspm/largebm/src/load_inst.cpp

@@ -0,0 +1,224 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
+
+namespace largebm {
+
+// ── single definitions of globals ─────────────────────────────────
+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(seq);
+    }
+}
+
+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;
+        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, minsup)) return false;
+        kk = std::clock();
+        Load_items(items_file);
+    }
+
+    // ensure DFS size
+    if (DFS.size() < L) {
+        DFS.reserve(L);
+        while (DFS.size() < L) {
+            DFS.emplace_back(-int(DFS.size()) - 1);
+        }
+    }
+
+    // SAFETY — seed any zeroed singletons from their str_pnt list
+    for (unsigned int i = 0; i < L && i < DFS.size(); ++i) {
+        if (DFS[i].freq == 0 && !DFS[i].str_pnt.empty()) {
+            DFS[i].freq = static_cast<unsigned long long>(DFS[i].str_pnt.size());
+        }
+    }
+
+    return true;
+}
+
+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;
+}
+
+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);
+    }
+}
+
+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,35 @@
+#pragma once
+#include <vector>
+#include <string>
+#include <ctime>
+
+namespace largebm {
+
+class Pattern; // forward
+// [2025-10-25 NEW]: match the real definition (class, not struct) to avoid ABI warnings
+class Arc;     // was: struct Arc;
+
+// Config & state (single definitions in load_inst.cpp)
+extern std::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 std::clock_t       start_time;
+
+extern std::vector<std::vector<int>> items;
+extern std::vector<int>              item_dic;
+extern std::vector<int>              inv_item_dic;
+extern std::vector<Pattern>          DFS;
+extern std::vector<std::vector<int>> collected;
+
+// Loader API
+bool Load_instance(const std::string& items_file, double thresh);
+bool Preprocess(const std::string& fname, double thresh);
+void Load_items_pre(const std::string& fname);
+bool Load_items(const std::string& fname);
+
+void ClearCollected();
+const std::vector<std::vector<int>>& GetCollected();
+
+} // namespace largebm

effspm/largebm/src/utility.cpp

@@ -0,0 +1,35 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include <vector>
+
+namespace largebm {
+
+double give_time(std::clock_t ticks) {
+    return static_cast<double>(ticks) / CLOCKS_PER_SEC;
+}
+
+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;
+
+    for (std::vector<unsigned long long>::reverse_iterator 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;
+}
+
+} // namespace largebm

effspm/largebm/src/utility.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <vector>
+#include <ctime>
+
+namespace largebm {
+
+double give_time(std::clock_t ticks);
+
+// Check if `str_pnt` is an ancestor of `cur_arc` respecting itemset boundaries
+bool check_parent(unsigned long long cur_arc,
+                  unsigned long long str_pnt,
+                  unsigned long long start,
+                  std::vector<unsigned long long>& strpnt_vec);
+
+} // namespace largebm