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

effspm/htminer/src/load_inst.hpp

@@ -6,18 +6,35 @@
 #include <map>
 #include <unordered_set>
 #include <unordered_map>
+#include <time.h>
+
 namespace htminer {
-using namespace std;
+
+using std::string;
+using std::vector;
 
 bool Load_instance(string& items_file, double thresh);
 
 extern string out_file, folder;
 
-extern bool b_disp, b_write, use_dic, just_build, pre_pro, itmset_exists;
+extern bool b_disp;
+extern bool b_write;
+extern bool use_dic;
+extern bool just_build;
+extern bool pre_pro;
+extern bool itmset_exists;
+
+extern unsigned int        M;
+extern unsigned int        mlim;
+extern unsigned int        time_limit;
+extern unsigned long long  N;
+extern unsigned long long  L;
+extern unsigned long long  theta;
+extern unsigned long long  E;
 
-extern unsigned int M, mlim, time_limit;
+// 🔥 This is the missing declaration that fixes the error:
+extern vector<int> item_dic;
 
-extern unsigned long long int N, L, theta;
+extern clock_t start_time;
 
-extern clock_t start_time; 
-}
+} // namespace htminer

effspm/htminer/src/main.cpp

@@ -0,0 +1,97 @@
+#include <iostream>
+#include <time.h>
+#include <string.h>
+#include <string>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
+namespace htminer {
+using namespace std;
+
+string out_file;
+
+bool  b_disp = 0, b_write = 0, use_dic = 0, just_build = 0, pre_pro = 1;
+
+unsigned int time_limit = 10 * 3600;
+
+clock_t start_time;
+
+string folder;
+
+int main(int argc, char* argv[]) {
+		
+	string VV, attr;
+
+	double thresh = 0;
+	for (int i = 1; i<argc; i++) {
+		if (argv[i][0] != '-' || isdigit(argv[i][1]))
+			continue;
+		else if (strcmp(argv[i], "-thr") == 0)
+			thresh = stod(argv[i + 1]);
+		else if (strcmp(argv[i], "-file") == 0)
+			VV = argv[i + 1];
+		else if (strcmp(argv[i], "-time") == 0)
+			time_limit = stoi(argv[i + 1]);
+		else if (strcmp(argv[i], "-jbuild") == 0)
+			just_build = 1;
+		else if (strcmp(argv[i], "-folder") == 0)
+			folder = argv[i + 1];
+		else if (strcmp(argv[i], "-npre") == 0)
+			pre_pro = 0;
+		else if (strcmp(argv[i], "-dic") == 0)
+			use_dic = 1;
+		else if (strcmp(argv[i], "-out") == 0) {
+			if (i + 1 == argc || argv[i + 1][0] == '-')
+				b_disp = 1;
+			else if (argv[i + 1][0] == '+') {
+				b_disp = 1;
+				b_write = 1;
+				if (strlen(argv[i + 1]) > 1) {
+					out_file = argv[i + 1];
+					out_file = out_file.substr(1, out_file.size() - 1);
+				}
+				else
+					out_file = VV;
+			}
+			else {
+				b_write = 1;
+				out_file = argv[i + 1];
+			}
+		}
+
+		else
+			cout << "Command " << argv[i] << " not recognized and skipped.\n";
+	}
+
+
+
+    cout << "\n********************** " << VV << "**********************\n";
+
+	string item_file = folder + VV + ".txt";
+
+	cout << "loading instances...\n";
+
+	clock_t start_time_all = clock();
+	start_time = clock();
+
+	if (!Load_instance(item_file, thresh)) {
+		cout << "Files invalid, exiting.\n";
+		cin.get();
+		return 0;
+	}
+
+	start_time = clock();
+
+	if (!just_build && give_time(clock() - start_time) < time_limit) {
+		Freq_miner();
+		if (give_time(clock() - start_time) >= time_limit)
+			cout << "TIME LIMIT REACHED\n";
+		cout << "Mining Complete\n\nFound a total of " << num_patt << " patterns\n";	
+		cout << "\nTotal CPU time " << give_time(clock() - start_time_all) << " seconds\n\n";
+	}
+
+
+	return 0;
+}
+}

effspm/htminer/src/utility.cpp

@@ -1,72 +1,53 @@
 #include "utility.hpp"
+#include "build_mdd.hpp"
 #include "load_inst.hpp"
-#include "freq_miner.hpp"
-#include <vector>
-namespace htminer {
-
-// ─── Flag‐like globals ──────────────────────────────────────────────────────
-bool use_list   = false;
-bool just_build = false;
-bool b_disp     = false;
-bool b_write    = false;
-bool use_dic    = false;
-bool pre_pro    = false;
+#include <iostream>
 
-unsigned int time_limit = 0;
-std::string out_file    = "";
-std::clock_t start_time = 0;
+namespace htminer {
 
-// ─── Dataset‐level globals ─────────────────────────────────────────────────
-std::vector<std::vector<int>> items;
-unsigned long long N     = 0;
-unsigned long long L     = 0;
-unsigned long long theta = 0;
-unsigned int M           = 0;
-unsigned long long E     = 0;
-unsigned int mlim        = 0; 
-// ─── DFS stacks ─────────────────────────────────────────────────────────────
-std::vector<Pattern> DFS;
-std::vector<VPattern> VDFS;
+using std::vector;
 
-// ─── Collected patterns storage ────────────────────────────────────────────
-std::vector<std::vector<int>> collectedPatterns;
-const std::vector<std::vector<int>>& GetCollected() {
-    return collectedPatterns;
-}
-
-// ─── give_time and check_parent get their definitions here (as provided) ───
-float give_time(std::clock_t kk) {
-    return static_cast<float>(kk) / static_cast<float>(CLOCKS_PER_SEC);
-}
-bool check_parent(unsigned int cur_anct, unsigned int str_pnt, unsigned int start, vector<unsigned int>& strpnt_vec) {
+vector<vector<int>> collectedPatterns;
 
-	vector<unsigned 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;
-	}
+bool check_parent(unsigned int cur_anct, unsigned int str_pnt,
+                  unsigned int start, vector<unsigned int>& strpnt_vec) {
 
-	if (abs(Tree[cur_anct].itmset) == abs(Tree[str_pnt].itmset))
-		return 1;
-	else {
-		for (vector<unsigned 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;
-			}
-		}
-	}
+    vector<unsigned int> ancestors;
 
+    while (std::abs(Tree[cur_anct].itmset) >
+           std::abs(Tree[str_pnt].itmset)) {
+        if (Tree[cur_anct].item > 0)
+            ancestors.push_back(cur_anct);
+        cur_anct = Tree[cur_anct].anct;
+    }
 
-	return 0;
+    if (std::abs(Tree[cur_anct].itmset) ==
+        std::abs(Tree[str_pnt].itmset))
+        return true;
+    else {
+        for (vector<unsigned 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 true;
+            }
+        }
+    }
 
+    return false;
 }
 
+float give_time(clock_t kk) {
+    float ll = ((float)kk) / CLOCKS_PER_SEC;
+    return ll;
+}
 
+void ClearCollected() {
+    collectedPatterns.clear();
+}
 
+const vector<vector<int>>& GetCollected() {
+    return collectedPatterns;
+}
 
-
-
-}
+} // namespace htminer

effspm/htminer/src/utility.hpp

@@ -1,77 +1,22 @@
 #pragma once
 
 #include <vector>
-#include <ctime>
+#include <time.h>
 #include <string>
 #include "build_mdd.hpp"
-#include "freq_miner.hpp"
-#include "load_inst.hpp"
 
 namespace htminer {
 
-// ─── Global flags and counters ─────────────────────────────────────────────
-/// Controls whether to mine in “list” mode (unused for HTMiner, but declared)
-extern bool use_list;
-/// If true, only build MDD and exit (don’t actually mine)
-extern bool just_build;
-/// If true, print each pattern to stdout as it’s found
-extern bool b_disp;
-/// If true, write each pattern to file (see out_file)
-extern bool b_write;
-/// If true, use a dictionary‐file mapping items → new IDs
-extern bool use_dic;
-/// If true, preprocess input (create dictionary) instead of mining
-extern bool pre_pro;
+using std::vector;
 
-/// Time limit (in seconds) for mining before forced exit
-extern unsigned int time_limit;
-/// Output filename (if b_write is true)
-extern std::string out_file;
-/// Clock tick when mining started
-extern std::clock_t start_time;
+float give_time(clock_t kk);
+bool check_parent(unsigned int cur_arc, unsigned int str_pnt,
+                  unsigned int start, vector<unsigned int>& strpnt_vec);
 
-// ─── Data‐set‐level globals ─────────────────────────────────────────────────
-/// The input sequences (each sequence is a vector of integers)
-extern std::vector<std::vector<int>> items;
-/// Number of sequences (items.size())
-extern unsigned long long N;
-/// Number of distinct items (max absolute item ID)
-extern unsigned long long L;
-/// Minimum support threshold (absolute count, not fraction)
-extern unsigned long long theta;
-/// Maximum sequence length across all items
-extern unsigned int M;
-/// Total number of “entries” (sum of all sequence lengths)
-extern unsigned long long E;
+// pattern collection for Python
+extern vector<vector<int>> collectedPatterns;
 
-// ─── Per‐pattern DFS stacks ─────────────────────────────────────────────────
-/// DFS stack of “in‐memory” patterns (each Pattern holds its own ilist/slist, freq, str_pnt, etc.)
-extern std::vector<Pattern> DFS;
-
-extern std::vector<std::vector<int>> collectedPatterns;
-// ─── Collected output ───────────────────────────────────────────────────────
-/// Clears any patterns left in DFS (called at the start of each run)
-inline void ClearCollected() {
-    DFS.clear();
-    collectedPatterns.clear();     
-}
-/// Returns a reference to the entire “collected patterns” vector
-/// (each Pattern knows how to output itself as a vector<int>)
-const std::vector<std::vector<int>>& GetCollected();
-
-// ─── Helper functions ───────────────────────────────────────────────────────
-/// Given a clock‐tick difference, return elapsed seconds as a float
-float give_time(std::clock_t kk);
-
-/// Check whether a candidate can extend its parent pattern:
-///   cur_arc  = current Arc node ID in MDD
-///   str_pnt  = string‐pointer of the existing pattern
-///   start    = starting index within the MDD arc‐list
-///   strpnt_vec = parent’s “string pointers” vector
-/// Returns true if `cur_arc` is a valid child of `str_pnt` from position `start`.
-bool check_parent(unsigned int cur_arc,
-                  unsigned int str_pnt,
-                  unsigned int start,
-                  std::vector<unsigned int>& strpnt_vec);
+void ClearCollected();
+const vector<vector<int>>& GetCollected();
 
 } // namespace htminer

effspm/largebm/src/build_mdd.cpp

@@ -1,137 +1,96 @@
-// File: effspm/largebm/src/load_inst.cpp
-
-#include <vector>
-#include <iostream>
 #include <unordered_map>
-#include "load_inst.hpp"
+#include <cstdlib>
 #include "build_mdd.hpp"
 #include "freq_miner.hpp"
-#include "utility.hpp"
+#include "load_inst.hpp"
 
 namespace largebm {
 
-    // Forward declaration for Add_arc
-    int Add_arc(int item, unsigned long long int last_arc, int& itmset,
-                std::unordered_map<int, unsigned long long int>& ancest_map);
-
-    // Global MDD tree and other globals (declared in headers)
-    std::vector<Arc> Tree;
+std::vector<Arc> Tree;
 
-    void Build_MDD(std::vector<int>& items) {
-        std::unordered_map<int, unsigned long long int> ancest_map;
-        unsigned long long int last_arc = 0;
-        int itmset = 0;
+static int Add_arc(int item,
+                   unsigned long long last_arc,
+                   int& itmset,
+                   std::unordered_map<int, unsigned long long>& ancest_map);
 
-        for (auto it = items.begin(); it != items.end(); ++it) {
-            last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
-        }
+void Build_MDD(const std::vector<int>& items) {
+    std::unordered_map<int, unsigned long long> ancest_map;
+    unsigned long long last_arc = 0;
+    int itmset = 0;
+    for (int v : items) {
+        last_arc = Add_arc(v, last_arc, itmset, ancest_map);
     }
+}
 
+static int Add_arc(int item,
+                   unsigned long long last_arc,
+                   int& itmset,
+                   std::unordered_map<int, unsigned long long>& ancest_map) {
+    ++E;
 
-    int Add_arc(int item, unsigned long long int last_arc, int& itmset,
-                std::unordered_map<int, unsigned long long int>& ancest_map) {
-
-        unsigned idx = std::abs(item) - 1;
+    unsigned idx = static_cast<unsigned>(std::abs(item) - 1);
 
-        // ─── DEBUG ────────────────────────────────────────────────
-        // std::cout << "[Add_arc] item=" << item
-        //           << "  idx=" << idx
-        //           << "  last_arc=" << last_arc
-        //           << "  Tree.size=" << Tree.size()
-        //           << "  DFS.size="  << DFS.size()
-        //           << std::endl;
-
-        // Ensure DFS can hold this index
-        if (idx >= DFS.size()) {
-           // std::cout << "[Add_arc]  • resizing DFS to " << (idx + 1) << std::endl;
-            DFS.reserve(idx + 1);
-            while (DFS.size() <= idx) {
-                DFS.emplace_back(-static_cast<int>(DFS.size()) - 1); // Pattern(-id)
-            }
+    if (idx >= DFS.size()) {
+        DFS.reserve(idx + 1);
+        while (DFS.size() <= idx) {
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
         }
+    }
 
-        unsigned long long int anct;
-        auto p = ancest_map.find(std::abs(item));
-        if (p == ancest_map.end()) {
-            anct = 0;
-        } else {
-            anct = p->second;
-        }
+    unsigned long long anct = 0;
+    {
+        std::unordered_map<int, unsigned long long>::const_iterator p =
+            ancest_map.find(std::abs(item));
+        if (p != ancest_map.end()) anct = p->second;
+    }
 
-        if (item < 0) {
-            ++itmset;
-        }
+    if (item < 0) {
+        ++itmset;
+    }
 
-        // Before accessing Tree[last_arc].chld, check bounds
-        if (last_arc >= Tree.size()) {
-            // std::cout << "[Add_arc]  !!! last_arc OOB  last_arc="
-            //           << last_arc << "  Tree.size=" << Tree.size()
-            //           << std::endl;
-            // We still proceed so we can see crash context:
-        }
+    unsigned long long last_sibl = 0;
+    if (last_arc < Tree.size()) {
+        last_sibl = Tree[last_arc].chld;
+    }
 
-        unsigned long long int last_sibl = 0;
+    if (last_sibl == 0) {
+        Tree.emplace_back(item, itmset, anct);
+        last_sibl = Tree.size() - 1;
         if (last_arc < Tree.size()) {
-            last_sibl = Tree[last_arc].chld;
+            Tree[last_arc].chld = last_sibl;
         }
-
-        if (last_sibl == 0) {
-            // Insert new node as first child
-            Tree.emplace_back(item, itmset, anct);
-            last_sibl = Tree.size() - 1;
-
-            if (last_arc < Tree.size()) {
-                Tree[last_arc].chld = last_sibl;
-            }
-            if (anct == 0) {
-                // Debug before DFS access
-                // std::cout << "[Add_arc]  • DFS access at index=" << (std::abs(item) - 1)
-                //           << "  DFS.size=" << DFS.size() << std::endl;
-                DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+        if (anct == 0) {
+            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+        }
+    } else {
+        while (true) {
+            if (last_sibl >= Tree.size()) break;
+            if (Tree[last_sibl].item == item) {
+                break;
             }
-
-        } else {
-
-            // Walk siblings until find matching item or end
-            while (true) {
-                if (last_sibl >= Tree.size()) {
-                    // std::cout << "[Add_arc]  !!! last_sibl OOB  last_sibl="
-                    //           << last_sibl << "  Tree.size=" << Tree.size()
-                    //           << std::endl;
-                    break;
-                }
-                if (Tree[last_sibl].item == item) {
-                    break;
-                }
-                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) {
-                        // std::cout << "[Add_arc]  • DFS access at index=" << (std::abs(item) - 1)
-                        //           << "  DFS.size=" << DFS.size() << std::endl;
-                        DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-                    }
-                    break;
+            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);
                 }
-                last_sibl = Tree[last_sibl].sibl;
+                break;
             }
+            last_sibl = Tree[last_sibl].sibl;
         }
+    }
 
-        if (anct == 0) {
-            // std::cout << "[Add_arc]  • increment DFS.freq at index=" << (std::abs(item) - 1)
-            //           << "  DFS.size=" << DFS.size() << std::endl;
-            DFS[std::abs(item) - 1].freq++;
-        }
-
-        if (last_sibl < Tree.size()) {
-            // std::cout << "[Add_arc]  • increment Tree.freq at node=" << last_sibl
-            //           << "  Tree.size=" << Tree.size() << std::endl;
-            Tree[last_sibl].freq++;
-        }
+    if (anct == 0) {
+        DFS[std::abs(item) - 1].freq++;
+    }
 
-        ancest_map[std::abs(item)] = last_sibl;
-        return last_sibl;
+    if (last_sibl < Tree.size()) {
+        Tree[last_sibl].freq++;
     }
 
-}  // namespace largebm
+    ancest_map[std::abs(item)] = last_sibl;
+    return static_cast<int>(last_sibl);
+}
+
+} // namespace largebm

effspm/largebm/src/build_mdd.hpp

@@ -1,47 +1,32 @@
 #pragma once
-
-#include<vector>
-#include <cmath>
-#include "load_inst.hpp"
+#include <vector>
+#include <cstdint>
 
 namespace largebm {
-void Build_MDD(std::vector<int>& items);
 
 class Arc {
 public:
+    unsigned long long chld = 0;
+    unsigned long long sibl = 0;
+    unsigned long long freq = 0;
+    unsigned long long anct = 0;
+    int itmset = 0;
+    int item = 0;
+
+    Arc() = default;
+    Arc(int _itm, int _itmset, unsigned long long _anc)
+        : chld(0), sibl(0), freq(0), anct(_anc), itmset(_itmset), item(_itm) {}
+    Arc(int _itm, unsigned long long _anc)
+        : chld(0), sibl(0), freq(0), anct(_anc), item(_itm) {}
+};
 
-	unsigned long long int chld;	
-	unsigned long long int sibl;
-	unsigned long long int freq;		
-	unsigned long long int anct;
-	int itmset;
-	int item;
-
-	Arc(int _itm, int _itmset, unsigned long long int _anc) {
-		itmset = _itmset;
-		anct = _anc;
-		item = _itm;
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
-
-	Arc(int _itm, int _anc) {
-		item = _itm;
-		anct = _anc;
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
-
-	Arc() {
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
+// Single global MDD, defined in build_mdd.cpp
+extern std::vector<Arc> Tree;
 
+// [2025-10-25 NEW]: const-correct signature used everywhere
+void Build_MDD(const std::vector<int>& items);
 
-};
+// [2025-10-25 NEW]: debug helper to read how many anct==0 ticks we did
+unsigned long long _effspm_dbg_anct0_ticks();
 
-extern std::vector<Arc> Tree;
-}
+} // namespace largebm