effspm 0.2.6__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

effspm/largepp/src/load_inst.cpp

@@ -0,0 +1,219 @@
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <cmath>
+#include "load_inst.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+
+namespace largepp {   // ─── BEGIN namespace ─────────────────────
+using namespace std;
+
+/* ------------------------------------------------------------------
+ *  Global definitions (match the externs in load_inst.hpp)
+ * ---------------------------------------------------------------- */
+unsigned int        M = 0, L = 0;
+unsigned long long  N = 0, E = 0;
+double              theta = 0.01;
+vector<vector<int>> items;
+vector<Pattern>     DFS;
+vector<int>         item_dic;
+
+/*  Forward decls for helper routines in this file  */
+static bool  Load_items(string& inst);
+static void  Load_items_pre(string& inst);
+static bool  Preprocess(string& inst, double thresh);
+
+/* ==================================================================
+ *  MAIN ENTRY — load from disk
+ * ================================================================= */
+bool Load_instance(string& items_file, double thresh)
+{
+    clock_t kk = clock();
+
+    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 (unsigned int i = 0; i < L; ++i)
+            DFS.emplace_back(-int(i) - 1);
+
+        kk = clock();
+        Load_items_pre(items_file);
+        N = items.size();
+    }
+    else if (!Load_items(items_file))
+        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";
+
+    return true;
+}
+
+/* ==================================================================
+ *  ALT ENTRY — load directly from a Python list of lists
+ * ================================================================= */
+void Load_py(const pybind11::object& data, double thresh)
+{
+    items = data.cast<vector<vector<int>>>();
+    N     = items.size();
+
+    int max_id = 0;
+    M = 0;  E = 0;
+    for (auto& seq : items) {
+        M = max<unsigned int>(M, seq.size());
+        E += seq.size();
+        for (int x : seq)
+            max_id = max(max_id, abs(x));
+    }
+    L = max_id;
+    theta = (thresh < 1.0) ? ceil(thresh * N) : thresh;
+
+    DFS.clear();
+    DFS.reserve(L);
+    for (unsigned int i = 0; i < L; ++i)
+        DFS.emplace_back(-int(i) - 1);
+}
+
+/* =================================================================
+ *  The professor’s original helpers — untouched
+ * ================================================================= */
+static bool Preprocess(string& inst, double thresh)
+{
+    ifstream file(inst);
+    vector<unsigned long long> freq(1000000), counted(1000000, 0);
+
+    if (file.good()) {
+        string line; int ditem;
+        while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+            ++N;
+            istringstream word(line);
+            string itm;
+            while (word >> itm) {
+                ditem = stoi(itm);
+                L = max<unsigned int>(L, abs(ditem));
+
+                if (freq.size() < L) {
+                    freq.resize(L, 0);
+                    counted.resize(L, 0);
+                }
+                if (counted[abs(ditem) - 1] != N) {
+                    ++freq[abs(ditem) - 1];
+                    counted[abs(ditem) - 1] = N;
+                }
+            }
+        }
+    } else {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    theta = (thresh < 1.0) ? ceil(thresh * N) : thresh;
+
+    int real_L = 0;
+    item_dic.assign(L, -1);
+    for (unsigned 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 << '\n';
+
+    L = real_L;
+    N = 0;
+    return true;
+}
+
+static void Load_items_pre(string& inst)
+{
+    ifstream file(inst);
+
+    if (!file.good()) return;
+    string line; int size_m, ditem; bool empty_seq = false;
+
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        vector<bool> counted(L, 0);
+        istringstream word(line);
+
+        if (!empty_seq) items.emplace_back();
+        string itm; size_m = 0; bool sgn = false; empty_seq = true;
+
+        while (word >> itm) {
+            ditem = stoi(itm);
+
+            if (item_dic[abs(ditem) - 1] == -1) {
+                if (!sgn) sgn = ditem < 0;
+                continue;
+            } else {
+                ditem = (ditem > 0)
+                      ?  item_dic[ditem - 1]
+                      : -item_dic[-ditem - 1];
+            }
+            empty_seq = false;
+
+            if (sgn) { if (ditem > 0) ditem = -ditem; sgn = false; }
+
+            items.back().push_back(ditem);
+
+            if (!counted[abs(ditem) - 1] && !just_build) {
+                DFS[abs(ditem) - 1].seq_ID.push_back(items.size() - 1);
+                DFS[abs(ditem) - 1].str_pnt.push_back(items.back().size() - 1);
+                ++DFS[abs(ditem) - 1].freq;
+                counted[abs(ditem) - 1] = true;
+            }
+            ++size_m;
+        }
+        if (empty_seq) continue;
+
+        ++N;  E += size_m;  M = max<unsigned int>(M, size_m);
+    }
+}
+
+static bool Load_items(string& inst)
+{
+    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);
+
+        items.emplace_back();
+        string itm; size_m = 0;
+
+        while (word >> itm) {
+            ditem = stoi(itm);
+            if (L < abs(ditem)) {
+                L = abs(ditem);
+                while (DFS.size() < L) {
+                    DFS.emplace_back(-int(DFS.size()) - 1);
+                    counted.push_back(0);
+                }
+            }
+            items.back().push_back(ditem);
+
+            if (!counted[abs(ditem) - 1] && !just_build) {
+                DFS[abs(ditem) - 1].seq_ID.push_back(items.size() - 1);
+                DFS[abs(ditem) - 1].str_pnt.push_back(items.back().size() - 1);
+                ++DFS[abs(ditem) - 1].freq;
+                counted[abs(ditem) - 1] = true;
+            }
+            ++size_m;
+        }
+        E += size_m;
+        M = max<unsigned int>(M, size_m);
+    }
+    return true;
+}
+
+} // namespace largepp  // ─── END namespace ──────────────────────

effspm/largepp/src/load_inst.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <pybind11/pybind11.h>
+
+namespace largepp {
+using namespace std;
+
+// ───── public entry points ───────────────────────────────────────
+bool Load_instance(string& items_file, double thresh);
+void Load_py(const pybind11::object& py_data, double thresh);
+
+// ───── shared state (defined once in load_inst.cpp) ──────────────
+extern vector<vector<int>> items;      // encoded database
+extern string              out_file;
+
+extern bool b_disp, b_write, use_dic, just_build, ovr_count, pre_pro;
+
+extern unsigned int        M, L, time_limit;
+extern unsigned long long  N;          // # sequences
+extern double              theta;      // support threshold
+extern unsigned long long  E;          // total entries
+extern clock_t             start_time;
+
+} // namespace largepp

effspm/largepp/src/utility.cpp

@@ -0,0 +1,34 @@
+#include "utility.hpp"
+#include <string>
+
+namespace largepp {
+
+// ─── instantiate the globals declared in the header ─────────────
+bool  b_disp   = false;
+bool  b_write  = false;
+bool  use_dic  = false;
+bool  just_build = false;
+bool  ovr_count  = false;
+bool  pre_pro  = false;
+bool  use_list = true;          // large-prefix flag the binder toggles
+unsigned int time_limit = 36000;
+std::string out_file;  
+std::vector<std::vector<int>> collected;  // mined pattern output
+
+
+std::clock_t start_time = 0;
+
+// ─── helper implementations ─────────────────────────────────────
+void ClearCollected()                       { collected.clear(); }
+
+const std::vector<std::vector<int>>& GetCollected()
+{
+    return collected;
+}
+
+double give_time(std::clock_t ticks)
+{
+    return static_cast<double>(ticks) / CLOCKS_PER_SEC;
+}
+
+} // namespace largepp

effspm/largepp/src/utility.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <vector>
+#include <ctime>
+#include <string>
+
+namespace largepp {
+
+// Flag & option globals (only declare here – actual values in utility.cpp)
+extern bool b_disp, b_write, use_dic, just_build, ovr_count, pre_pro;
+extern bool use_list;                  // ← NEW (large-prefix needs this)
+extern unsigned int time_limit;
+
+// Pattern buffer that _effspm.cpp_ returns to Python
+extern std::vector<std::vector<int>> collected;
+
+// Helper functions every source file uses
+void ClearCollected();                                   // wipe buffer
+const std::vector<std::vector<int>>& GetCollected();     // read buffer
+double give_time(std::clock_t ticks);                    // secs from clocks
+
+} // namespace largepp

effspm/load_inst.cpp

@@ -0,0 +1,252 @@
+#include<iostream>
+#include <sstream>
+#include <algorithm>
+#include "load_inst.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+#include <math.h>
+
+using namespace std;
+
+unsigned int M = 0, L = 0;
+unsigned long long int N = 0, E = 0, theta;
+
+vector<vector<int>> items;
+vector<Pattern> DFS;
+vector<int> item_dic;
+
+bool Load_items(string& inst);
+void Load_items_pre(string& inst);
+bool Preprocess(string& inst, double thresh);
+
+bool Load_instance(string &items_file, double thresh) {
+
+	clock_t kk = clock();
+	if (pre_pro) {
+		if(!Preprocess(items_file, thresh))
+			return 0;
+
+		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);
+	
+		N = items.size();
+
+	}
+	else if (!Load_items(items_file))
+		return 0;
+	else {
+		if (thresh < 1)
+			theta = ceil(thresh * N);
+		else
+			theta = 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";
+
+
+	return 1;
+}
+
+bool Preprocess(string &inst, double thresh) {
+
+	ifstream file(inst);
+
+	vector<unsigned int> freq(1000000);
+	vector<unsigned int> counted(1000000, 0);
+
+	if (file.good()) {
+		string line;
+		int ditem;
+		while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+			++N;
+			istringstream word(line);
+			string itm;
+			while (word >> itm) {
+				ditem = stoi(itm);
+				if (L < abs(ditem))
+					L = abs(ditem);
+			
+				if (freq.size() < L) {
+					freq.reserve(L);
+					counted.reserve(L);
+					while (freq.size() < L) {
+						freq.push_back(0);
+						counted.push_back(0);
+					}
+				}
+				
+				if (counted[abs(ditem) - 1] != N) {
+					++freq[abs(ditem) - 1];
+					counted[abs(ditem) - 1] = N;
+				}
+			}
+		}
+	}
+	else {
+		cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+		return 0;
+	}
+
+	if (thresh < 1)
+		theta = ceil(thresh * N);
+	else
+		theta = 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 1;
+}
+
+
+void Load_items_pre(string &inst) {
+
+	ifstream file(inst);
+
+	if (file.good()) {
+		string line;
+		int size_m;
+		int ditem;
+		bool empty_seq = 0;
+		while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+			vector<bool> counted(L, 0);
+			istringstream word(line);
+			if (!empty_seq) {
+				vector<int> temp;
+				items.push_back(temp);
+			}
+			string itm;
+			size_m = 0;
+			bool sgn = 0; 
+			empty_seq = 1;
+			while (word >> itm) {
+				
+				ditem = stoi(itm);
+
+				if (item_dic[abs(ditem) - 1] == -1) {
+					if (!sgn)
+						sgn = ditem < 0;
+					continue;
+				}
+				else {
+					if (ditem > 0)
+						ditem = item_dic[ditem - 1];
+					else
+						ditem = -item_dic[-ditem - 1];
+				}
+
+				empty_seq = 0;
+
+				if (sgn) {
+					if (ditem > 0)
+						ditem = -ditem;
+					sgn = 0;
+				}
+			
+				items.back().push_back(ditem);
+
+				if (!counted[abs(ditem) - 1]) {
+					DFS[abs(ditem) - 1].seq_ID.push_back(items.size() - 1);
+					DFS[abs(ditem) - 1].str_pnt.push_back(items.back().size() - 1);
+					++DFS[abs(ditem) - 1].freq;
+					counted[abs(ditem) - 1] = 1;
+				}
+
+				++size_m;
+			}
+
+			if (empty_seq)
+				continue;
+
+			++N;
+
+			E += size_m;
+
+			if (size_m > M)
+				M = size_m;
+			
+		}
+	}
+}
+
+bool Load_items(string &inst) {
+
+	ifstream file(inst);
+
+	if (file.good()) {
+		string line;
+		int size_m;
+		int ditem;
+		while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+			++N;
+			vector<bool> counted(L, 0);
+			istringstream word(line);
+			items.emplace_back();
+			string itm;
+			size_m = 0;
+			while (word >> itm) {
+				ditem = stoi(itm);
+				if (L < abs(ditem)) {
+					L = abs(ditem);
+					while (DFS.size() < L) {
+						DFS.emplace_back(-DFS.size() - 1);
+						counted.push_back(0);
+					}
+				}
+			
+				items.back().push_back(ditem);
+
+				if (!counted[abs(ditem) - 1]) {
+					DFS[abs(ditem) - 1].seq_ID.push_back(items.size() - 1);
+					DFS[abs(ditem) - 1].str_pnt.push_back(items.back().size() - 1);
+					++DFS[abs(ditem) - 1].freq;
+					counted[abs(ditem) - 1] = 1;
+				}
+
+				++size_m;
+			}
+
+			E += size_m;
+
+			if (size_m > M)
+				M = size_m;
+	
+		}
+			}
+	else {
+		cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+		return 0;
+	}
+
+	return 1;
+
+}
+
+
+
+
+
+
+
+
+

effspm/load_inst.hpp

@@ -0,0 +1,31 @@
+// effspm/load_inst.hpp
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <ctime>    // for clock_t
+
+using namespace std;
+
+// ------------------------------------------------------------
+// forward declare Pattern (defined in freq_miner.hpp)
+class Pattern;
+
+
+// Main entrypoint: load your file on disk into 'items', build DFS, theta, etc.
+bool Load_instance(string &items_file, double thresh);
+
+// storage & globals shared between the C++-CLI & Python bindings
+extern vector<vector<int>> items;
+extern vector<Pattern>     DFS;         // now Pattern is known
+extern vector<int>         item_dic;
+
+extern string              out_file;
+extern bool                b_disp, b_write, use_dic, use_list, pre_pro;
+
+extern unsigned int        M, L, time_limit;
+extern unsigned long long  N, E, theta; // E = total number of entries
+
+extern clock_t             start_time;

effspm/utility.cpp

@@ -0,0 +1,55 @@
+#include "utility.hpp"
+#include <iostream>
+#include <fstream>
+
+// timing
+std::clock_t start_time;
+
+// flags
+bool b_disp = false, b_write = false, use_dic = false, use_list = false, pre_pro = false;
+unsigned int time_limit = 10 * 3600;
+std::string out_file;
+
+// storage for Python
+static std::vector<std::vector<int>> collected_patterns;
+
+double give_time(std::clock_t end_time) {
+    return static_cast<double>(end_time) / CLOCKS_PER_SEC;
+}
+
+void ClearCollected() {
+    collected_patterns.clear();
+}
+
+const std::vector<std::vector<int>>& GetCollected() {
+    return collected_patterns;
+}
+
+// collect for Python
+void CollectPattern(const std::vector<int>& seq) {
+    collected_patterns.push_back(seq);
+}
+
+// non-const overload forwards to const version
+void Out_patt(std::vector<int>& seq, unsigned int freq) {
+    Out_patt(static_cast<const std::vector<int>&>(seq), freq);
+}
+
+// actual implementation
+void Out_patt(const std::vector<int>& seq, unsigned int freq) {
+    // 1) collect for Python
+    CollectPattern(seq);
+
+    // 2) optional console output
+    if (b_disp) {
+        for (int x : seq) std::cout << x << ' ';
+        std::cout << "\n************** Freq: " << freq << "\n";
+    }
+
+    // 3) optional file output
+    if (b_write) {
+        std::ofstream ofs(out_file, std::ios::app);
+        for (int x : seq) ofs << x << ' ';
+        ofs << "\n************** Freq: " << freq << "\n";
+    }
+}

effspm/utility.hpp

@@ -0,0 +1,29 @@
+#ifndef UTILITY_HPP
+#define UTILITY_HPP
+
+#include <vector>
+#include <string>
+#include <ctime>
+
+// timing
+extern std::clock_t start_time;
+double give_time(std::clock_t end_time);
+
+// flags (shared with main.cpp)
+extern bool b_disp, b_write, use_dic, use_list, pre_pro;
+extern unsigned int time_limit;
+extern std::string out_file;
+
+// Python-binding collection
+void ClearCollected();
+const std::vector<std::vector<int>>& GetCollected();
+
+// pattern collection & output
+void CollectPattern(const std::vector<int>& seq);
+
+// two overloads of Out_patt so calls with non‑const or const vectors both link
+void Out_patt(std::vector<int>& seq, unsigned int freq);
+void Out_patt(const std::vector<int>& seq, unsigned int freq);
+
+#endif // UTILITY_HPP
+