effspm 0.3.0__cp312-cp312-macosx_11_0_arm64.whl → 0.3.3__cp312-cp312-macosx_11_0_arm64.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/main.cpp

@@ -0,0 +1,95 @@
+#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 largebm{
+using namespace std;
+
+string out_file;
+
+bool  b_disp = 0, b_write = 0, just_build = 0, pre_pro = 1;
+
+int time_limit = 30 * 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], "-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";
+
+	start_time = clock();
+
+	if (!Load_instance(item_file, thresh)) {
+		cout << "Files invalid, exiting.\n";
+		cin.get();
+		return 0;
+	}
+
+	//kk = 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) << " seconds\n\n";
+	}
+
+
+	return 0;
+}
+}

effspm/largehm/src/build_mdd.cpp

@@ -1,173 +1,138 @@
-// ─── effspm/largehm/src/build_mdd.cpp ─────────────────────────────────────────
-
-#include "build_mdd.hpp"
-
-// ─── Definitions of the extern globals declared in build_mdd.hpp ─────────────
-std::vector<largehm::Arc>       largehm::Tree;
-std::vector<largehm::VArc>      largehm::VTree;
-std::vector<largehm::CArc>      largehm::CTree;
-
 #include <vector>
 #include <iostream>
-#include <cmath>           // for std::abs
 #include <unordered_map>
-#include <cstdint>         // for std::uint64_t
 #include "load_inst.hpp"
+#include "build_mdd.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
 
 namespace largehm {
 
-//
-// ─── Build the MDD by sequentially calling Add_arc() then possibly Add_vec() ──
-//
-void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
-    // SANITY CHECK: show sizes before building
-    
-    std::unordered_map<int, std::uint64_t> ancest_map;
-    std::uint64_t last_arc = 0;
-    int itmset = 0;
+using namespace std;
+
+int Add_arc(int item,
+            unsigned long long int last_arc,
+            int& itmset,
+            unordered_map<int, unsigned long long int>& ancest_map);
 
-    // Insert each prefix item as an arc
-    for (auto it = items.begin(); it != items.end(); ++it) {
+void Add_vec(vector<int>& items_lim,
+             unordered_map<int, unsigned long long int>& ancest_map,
+             unsigned long long int last_arc,
+             int itmset);
+
+vector<Arc>  Tree;
+vector<VArc> VTree;
+vector<CArc> CTree;
+
+void Build_MDD(vector<int>& items, vector<int>& items_lim) {
+
+    unordered_map<int, unsigned long long int> ancest_map;
+
+    unsigned long long int last_arc = 0;
+    int itmset = 0;
+    for (vector<int>::iterator it = items.begin(); it != items.end(); ++it)
         last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
-    }
 
-    // If there is a suffix beyond mlim, attach it via Add_vec()
-    if (!items_lim.empty()) {
+    if (!items_lim.empty())
         Add_vec(items_lim, ancest_map, last_arc, itmset);
-    }
 }
 
-
-//
-// ─── Add_arc: insert a single “item” into the MDD under parent last_arc. ──────
-//
 int Add_arc(int item,
-            std::uint64_t last_arc,
+            unsigned long long int last_arc,
             int& itmset,
-            std::unordered_map<int, std::uint64_t>& ancest_map)
-{
-    // Ensure DFS is at least size |item|
-    size_t needed = static_cast<size_t>(std::abs(item));
-    if (DFS.size() < needed) {
-        size_t old = DFS.size();
-        DFS.resize(needed);
-        for (size_t i = old; i < needed; ++i) {
-            DFS[i] = Pattern(-static_cast<int>(i) - 1);
-        }
-    }
+            unordered_map<int, unsigned long long int>& ancest_map) {
 
-    unsigned int anct = 0;
-    auto p = ancest_map.find(std::abs(item));
-    if (p != ancest_map.end()) {
+    unsigned int anct;
+    unordered_map<int, unsigned long long int>::iterator p = ancest_map.find(abs(item));
+    if (p == ancest_map.end())
+        anct = 0;
+    else
         anct = p->second;
-    }
 
-    if (item < 0) {
+    if (item < 0)
         ++itmset;
-    }
 
-    std::uint64_t last_sibl = Tree[last_arc].chld;
+    unsigned long long int last_sibl = Tree[last_arc].chld;
+
     if (last_sibl == 0) {
-        // No child yet: create a new Arc
         Tree.emplace_back(item, itmset, anct);
         last_sibl = Tree.size() - 1;
         Tree[last_arc].chld = last_sibl;
-        if (anct == 0) {
-            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-        }
+        if (anct == 0)
+            DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+
     }
     else {
-        // Traverse siblings until we find a match or append
         while (Tree[last_sibl].item != item) {
             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);
-                }
+                if (anct == 0)
+                    DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
                 break;
             }
             last_sibl = Tree[last_sibl].sibl;
         }
     }
 
-    if (anct == 0) {
-        ++DFS[std::abs(item) - 1].freq;
-    }
+    if (anct == 0)
+        ++DFS[abs(item) - 1].freq;
+
     ++Tree[last_sibl].freq;
-    ancest_map[std::abs(item)] = last_sibl;
-    return static_cast<int>(last_sibl);
-}
 
+    ancest_map[abs(item)] = last_sibl;
 
-//
-// ─── Add_vec: attach the “items_lim” vector as children/vertical arcs ─────────
-//
-void Add_vec(std::vector<int>& items_lim,
-             std::unordered_map<int, std::uint64_t>& ancest_map,
-             std::uint64_t last_arc,
-             int itmset)
-{
-    // Ensure VDFS and DFS are at least size L
-    if (VDFS.size() < static_cast<size_t>(L)) {
-        size_t old = VDFS.size();
-        VDFS.resize(static_cast<size_t>(L));
-        for (size_t i = old; i < VDFS.size(); ++i) {
-            VDFS[i] = VPattern(static_cast<int>(i));
-        }
-    }
-    if (DFS.size() < static_cast<size_t>(L)) {
-        size_t old = DFS.size();
-        DFS.resize(static_cast<size_t>(L));
-        for (size_t i = old; i < DFS.size(); ++i) {
-            DFS[i] = Pattern(-static_cast<int>(i) - 1);
-        }
-    }
+    return last_sibl;
+}
+
+void Add_vec(vector<int>& items_lim,
+             unordered_map<int, unsigned long long int>& ancest_map,
+             unsigned long long int last_arc,
+             int itmset) {
 
     items_lim.shrink_to_fit();
-    std::vector<bool> counted(L, false);
-
-    // If this node has positive itmset (>0) or no CTree child yet, create first child entry
-    if (Tree[last_arc].itmset > 0 || Tree[last_arc].chld == 0) {
-        std::vector<std::uint64_t> ancest(L + 1, 0ULL);
-        for (auto& kv : ancest_map) {
-            ancest[kv.first - 1] = kv.second;
-            counted[kv.first - 1] = true;
+    vector<bool> counted(L, 0);
+
+    if (Tree[last_arc].itmset > 0) {
+        vector<unsigned long long int> ancest(L + 1, 0); // last element is CArc child
+        for (unordered_map<int, unsigned long long int>::iterator p = ancest_map.begin();
+             p != ancest_map.end(); ++p) {
+            ancest[p->first - 1] = p->second;
+            counted[p->first - 1] = 1;
         }
-        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
-            int cur_itm = std::abs(items_lim[i]);
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
+            int cur_itm = abs(items_lim[i]);
             if (!counted[cur_itm - 1]) {
-                if (i + 1 < static_cast<int>(items_lim.size())) {
-                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1);
+                if (i + 1 < (int)items_lim.size()) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1); // negative = CTree
                     VDFS[cur_itm - 1].seq_ID.push_back(CTree.size());
                 }
                 ++DFS[cur_itm - 1].freq;
-                counted[cur_itm - 1] = true;
+                counted[cur_itm - 1] = 1;
             }
         }
         CTree.emplace_back(ancest, items_lim);
-        Tree[last_arc].chld  = CTree.size() - 1;
-        Tree[last_arc].itmset = -itmset;
+        Tree[last_arc].chld = CTree.size() - 1;
+        Tree[last_arc].itmset = -itmset; // negative itmset = connection to CTree
     }
     else {
-        // Normal “existing CTree child” path
-        auto& ancest = CTree[ Tree[last_arc].chld ].ancest;
-        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
-            int cur_itm = std::abs(items_lim[i]);
-            if (!counted[cur_itm - 1] && ancest[cur_itm - 1] == 0ULL) {
-                if (i + 1 < static_cast<int>(items_lim.size())) {
+        vector<unsigned long long int>& ancest = CTree[Tree[last_arc].chld].ancest;
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
+            int cur_itm = abs(items_lim[i]);
+            if (!counted[cur_itm - 1] && ancest[cur_itm - 1] == 0) {
+                if (i + 1 < (int)items_lim.size()) {
                     VDFS[cur_itm - 1].str_pnt.push_back(i + 1);
                     VDFS[cur_itm - 1].seq_ID.push_back(VTree.size());
                 }
                 ++DFS[cur_itm - 1].freq;
-                counted[cur_itm - 1] = true;
+                counted[cur_itm - 1] = 1;
             }
         }
-        VTree.emplace_back(items_lim, CTree[ Tree[last_arc].chld ].ancest.back());
-        CTree[ Tree[last_arc].chld ].ancest.back() = VTree.size();
+        VTree.emplace_back(items_lim,
+                           CTree[Tree[last_arc].chld].ancest.back());
+        // VTree siblings and CTree children are +1 of their actual position
+        CTree[Tree[last_arc].chld].ancest.back() = VTree.size();
     }
 }