effspm 0.2.8__cp39-cp39-win_amd64.whl → 0.3.3__cp39-cp39-win_amd64.whl

effspm/btminer/src/build_mdd.cpp

@@ -1,26 +1,46 @@
 #include <vector>
 #include <iostream>
 #include <unordered_map>
-#include "load_inst.hpp"
+#include <cstdlib>
+#include <cmath>
+
+#include "load_inst.hpp"   // ← has: extern unsigned long long E;
 #include "build_mdd.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
 
 namespace btminer {
 
-int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& ancest_map);
-std::vector<Arc> Tree;
+using std::vector;
+using std::unordered_map;
+using std::abs;
+
+static int Add_arc(int item,
+                   int last_arc,
+                   int& itmset,
+                   unordered_map<int, int>& ancest_map);
+
+vector<Arc> Tree;   // professor had this global
+
+void Build_MDD(vector<int>& items) {
+    unordered_map<int, int> ancest_map;
+
+    int last_arc = 0;
+    int itmset   = 0;
 
-void Build_MDD(std::vector<int>& items) {
-    std::unordered_map<int, int> ancest_map;
-    int last_arc = 0, itmset = 0;
-    for (auto it = items.begin(); it != items.end(); ++it)
-        last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
+    for (int item : items) {
+        ++E;   // ✅ count this entry, just like prefix-projection does
+        last_arc = Add_arc(item, last_arc, itmset, ancest_map);
+    }
 }
 
-int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& ancest_map) {
+static int Add_arc(int item,
+                   int last_arc,
+                   int& itmset,
+                   unordered_map<int, int>& ancest_map) {
+
     int anct;
-    auto p = ancest_map.find(abs(item));
+    auto p = ancest_map.find(std::abs(item));
     if (p == ancest_map.end())
         anct = 0;
     else
@@ -32,19 +52,23 @@ int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& a
     int last_sibl = Tree[last_arc].chld;
 
     if (last_sibl == -1) {
+        // create child
         Tree.emplace_back(item, itmset, anct);
-        last_sibl = Tree.size() - 1;
+        last_sibl = static_cast<int>(Tree.size()) - 1;
         Tree[last_arc].chld = last_sibl;
+
         if (anct == 0)
-            DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+
     } else {
+        // walk siblings
         while (Tree[last_sibl].item != item) {
             if (Tree[last_sibl].sibl == -1) {
                 Tree.emplace_back(item, itmset, anct);
-                Tree[last_sibl].sibl = Tree.size() - 1;
-                last_sibl = Tree.size() - 1;
+                Tree[last_sibl].sibl = static_cast<int>(Tree.size()) - 1;
+                last_sibl            = static_cast<int>(Tree.size()) - 1;
                 if (anct == 0)
-                    DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+                    DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
                 break;
             }
             last_sibl = Tree[last_sibl].sibl;
@@ -52,10 +76,11 @@ int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& a
     }
 
     if (anct == 0)
-        ++DFS[abs(item) - 1].freq;
+        ++DFS[std::abs(item) - 1].freq;
 
     ++Tree[last_sibl].freq;
-    ancest_map[abs(item)] = last_sibl;
+
+    ancest_map[std::abs(item)] = last_sibl;
 
     return last_sibl;
 }

effspm/btminer/src/build_mdd.hpp

@@ -6,7 +6,9 @@
 
 namespace btminer {
 
-void Build_MDD(std::vector<int>& items);
+using std::vector;
+
+void Build_MDD(vector<int>& items);
 
 class Arc {
 public:
@@ -17,24 +19,16 @@ public:
     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;
-    }
+    Arc(int _itm, int _itmset, int _anc)
+        : chld(-1), sibl(-1), freq(0), anct(_anc), itmset(_itmset), item(_itm) {}
+
+    // sometimes professor used this shorter ctor
+    Arc(int _itm, int _anc)
+        : chld(-1), sibl(-1), freq(0), anct(_anc), itmset(0), item(_itm) {}
+
+    Arc() = default;
 };
 
-extern std::vector<Arc> Tree;
+extern vector<Arc> Tree;
 
-} 
+} // namespace btminer

effspm/btminer/src/freq_miner.cpp

@@ -1,27 +1,59 @@
+// effspm/btminer/src/freq_miner.cpp
 #include <iostream>
+#include <fstream>      // for ofstream
 #include <time.h>
-#include <vector>
-#include <fstream>
-#include <cmath>
 #include "freq_miner.hpp"
 #include "build_mdd.hpp"
 #include "utility.hpp"
+#include "load_inst.hpp"
 
 namespace btminer {
 
-void Out_patt(std::vector<int>& seq, int freq);
-void Extend_patt(Pattern _patt);
+using namespace std;
 
+// professor logic needs these forward decls
+static void Out_patt(vector<int>& seq, int freq);
+static void Extend_patt(Pattern _patt);
+
+// ✅ define ONLY num_patt here
 int num_patt = 0;
 
+// ✅ here we ONLY REFER to DFS (real one lives in load_inst.cpp)
+extern std::vector<Pattern> DFS;
+
+// ✅ NEW: actual storage for collected BT patterns
+std::vector<std::vector<int>> collectedPatterns;
+
+// ------------------------------------------------------------
+// helper API
+// ------------------------------------------------------------
+void ClearCollected() {
+    collectedPatterns.clear();
+    // optional: keep some capacity
+    collectedPatterns.reserve(512);
+}
+
+const std::vector<std::vector<int>>& GetCollected() {
+    return collectedPatterns;
+}
+
+// ------------------------------------------------------------
+// main entry
+// ------------------------------------------------------------
 void Freq_miner() {
-    std::vector<int> islist;
+
+    // every run should start clean
+    ClearCollected();
+    num_patt = 0;
+
+    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) {
+    for (int i = 0; i < static_cast<int>(DFS.size()); ++i) {
         DFS[i].ilist = islist;
         DFS[i].slist = islist;
     }
@@ -34,13 +66,20 @@ void Freq_miner() {
     }
 }
 
-void Extend_patt(Pattern _patt) {
+// ------------------------------------------------------------
+// recursive extension
+// ------------------------------------------------------------
+static 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;
+    vector<bool> slist(L, 0);
+    vector<bool> ilist(L, 0);
+
+    for (vector<int>::iterator it = _patt.slist.begin(); it != _patt.slist.end(); ++it)
+        slist[*it] = 1;
+    for (vector<int>::iterator it = _patt.ilist.begin(); it != _patt.ilist.end(); ++it)
+        ilist[*it] = 1;
 
     int itmset_size = 1;
     int last_neg = _patt.seq.size() - 1;
@@ -49,10 +88,13 @@ void Extend_patt(Pattern _patt) {
         ++itmset_size;
     }
 
-    std::vector<Pattern> pot_patt(2 * L);
-    std::vector<int> DFS_patt_init, DFS_patt, DFS_numfound, last_strpnt(L, 0);
+    vector<Pattern> pot_patt(2 * L);
+    vector<int> DFS_patt_init;
+    vector<int> DFS_patt;
+    vector<int> DFS_numfound;
+    vector<int> last_strpnt(L, 0);
 
-    for (int pnt = 0; pnt < _patt.str_pnt.size(); ++pnt) {
+    for (int pnt = 0; pnt < static_cast<int>(_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;
@@ -67,9 +109,15 @@ void Extend_patt(Pattern _patt) {
                     }
                     if (Tree[cur_sibl].chld != -1) {
                         DFS_patt.push_back(cur_sibl);
-                        DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                        if (!_patt.ilist.empty()) {
+                            if (cur_itm == -_patt.seq[last_neg])
+                                DFS_numfound.push_back(1);
+                            else
+                                DFS_numfound.push_back(0);
+                        }
                     }
-                } else {
+                }
+                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);
@@ -81,8 +129,8 @@ void Extend_patt(Pattern _patt) {
             }
         }
 
-        for (auto it : _patt.ilist)
-            last_strpnt[it] = pot_patt[it].str_pnt.size();
+        for (vector<int>::iterator it = _patt.ilist.begin(); it != _patt.ilist.end(); ++it)
+            last_strpnt[*it] = pot_patt[*it].str_pnt.size();
 
         while (!DFS_patt.empty()) {
             int cur_sibl = Tree[DFS_patt.back()].chld;
@@ -92,9 +140,13 @@ void Extend_patt(Pattern _patt) {
             while (cur_sibl != -1) {
                 int cur_itm = Tree[cur_sibl].item;
                 if (cur_itm > 0) {
-                    if (num_found == itmset_size && ilist[cur_itm - 1] &&
+                    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))) {
+                         !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);
                     }
@@ -105,10 +157,14 @@ void Extend_patt(Pattern _patt) {
                     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);
+                            if (num_found < itmset_size && cur_itm == abs(_patt.seq[last_neg + num_found]))
+                                DFS_numfound.push_back(num_found + 1);
+                            else
+                                DFS_numfound.push_back(num_found);
                         }
                     }
-                } else {
+                }
+                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;
@@ -117,7 +173,10 @@ void Extend_patt(Pattern _patt) {
                     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);
+                            if (cur_itm == -_patt.seq[last_neg])
+                                DFS_numfound.push_back(1);
+                            else
+                                DFS_numfound.push_back(0);
                         }
                     }
                 }
@@ -126,52 +185,78 @@ void Extend_patt(Pattern _patt) {
         }
     }
 
-    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);
+    vector<int> slistp;
+    vector<int> ilistp;
+
+    for (vector<int>::iterator it = _patt.ilist.begin(); it != _patt.ilist.end(); ++it) {
+        if (pot_patt[*it].freq >= theta)
+            ilistp.push_back(*it);
+    }
 
-    for (auto it : ilistp) {
-        pot_patt[it].str_pnt.shrink_to_fit();
-        DFS.push_back(pot_patt[it]);
+    for (vector<int>::iterator it = _patt.slist.begin(); it != _patt.slist.end(); ++it) {
+        if (pot_patt[(*it) + L].freq >= theta)
+            slistp.push_back(*it);
+    }
+
+    // ----- positive extensions -----
+    for (vector<int>::iterator it = ilistp.begin(); it != ilistp.end(); ++it) {
+        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.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);
+
+        // print/write + collect
+        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]);
+    // ----- itemset (negative) extensions -----
+    for (vector<int>::iterator it = slistp.begin(); it != slistp.end(); ++it) {
+        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.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);
+
+        // print/write + collect
+        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
+// ------------------------------------------------------------
+// final pattern printer + collector
+// ------------------------------------------------------------
+static void Out_patt(vector<int>& seq, int freq) {
+
+    // 1) ALWAYS collect (so Python can read it)
+    collectedPatterns.push_back(seq);
 
-    std::ofstream file_o;
-    if (b_write) file_o.open(out_file, std::ios::app);
+    // 2) existing behavior: print / write
+    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] << " ";
+    for (int ii = 0; ii < static_cast<int>(seq.size()); ii++) {
+        if (b_disp)
+            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)
+        cout << endl;
+    if (b_write)
+        file_o << endl;
 
-    if (b_disp) std::cout << "************** Freq: " << freq << std::endl;
+    if (b_disp)
+        cout << "************** Freq: " << freq << endl;
     if (b_write) {
-        file_o << "************** Freq: " << freq << std::endl;
+        file_o << "************** Freq: " << freq << endl;
         file_o.close();
     }
 }

effspm/btminer/src/freq_miner.hpp

@@ -8,6 +8,10 @@ namespace btminer {
 
 void Freq_miner();
 
+/**
+ * One pattern in the DFS stack.
+ * (same as professor)
+ */
 class Pattern {
 public:
     std::vector<int> seq;
@@ -32,8 +36,20 @@ public:
     }
 };
 
+// ----- existing globals -----
 extern int num_patt;
 extern int num_max_patt;
 extern std::vector<Pattern> DFS;
 
+// ----- NEW: collected patterns for Python binding -----
+
+// stores every pattern exactly as mined: [-68, -36, -5, ...]
+extern std::vector<std::vector<int>> collectedPatterns;
+
+// clear before every run
+void ClearCollected();
+
+// read-only access (Python binding will use this)
+const std::vector<std::vector<int>>& GetCollected();
+
 } // namespace btminer