effspm 0.1.5__cp39-cp39-win_amd64.whl → 0.2.7__cp39-cp39-win_amd64.whl

effspm/btminer/src/build_mdd.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "load_inst.hpp"
+
+namespace btminer {
+
+void Build_MDD(std::vector<int>& items);
+
+class Arc {
+public:
+    int chld = -1;
+    int sibl = -1;
+    int freq = 0;
+    int anct;
+    int itmset;
+    int item;
+
+    Arc(int _itm, int _itmset, int _anc) {
+        itmset = _itmset;
+        anct = _anc;
+        item = _itm;
+    }
+
+    Arc(int _itm, int _anc) {
+        item = _itm;
+        anct = _anc;
+    }
+
+    Arc() {
+        chld = -1;
+        sibl = -1;
+        freq = 0;
+    }
+};
+
+extern std::vector<Arc> Tree;
+
+} 

effspm/btminer/src/freq_miner.cpp

@@ -0,0 +1,179 @@
+#include <iostream>
+#include <time.h>
+#include <vector>
+#include <fstream>
+#include <cmath>
+#include "freq_miner.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+
+namespace btminer {
+
+void Out_patt(std::vector<int>& seq, int freq);
+void Extend_patt(Pattern _patt);
+
+int num_patt = 0;
+
+void Freq_miner() {
+    std::vector<int> islist;
+    for (int i = 0; i < L; ++i) {
+        if (DFS[i].freq >= theta)
+            islist.push_back(i);
+    }
+
+    for (int i = 0; i < DFS.size(); ++i) {
+        DFS[i].ilist = islist;
+        DFS[i].slist = islist;
+    }
+
+    while (!DFS.empty() && give_time(clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta)
+            Extend_patt(DFS.back());
+        else
+            DFS.pop_back();
+    }
+}
+
+void Extend_patt(Pattern _patt) {
+    DFS.pop_back();
+    std::vector<bool> slist(L, 0);
+    std::vector<bool> ilist(L, 0);
+
+    for (auto it : _patt.slist) slist[it] = 1;
+    for (auto it : _patt.ilist) ilist[it] = 1;
+
+    int itmset_size = 1;
+    int last_neg = _patt.seq.size() - 1;
+    while (_patt.seq[last_neg] > 0) {
+        --last_neg;
+        ++itmset_size;
+    }
+
+    std::vector<Pattern> pot_patt(2 * L);
+    std::vector<int> DFS_patt_init, DFS_patt, DFS_numfound, last_strpnt(L, 0);
+
+    for (int pnt = 0; pnt < _patt.str_pnt.size(); ++pnt) {
+        DFS_patt_init.push_back(_patt.str_pnt[pnt]);
+        while (!DFS_patt_init.empty()) {
+            int cur_sibl = Tree[DFS_patt_init.back()].chld;
+            DFS_patt_init.pop_back();
+            while (cur_sibl != -1) {
+                int cur_itm = Tree[cur_sibl].item;
+                if (cur_itm < 0) {
+                    cur_itm = -cur_itm;
+                    if (slist[cur_itm - 1]) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                    }
+                } else {
+                    if (ilist[cur_itm - 1]) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1)
+                        DFS_patt_init.push_back(cur_sibl);
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+
+        for (auto it : _patt.ilist)
+            last_strpnt[it] = pot_patt[it].str_pnt.size();
+
+        while (!DFS_patt.empty()) {
+            int cur_sibl = Tree[DFS_patt.back()].chld;
+            int num_found = DFS_numfound.back();
+            DFS_patt.pop_back();
+            DFS_numfound.pop_back();
+            while (cur_sibl != -1) {
+                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 - 1].str_pnt))) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm - 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 + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (!_patt.ilist.empty()) {
+                            DFS_numfound.push_back((num_found < itmset_size && cur_itm == abs(_patt.seq[last_neg + num_found])) ? num_found + 1 : 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 + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (!_patt.ilist.empty()) {
+                            DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                        }
+                    }
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+    }
+
+    std::vector<int> slistp, ilistp;
+    for (auto it : _patt.ilist) if (pot_patt[it].freq >= theta) ilistp.push_back(it);
+    for (auto it : _patt.slist) if (pot_patt[it + L].freq >= theta) slistp.push_back(it);
+
+    for (auto it : ilistp) {
+        pot_patt[it].str_pnt.shrink_to_fit();
+        DFS.push_back(pot_patt[it]);
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(it + 1);
+        DFS.back().seq.shrink_to_fit();
+        DFS.back().slist = slistp;
+        DFS.back().ilist = ilistp;
+        if (b_disp || b_write) Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+
+    for (auto it : slistp) {
+        pot_patt[it + L].str_pnt.shrink_to_fit();
+        DFS.push_back(pot_patt[it + L]);
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(-it - 1);
+        DFS.back().seq.shrink_to_fit();
+        DFS.back().slist = slistp;
+        DFS.back().ilist = slistp;
+        if (b_disp || b_write) Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+}
+
+void Out_patt(std::vector<int>& seq, int freq) {
+    
+    btminer::collected.push_back(seq);   // make pattern visible to Python
+
+    std::ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    for (int ii = 0; ii < seq.size(); ii++) {
+        if (b_disp) std::cout << seq[ii] << " ";
+        if (b_write) file_o << seq[ii] << " ";
+    }
+    if (b_disp) std::cout << std::endl;
+    if (b_write) file_o << std::endl;
+
+    if (b_disp) std::cout << "************** Freq: " << freq << std::endl;
+    if (b_write) {
+        file_o << "************** Freq: " << freq << std::endl;
+        file_o.close();
+    }
+}
+
+} // namespace btminer

effspm/btminer/src/freq_miner.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <vector>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+
+namespace btminer {
+
+void Freq_miner();
+
+class Pattern {
+public:
+    std::vector<int> seq;
+    std::vector<int> str_pnt;
+    std::vector<int> slist;
+    std::vector<int> ilist;
+    int freq;
+
+    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;
+    }
+
+    Pattern() {
+        freq = 0;
+    }
+};
+
+extern int num_patt;
+extern int num_max_patt;
+extern std::vector<Pattern> DFS;
+
+} // namespace btminer

effspm/btminer/src/load_inst.cpp

@@ -0,0 +1,200 @@
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <cmath>
+#include <ctime>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+
+namespace btminer {
+
+using namespace std;
+
+extern int num_nodes, cur_node;
+
+
+map<string, int> item_map;
+map<int, string> item_map_rev;
+vector<int> freq;
+vector<int> item_dic;
+
+void Load_items_pre(string& inst_name);
+bool Load_items(string& inst_name);
+bool Preprocess(string& inst, double thresh);
+
+
+
+
+bool Load_instance(string& items_file, double thresh) {
+    clock_t kk = clock();
+    Tree.emplace_back(0, 0, 0);
+
+    if (pre_pro) {
+        if (!Preprocess(items_file, thresh))
+            return false;
+
+        cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
+
+        DFS.reserve(L);
+        for (int i = 0; i < L; ++i)
+            DFS.emplace_back(-i - 1);
+
+        kk = clock();
+        Load_items_pre(items_file);
+    } else if (!Load_items(items_file))
+        return false;
+    else {
+        theta = (thresh < 1) ? ceil(thresh * N * N_mult) : thresh;
+    }
+
+    cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+    cout << "Found " << N * N_mult << " sequence, with max line len " << M << ", and " << L << " items, and " << E << " enteries\n";
+    cout << "Total MDD nodes: " << Tree.size() << endl;
+
+    return true;
+}
+
+bool Preprocess(string& inst, double thresh) {
+    ifstream file(inst);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int size_m, ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        vector<bool> counted(L, 0);
+        istringstream word(line);
+        string itm;
+        while (word >> itm) {
+            ditem = stoi(itm);
+            if (L < abs(ditem)) L = abs(ditem);
+            while (freq.size() < L) {
+                freq.push_back(0);
+                counted.push_back(0);
+            }
+            if (!counted[abs(ditem) - 1]) {
+                ++freq[abs(ditem) - 1];
+                counted[abs(ditem) - 1] = 1;
+            }
+        }
+    }
+
+    theta = (thresh < 1) ? ceil(thresh * N * N_mult) : thresh;
+
+    int real_L = 0;
+    item_dic = vector<int>(L, -1);
+    for (int i = 0; i < L; ++i) {
+        if (freq[i] >= theta)
+            item_dic[i] = ++real_L;
+    }
+
+    cout << "Original number of items: " << L << " Reduced to: " << real_L << endl;
+    L = real_L;
+    N = 0;
+    return true;
+}
+
+void Load_items_pre(string& inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) return;
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        bool sgn = 0;
+        while (word >> itm) {
+            if (use_dic) {
+                auto it = item_map.find(itm);
+                if (it == item_map.end()) {
+                    item_map[itm] = ++L;
+                    item_map_rev[L] = itm;
+                    ditem = L;
+                } else {
+                    ditem = it->second;
+                }
+            } else {
+                ditem = stoi(itm);
+            }
+
+            if (pre_pro && freq.size() > abs(ditem) - 1 && freq[abs(ditem) - 1] < theta) {
+                if (!sgn)
+                    sgn = ditem < 0;
+                continue;
+            } else if (pre_pro) {
+                ditem = (ditem > 0) ? item_dic[ditem - 1] : -item_dic[-ditem - 1];
+            }
+
+            if (sgn && ditem > 0)
+                ditem = -ditem;
+            sgn = 0;
+
+            temp_vec.push_back(ditem);
+        }
+
+        if (temp_vec.empty()) continue;
+
+        ++N;
+        if (temp_vec.size() > M) M = temp_vec.size();
+
+        E += temp_vec.size();  // <-- make sure E gets incremented
+        Build_MDD(temp_vec);
+    }
+}
+
+bool Load_items(string& inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        while (word >> itm) {
+            if (use_dic) {
+                auto it = item_map.find(itm);
+                if (it == item_map.end()) {
+                    item_map[itm] = ++L;
+                    item_map_rev[L] = itm;
+                    ditem = L;
+                } else {
+                    ditem = it->second;
+                }
+            } else {
+                ditem = stoi(itm);
+                if (L < abs(ditem)) {
+                    L = abs(ditem);
+                    while (DFS.size() < L && !just_build) {
+                        DFS.reserve(L);
+                        DFS.emplace_back(-DFS.size() - 1);
+                    }
+                }
+            }
+            temp_vec.push_back(ditem);
+        }
+
+        if (temp_vec.size() > M) M = temp_vec.size();
+        E += temp_vec.size();  // <-- make sure E gets incremented
+        Build_MDD(temp_vec);
+    }
+    return true;
+}
+
+} // namespace btminer

effspm/btminer/src/load_inst.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <ctime>
+
+namespace btminer {
+
+bool Load_instance(std::string& items_file, double thresh);
+
+extern std::string out_file, folder;
+
+extern bool b_disp, b_write, use_dic, just_build, pre_pro;
+
+extern int N, M, L, theta, num_nodes, M_mult, N_mult, time_limit, cur_node;
+
+extern clock_t start_time;
+
+
+
+} // namespace btminer

effspm/btminer/src/utility.cpp

@@ -0,0 +1,65 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "load_inst.hpp"
+#include <iostream>
+
+namespace btminer {
+
+// ─── Global definitions ──────────────────────────────────────────
+bool use_dic   = false;
+std::vector<std::vector<int>> items;
+bool use_list  = false;
+bool just_build = false;
+int  E = 0, M = 0, N = 0, L = 0, theta = 0;
+std::vector<Pattern> DFS;
+clock_t start_time = 0;
+bool b_disp = false, b_write = false;
+std::string out_file;
+
+bool pre_pro   = true;
+int  N_mult    = 1, M_mult   = 1;
+int  time_limit = 30 * 3600;
+
+// buffer of mined patterns returned to Python
+std::vector<std::vector<int>> collected;
+
+void ClearCollected()                       { collected.clear(); }
+const std::vector<std::vector<int>>& GetCollected() { return collected; }
+
+// ─── Utility functions ───────────────────────────────────────────
+int find_ID(std::vector<int>& vec, int itm)
+{
+    int plc = 0;
+    while (plc < static_cast<int>(vec.size()) && vec[plc] != itm) ++plc;
+    return (plc == static_cast<int>(vec.size())) ? -1 : plc;
+}
+
+bool check_parent(int cur_arc, int str_pnt, int start,
+                  std::vector<int>& strpnt_vec)
+{
+    std::vector<int> ancestors;
+    int 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 (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it)
+        for (int i = start; i < static_cast<int>(strpnt_vec.size()); ++i)
+            if (strpnt_vec[i] == *it) return true;
+
+    return false;
+}
+
+bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos)
+{
+    for (size_t i = pos; i < vec.size(); ++i)
+        if (vec[i] == pnt) return true;
+    return false;
+}
+
+double give_time(clock_t kk) { return double(kk) / CLOCKS_PER_SEC; }
+
+} // namespace btminer

effspm/btminer/src/utility.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+#include <ctime>
+#include <string>
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+#include "load_inst.hpp"
+
+namespace btminer {
+
+// === Utility function declarations ===
+bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos);
+int find_ID(std::vector<int>& vec, int itm);
+double give_time(clock_t kk);
+bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec);
+
+// === Global variables (DECLARATIONS ONLY) ===
+
+extern bool use_list;
+extern bool just_build;
+extern int E, M, N, L, theta;
+extern std::vector<Pattern> DFS;
+extern clock_t start_time;
+extern bool b_disp, b_write;
+extern std::string out_file;
+extern bool pre_pro;
+extern int N_mult, M_mult;
+extern int time_limit;
+extern std::vector<std::vector<int>> items;
+
+ extern std::vector<std::vector<int>> collected;
+
+void ClearCollected();
+const std::vector<std::vector<int>>& GetCollected();
+
+}
+
+
+// namespace btminer

effspm/freq_miner.hpp

@@ -1,7 +1,11 @@
 #pragma once
-
+#include <vector>
 #include "load_inst.hpp"
+#include <cstdlib> 
+#include <cmath> 
+#include <cstddef>  // for std::size_t
 
+using namespace std;
 void Freq_miner();
 void Out_patt(std::vector<int>& seq, unsigned int freq);
 
@@ -20,7 +24,8 @@ public:
 
 	Pattern(vector<int>& _seq, int item) {
 		seq.reserve(_seq.size());
-		for (int i = 0; i < _seq.size(); ++i)
+		for (std::size_t i = 0; i < _seq.size(); ++i)
+
 			seq.push_back(_seq[i]);
 		seq.push_back(item);
 		freq = 0;