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

effspm/largehm/src/utility.cpp

@@ -2,37 +2,55 @@
 #include "build_mdd.hpp"
 #include "load_inst.hpp"
 #include <iostream>
+
 namespace largehm {
-	std::vector<std::vector<int>> collected;
-bool check_parent(unsigned long long int cur_anct, unsigned long long int str_pnt, unsigned long long int start, vector<unsigned long long int>& strpnt_vec) {
-
-	vector<unsigned long long int> ancestors;
-	
-	while (abs(Tree[cur_anct].itmset) > abs(Tree[str_pnt].itmset)) {
-		if (Tree[cur_anct].item > 0)
-			ancestors.push_back(cur_anct);
-		cur_anct = Tree[cur_anct].anct;
-	}
-
-	if (abs(Tree[cur_anct].itmset) == abs(Tree[str_pnt].itmset))
-		return 1;
-	else {
-		for (vector<unsigned long long int>::reverse_iterator it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
-			for (unsigned int i = start; i < strpnt_vec.size(); ++i) {
-				if (strpnt_vec[i] == *it)
-					return 1;
-			}
-		}
-	}
-
-	return 0;
 
+using namespace std;
+
+// storage for mined patterns (each pattern = vector<int>)
+std::vector<std::vector<int>> collectedPatterns;
+
+bool check_parent(unsigned long long int cur_anct,
+                  unsigned long long int str_pnt,
+                  unsigned long long int start,
+                  vector<unsigned long long int>& strpnt_vec) {
+
+    vector<unsigned long long int> ancestors;
+
+    while (abs(Tree[cur_anct].itmset) > abs(Tree[str_pnt].itmset)) {
+        if (Tree[cur_anct].item > 0)
+            ancestors.push_back(cur_anct);
+        cur_anct = Tree[cur_anct].anct;
+    }
+
+    if (abs(Tree[cur_anct].itmset) == abs(Tree[str_pnt].itmset))
+        return 1;
+    else {
+        for (vector<unsigned long long int>::reverse_iterator it = ancestors.rbegin();
+             it != ancestors.rend(); ++it) {
+            for (unsigned int i = start; i < strpnt_vec.size(); ++i) {
+                if (strpnt_vec[i] == *it)
+                    return 1;
+            }
+        }
+    }
+
+    return 0;
 }
 
+float give_time(clock_t kk) {
+    float ll = ((float)kk) / CLOCKS_PER_SEC;
+    return ll;
+}
 
+// clear vector used to return patterns to Python
+void ClearCollected() {
+    collectedPatterns.clear();
+}
+
+// return reference so Python wrapper can build list[list[int]]
+const std::vector<std::vector<int>>& GetCollected() {
+    return collectedPatterns;
+}
 
-// float give_time(clock_t kk) {
-// 	float ll = ((float)kk) / CLOCKS_PER_SEC;
-// 	return ll;
-// }
-}
+} // namespace largehm

effspm/largehm/src/utility.hpp

@@ -6,24 +6,26 @@
 #include "build_mdd.hpp"
 
 namespace largehm {
-using namespace std;
 
-  extern std::vector<std::vector<int>> collected;
+using std::vector;
+using std::string;
 
-  // Helpers to clear and fetch collected patterns from Python:
-  inline void ClearCollected() {
-    collected.clear();
-  }
-  inline const std::vector<std::vector<int>>& GetCollected() {
-    return collected;
-  }
+// time helper
+float give_time(clock_t kk);
 
-  // A small timer helper:
-  inline float give_time(clock_t kk) {
-    float ll = ((float)kk) / CLOCKS_PER_SEC;
-    return ll;
-  }
-bool check_parent(unsigned long long int cur_anct, unsigned long long int str_pnt, unsigned long long int start, vector<unsigned long long int>& strpnt_vec);
+// ancestor-check helper
+bool check_parent(unsigned long long int cur_anct,
+                  unsigned long long int str_pnt,
+                  unsigned long long int start,
+                  vector<unsigned long long int>& strpnt_vec);
 
+// pattern collection for Python wrapper
+extern std::vector<std::vector<int>> collectedPatterns;
 
-}
+// clear collected patterns between runs
+void ClearCollected();
+
+// get collected patterns after mining
+const std::vector<std::vector<int>>& GetCollected();
+
+} // namespace largehm

effspm/largepp/src/freq_miner.cpp

@@ -1,170 +1,198 @@
+#include <algorithm>
+#include <cstdlib>
+#include <fstream>
 #include <iostream>
-#include <time.h>
+
 #include "freq_miner.hpp"
+#include "pattern.hpp"
+#include "load_inst.hpp"
 #include "utility.hpp"
 
-namespace largepp   // ← BEGIN namespacing
-{
-void Out_patt(vector<int>& seq, unsigned int freq);
-void Extend_patt(Pattern& _patt);
-
-unsigned long long int num_patt = 0;
-
-Pattern _patt;
+namespace largepp {
 
-void Freq_miner() {
+using std::abs;
+using std::cout;
+using std::endl;
+using std::ofstream;
+using std::swap;
+using std::vector;
 
-	vector<int> islist;
+static void Out_patt(vector<int>& seq, unsigned int freq);
+static void Extend_patt(Pattern& _pattern);
 
-	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();
-	}
+unsigned long long int num_patt = 0;      // counter for emitted patterns
+static Pattern _patt;                     // scratch pattern (for in-place extend)
 
+/* ------------------------------------------------------------------ */
+/*  Driver                                                            */
+/* ------------------------------------------------------------------ */
+void Freq_miner()
+{
+    // Build the candidate item list once (items that pass minsup at length-1)
+    vector<int> islist;
+    islist.reserve(L);
+    for (unsigned int i = 0; i < L; ++i) {
+        if (DFS[i].freq >= theta) islist.push_back(static_cast<int>(i));
+    }
+
+    // Seed each 1-length pattern’s extension lists
+    for (unsigned int i = 0; i < DFS.size(); ++i) {
+        DFS[i].ilist = islist;
+        DFS[i].slist = islist;
+    }
+
+    // DFS over the stack, extending only nodes whose current support ≥ theta
+    while (!DFS.empty() && give_time(std::clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta) {
+            Extend_patt(DFS.back());
+        } else {
+            DFS.pop_back();
+        }
+    }
 }
 
-void Extend_patt(Pattern& _pattern) {
-
-	swap(_patt, _pattern);
-	DFS.pop_back();
-
-	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;
-
-	vector<Pattern> pot_patt(L * 2);
-
-	int last_neg = _patt.seq.size() - 1;
-	while (_patt.seq[last_neg] > 0)
-		--last_neg;
-
-	for (int i = 0; i < _patt.str_pnt.size(); ++i) {
-
-		vector<bool> found(L * 2, 0);		
-
-		unsigned long long int seq = _patt.seq_ID[i];				
-		unsigned int j = _patt.str_pnt[i] + 1;
-		while (j < items[seq].size() && items[seq][j] > 0) {
-			int cur_itm = items[seq][j];
-			if (ilist[cur_itm - 1]) {
-				pot_patt[cur_itm - 1].seq_ID.push_back(seq);
-				pot_patt[cur_itm - 1].str_pnt.push_back(j);
-				++pot_patt[cur_itm - 1].freq;
-				found[cur_itm - 1] = 1;
-			}
-			++j;
-		}
-		
-		int num_itmfnd = 0;
-		for (int k = j; k < items[seq].size(); ++k) {
-			int cur_itm = abs(items[seq][k]);
-			if (items[seq][k] < 0) 
-				num_itmfnd = 0;
-			if (slist[cur_itm - 1] && !found[L + cur_itm - 1]) {
-				pot_patt[L + cur_itm - 1].seq_ID.push_back(seq);
-				pot_patt[L + cur_itm - 1].str_pnt.push_back(k);
-				++pot_patt[L + cur_itm - 1].freq;
-				found[L + cur_itm - 1] = 1;
-			}
-			if (num_itmfnd == _patt.seq.size() - last_neg) {
-				if (ilist[cur_itm - 1] && !found[cur_itm - 1]) {
-					pot_patt[cur_itm - 1].seq_ID.push_back(seq);
-					pot_patt[cur_itm - 1].str_pnt.push_back(k);
-					++pot_patt[cur_itm - 1].freq;
-					found[cur_itm - 1] = 1;
-				}
-			}
-			else if (cur_itm == abs(_patt.seq[last_neg + num_itmfnd])) 
-				++num_itmfnd;
-		}
-	}
-
-
-	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 (vector<int>::iterator it = _patt.slist.begin(); it != _patt.slist.end(); ++it) {
-		if (pot_patt[(*it) + L].freq >= theta) 
-			slistp.push_back(*it);
-	}
-
-	for (vector<int>::iterator it = ilistp.begin(); it != ilistp.end(); ++it) {
-		DFS.emplace_back();
-		swap(DFS.back(), pot_patt[*it]);
-		DFS.back().seq = _patt.seq;
-		DFS.back().seq.push_back((*it) + 1);
-		DFS.back().slist = slistp;
-		DFS.back().ilist = ilistp;
-		if (b_disp || b_write) 
-			Out_patt(DFS.back().seq, DFS.back().freq);
-		++num_patt;
-	}
-
-
-	for (vector<int>::iterator it = slistp.begin(); it != slistp.end(); ++it) {
-		DFS.emplace_back();
-		swap(DFS.back(), pot_patt[(*it) + L]);
-		DFS.back().seq = _patt.seq;
-		DFS.back().seq.push_back(-(*it) - 1);
-		DFS.back().slist = slistp;
-		DFS.back().ilist = slistp;
-		if (b_disp || b_write) 
-			Out_patt(DFS.back().seq, DFS.back().freq);
-		++num_patt;
-	}
-
+/* ------------------------------------------------------------------ */
+/*  Extend_patt: given a frequent pattern, enumerate its i- and s-ext */
+/* ------------------------------------------------------------------ */
+static void Extend_patt(Pattern& _pattern)
+{
+    swap(_patt, _pattern);  // work on local scratch
+    DFS.pop_back();         // remove from stack
+
+    // Quick presence tables for allowed i-/s-extensions
+    vector<bool> slist(L, false);
+    vector<bool> ilist(L, false);
+    for (int idx : _patt.slist) slist[static_cast<size_t>(idx)] = true;
+    for (int idx : _patt.ilist) ilist[static_cast<size_t>(idx)] = true;
+
+    // Potential children buffers:
+    vector<Pattern> pot_patt(L * 2); // [0..L-1] = i-ext, [L..2L-1] = s-ext
+
+    // Find last negative from the end (boundary between itemsets)
+    int last_neg = static_cast<int>(_patt.seq.size()) - 1;
+    while (last_neg >= 0 && _patt.seq[static_cast<size_t>(last_neg)] > 0) --last_neg;
+
+    // Scan occurrences to build supports for all valid next-steps
+    for (size_t i = 0; i < _patt.str_pnt.size(); ++i) {
+        vector<bool> found(L * 2, false);
+
+        unsigned long long seq_id = _patt.seq_ID[i];
+        unsigned int j = _patt.str_pnt[i] + 1;
+
+        // 1) Same itemset (i-extension) forward until end-of-itemset (>0)
+        while (j < items[seq_id].size() && items[seq_id][j] > 0) {
+            int cur_itm = items[seq_id][j];
+            if (ilist[static_cast<size_t>(cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(j);
+                ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                found[static_cast<size_t>(cur_itm - 1)] = true;
+            }
+            ++j;
+        }
+
+        // 2) Later itemsets (s-extension), plus special re-open i-ext rule
+        int num_itmfnd = 0;
+        for (size_t k = j; k < items[seq_id].size(); ++k) {
+            int cur = items[seq_id][k];
+            int cur_itm = abs(cur);
+
+            if (cur < 0) num_itmfnd = 0; // new itemset boundary seen
+
+            // s-extension: add cur_itm as new itemset element
+            if (slist[static_cast<size_t>(cur_itm - 1)] &&
+                !found[static_cast<size_t>(L + cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].str_pnt.push_back(k);
+                ++pot_patt[static_cast<size_t>(L + cur_itm - 1)].freq;
+                found[static_cast<size_t>(L + cur_itm - 1)] = true;
+            }
+
+            // once we've seen the suffix of the last itemset fully,
+            // allow i-extension again (across future itemsets)
+            if (num_itmfnd == static_cast<int>(_patt.seq.size()) - last_neg) {
+                if (ilist[static_cast<size_t>(cur_itm - 1)] &&
+                    !found[static_cast<size_t>(cur_itm - 1)]) {
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(k);
+                    ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                    found[static_cast<size_t>(cur_itm - 1)] = true;
+                }
+            } else if (last_neg + num_itmfnd >= 0 &&
+                       cur_itm == abs(_patt.seq[static_cast<size_t>(last_neg + num_itmfnd)])) {
+                ++num_itmfnd;
+            }
+        }
+    }
+
+    // Filter children by support threshold
+    vector<int> ilistp;
+    vector<int> slistp;
+    ilistp.reserve(_patt.ilist.size());
+    slistp.reserve(_patt.slist.size());
+
+    for (int idx : _patt.ilist) {
+        if (pot_patt[static_cast<size_t>(idx)].freq >= theta)
+            ilistp.push_back(idx);
+    }
+    for (int idx : _patt.slist) {
+        if (pot_patt[static_cast<size_t>(idx + static_cast<int>(L))].freq >= theta)
+            slistp.push_back(idx);
+    }
+
+    // Push all i-extensions
+    for (int idx : ilistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx)]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(idx + 1);
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = ilistp;
+
+        // ALWAYS emit (so collected fills even if !b_disp && !b_write)
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+
+    // Push all s-extensions
+    for (int idx : slistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx + static_cast<int>(L))]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(-(idx + 1));  // negative encodes new itemset
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = slistp;             // as in original code
+
+        // ALWAYS emit
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
 }
 
-
-void Out_patt(vector<int>& seq, unsigned int freq) {
-
-	largepp::collected.push_back(seq);  
-
-	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)
-			cout << seq[ii] << " ";
-		if (b_write) 
-			file_o << seq[ii] << " ";
-	}
-	if (b_disp)
-		cout << endl;
-	if (b_write) 
-		file_o << endl;
-	
-	if (b_disp)
-		cout << "************** Freq: " << freq << endl;
-	if (b_write) {
-		file_o << "************** Freq: " << freq << endl;
-		file_o.close();
-	}
-}
+/* ------------------------------------------------------------------ */
+/*  Out_patt: append to buffer; optionally print/write                */
+/* ------------------------------------------------------------------ */
+static void Out_patt(vector<int>& seq, unsigned int freq)
+{
+    // Always append to in-memory results returned to Python
+    largepp::collected.push_back(seq);
+
+    ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    if (b_disp) {
+        for (int v : seq) cout << v << " ";
+        cout << "\n************** Freq: " << freq << endl;
+    }
+    if (b_write) {
+        for (int v : seq) file_o << v << " ";
+        file_o << "\n************** Freq: " << freq << "\n";
+        file_o.close();
+    }
 }
 
-
-
-
+} // namespace largepp

effspm/largepp/src/freq_miner.hpp

@@ -1,43 +1,18 @@
 #pragma once
 
-#include "load_inst.hpp"
-namespace largepp   // ← BEGIN namespacing
-{
-void Freq_miner();
-
-class Pattern {
-public:
-
-	vector<int> seq;
-	vector<unsigned int> str_pnt;
-	vector<unsigned long long int> seq_ID;
-
-	vector<int> slist;
-	vector<int> ilist;
-
-	unsigned long long int freq;
+#include <vector>
+#include <string>
 
-	Pattern(vector<int>& _seq, int item) {
-		seq.reserve(_seq.size());
-		for (int i = 0; i < _seq.size(); ++i)
-			seq.push_back(_seq[i]);
-		seq.push_back(item);
-		freq = 0;
-	}
+#include "pattern.hpp"   // defines largepp::Pattern
+#include "load_inst.hpp" // declares externs: items, L, theta, DFS, etc.
+#include "utility.hpp"   // flags, collected buffer, timers, helpers
 
+namespace largepp {
 
-	Pattern(int item) {
-		seq.push_back(item);
-		freq = 0;
-	}
-
-	Pattern() {
-		freq = 0;
-	}
-
-};
-
-extern vector<Pattern> DFS;				//DFS queue of potential patterns to extend
+// Public entry point
+void Freq_miner();
 
+// (defined in the .cpp)
 extern unsigned long long int num_patt;
-}
+
+} // namespace largepp

effspm/largepp/src/load_inst.cpp

@@ -2,6 +2,7 @@
 #include <sstream>
 #include <algorithm>
 #include <cmath>
+#include <fstream>
 #include "load_inst.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
@@ -36,6 +37,7 @@ bool Load_instance(string& items_file, double thresh)
 
         cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
 
+        DFS.clear();
         DFS.reserve(L);
         for (unsigned int i = 0; i < L; ++i)
             DFS.emplace_back(-int(i) - 1);
@@ -48,10 +50,28 @@ bool Load_instance(string& items_file, double thresh)
         return false;
     else
         theta = (thresh < 1.0) ? ceil(thresh * N) : thresh;
-
-    cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
-    cout << "Found " << N << " sequence, with max line len " << M
-         << ", and " << L << " items, and " << E << " enteries\n";
+    if (b_disp)
+        cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+    if (b_disp)
+        cout << "Found " << N << " sequence, with max line len " << M
+             << ", and " << L << " items, and " << E << " enteries\n";
+
+    // ───────────────────────────────────────────────────────────
+    // DEBUG snapshot of seeds right after loading
+    // ───────────────────────────────────────────────────────────
+    {
+        unsigned long long seeds_ge_theta = 0, seeds_nonzero = 0, max_freq = 0;
+        for (size_t i = 0; i < DFS.size(); ++i) {
+            if (DFS[i].freq > 0) ++seeds_nonzero;
+            if (DFS[i].freq >= theta) ++seeds_ge_theta;
+            if (DFS[i].freq > max_freq) max_freq = DFS[i].freq;
+        }
+       // std::cout << " theta=" << theta
+               //   << " | DFS.size=" << DFS.size()
+               //   << " | seeds>=theta=" << seeds_ge_theta
+              //    << " | seeds>0=" << seeds_nonzero
+              //    << " | max_seed_freq=" << max_freq << "\n";
+    }
 
     return true;
 }
@@ -67,12 +87,12 @@ void Load_py(const pybind11::object& data, double thresh)
     int max_id = 0;
     M = 0;  E = 0;
     for (auto& seq : items) {
-        M = max<unsigned int>(M, seq.size());
+        M = max<unsigned int>(M, static_cast<unsigned int>(seq.size()));
         E += seq.size();
         for (int x : seq)
             max_id = max(max_id, abs(x));
     }
-    L = max_id;
+    L = static_cast<unsigned int>(max_id);
     theta = (thresh < 1.0) ? ceil(thresh * N) : thresh;
 
     DFS.clear();
@@ -82,7 +102,7 @@ void Load_py(const pybind11::object& data, double thresh)
 }
 
 /* =================================================================
- *  The professor’s original helpers — untouched
+ *  The professor’s original helpers — untouched except minor safety
  * ================================================================= */
 static bool Preprocess(string& inst, double thresh)
 {
@@ -97,7 +117,7 @@ static bool Preprocess(string& inst, double thresh)
             string itm;
             while (word >> itm) {
                 ditem = stoi(itm);
-                L = max<unsigned int>(L, abs(ditem));
+                L = max<unsigned int>(L, static_cast<unsigned int>(abs(ditem)));
 
                 if (freq.size() < L) {
                     freq.resize(L, 0);
@@ -170,7 +190,7 @@ static void Load_items_pre(string& inst)
         }
         if (empty_seq) continue;
 
-        ++N;  E += size_m;  M = max<unsigned int>(M, size_m);
+        ++N;  E += size_m;  M = max<unsigned int>(M, static_cast<unsigned int>(size_m));
     }
 }
 
@@ -193,8 +213,8 @@ static bool Load_items(string& inst)
 
         while (word >> itm) {
             ditem = stoi(itm);
-            if (L < abs(ditem)) {
-                L = abs(ditem);
+            if (L < static_cast<unsigned int>(abs(ditem))) {
+                L = static_cast<unsigned int>(abs(ditem));
                 while (DFS.size() < L) {
                     DFS.emplace_back(-int(DFS.size()) - 1);
                     counted.push_back(0);
@@ -211,7 +231,7 @@ static bool Load_items(string& inst)
             ++size_m;
         }
         E += size_m;
-        M = max<unsigned int>(M, size_m);
+        M = max<unsigned int>(M, static_cast<unsigned int>(size_m));
     }
     return true;
 }