effspm 0.1.7__cp312-cp312-win_amd64.whl → 0.2.6__cp312-cp312-win_amd64.whl

effspm/largehm/src/load_inst.cpp

@@ -0,0 +1,357 @@
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <fstream>
+#include <cmath>
+#include <ctime>
+
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+
+namespace largehm {
+using namespace std;
+
+string out_file;
+string folder;
+
+bool b_disp       = false;
+bool b_write      = false;
+bool use_dic      = false;
+bool use_list     = false;
+bool just_build   = false;
+bool pre_pro      = false;
+bool itmset_exists = false;
+
+unsigned int M         = 0;
+unsigned int L         = 0;
+unsigned int mlim      = 0;
+unsigned int time_limit = 0;
+
+unsigned long long int N     = 0;
+unsigned long long int theta = 0;
+unsigned long long int E     = 0;
+
+clock_t start_time = 0;
+
+vector<vector<int>> items;
+
+vector<int> item_dic;
+vector<Pattern> DFS;
+vector<VPattern> VDFS;
+
+
+bool Load_instance(string& items_file, double thresh) {
+    // ─── 1) CLEAR ANY leftover state from a previous run ───
+    Tree.clear();
+    VTree.clear();
+    CTree.clear();
+    DFS.clear();
+    VDFS.clear();
+    item_dic.clear();
+    items.clear();
+
+    N = 0;
+    M = 0;
+    L = 0;
+    E = 0;
+    theta = 0;
+    itmset_exists = false;
+    // ────────────────────────────────────────────────────
+
+    clock_t kk = clock();
+
+    // Insert fresh dummy root node:
+	
+
+   
+
+    Tree.emplace_back(0, 0, 0);
+
+    if (!pre_pro) {
+        if (!Load_items(items_file))
+            return false;
+        DFS.reserve(L);
+        while (DFS.size() < L) {
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        }
+        VDFS.reserve(L);
+        while (VDFS.size() < L) {
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        }
+        if (thresh < 1.0) {
+            theta = static_cast<unsigned long long>(ceil(thresh * N));
+        } else {
+            theta = static_cast<unsigned long long>(thresh);
+        }
+    }
+    else {
+        if (!Load_items(items_file))
+            return false;
+        if (thresh < 1.0) {
+            theta = static_cast<unsigned long long>(ceil(thresh * N));
+        } else {
+            theta = static_cast<unsigned long long>(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";
+    // cout << "Total Trie nodes: " << Tree.size()
+    //      << " Total CTree nodes: " << CTree.size()
+    //      << " Total VTree nodes: " << VTree.size() << endl;
+
+    return true;
+}
+
+
+bool Preprocess(string &inst, double thresh) {
+    vector<unsigned long long int> MN(100, 0);
+    vector<vector<bool>> ML(100, vector<bool>(1000000, false));
+
+    ifstream file(inst);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    vector<unsigned long long int> freq(1000000, 0ULL);
+    vector<unsigned long long int> counted(1000000, 0ULL);
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        if (N % 10000000 == 0)
+            cout << "N: " << N << endl;
+
+        istringstream word(line);
+        string itm;
+        int size_m = 0;
+        while (word >> itm) {
+            ++size_m;
+            ditem = stoi(itm);
+
+            if (ditem > 0)
+                itmset_exists = true;
+            else
+                ditem = -ditem;
+
+            if (size_m < (int)MN.size()) {
+                ++MN[size_m - 1];
+                if ((int)ML[size_m - 1].size() < ditem) {
+                    ML[size_m - 1].resize(ditem, false);
+                }
+                ML[size_m - 1][ditem - 1] = true;
+            }
+
+            if (L < static_cast<unsigned int>(ditem)) {
+                L = static_cast<unsigned int>(ditem);
+            }
+
+            if ((int)freq.size() < ditem) {
+                freq.resize(ditem, 0ULL);
+                counted.resize(ditem, 0ULL);
+            }
+            if (counted[ditem - 1] != N) {
+                ++freq[ditem - 1];
+                counted[ditem - 1] = N;
+            }
+        }
+        if (size_m > (int)M)
+            M = size_m;
+    }
+
+    if (thresh < 1.0) {
+        theta = static_cast<unsigned long long>(ceil(thresh * N));
+    } else {
+        theta = static_cast<unsigned long long>(thresh);
+    }
+
+    int real_L = 0;
+    item_dic.assign(L, -1);
+    vector<bool> item_in(L, false);
+    for (int i = 0; i < (int)L; ++i) {
+        if (freq[i] >= theta) {
+            item_dic[i] = ++real_L;
+            item_in[i] = true;
+        }
+    }
+
+    cout << "Original number of items: " << L << " Reduced to: " << real_L << endl;
+
+    unsigned long long int LpM = 1;
+    mlim = M;
+    int orgmlim = 0;
+    int ulim = min(1 + real_L / 4, 10);
+    unsigned long long int ml;
+
+    for (int i = 0; i + ulim < (int)MN.size() && i + ulim < (int)M; ++i) {
+        ml = 0;
+        for (int j = 0; j < (int)L; ++j) {
+            if (ML[i][j] && item_in[j])
+                ++ml;
+        }
+        LpM *= ml * (1 + itmset_exists);
+        cout << ml << " " << LpM << " " << MN[i] << endl;
+        if (LpM * ulim > MN[i]) {
+            orgmlim = i;
+            while (i + ulim - 1 < (int)MN.size() && i + ulim - 1 < (int)M) {
+                cout << (MN[i - 1] - MN[i + ulim - 1]) << " "
+                     << MN[i + ulim - 1] << endl;
+                if ((MN[i - 1] - MN[i + ulim - 1]) < MN[i + ulim - 1]
+                     && MN[i + ulim - 1] < 600000000) {
+                    mlim = i - 1;
+                    break;
+                }
+                ++i;
+            }
+            break;
+        }
+    }
+
+    cout << "M is: " << M << " Mlim is: " << mlim
+         << " ulim is: " << ulim
+         << " original mlim is: " << orgmlim
+         << " guess is: "
+         << round((log(N) - log(6)) / log(real_L)) << endl;
+
+    if (mlim < (int)M) {
+        for (int i = 0; i < real_L; ++i)
+            VDFS.emplace_back(i);
+    }
+
+    L = static_cast<unsigned int>(real_L);
+    N = 0;
+    M = 0;
+    return true;
+}
+
+
+bool Load_items_pre(string &inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        vector<int> temp_lim;
+        bool sgn = false;
+
+        // L is final from Preprocess
+        while (word >> itm) {
+            ditem = stoi(itm);
+            if (item_dic[std::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];
+            }
+            if (sgn) {
+                if (ditem > 0)
+                    ditem = -ditem;
+                sgn = false;
+            }
+            if (temp_vec.size() <= (size_t)mlim)
+                temp_vec.push_back(ditem);
+            else
+                temp_lim.push_back(ditem);
+        }
+
+        if (temp_vec.empty())
+            continue;
+
+        ++N;
+        if (N % 10000000 == 0)
+            cout << N << endl;
+
+        if (temp_vec.size() + temp_lim.size() > (size_t)M)
+            M = static_cast<unsigned int>(temp_vec.size() + temp_lim.size());
+
+        // ─── Ensure DFS/VDFS size before Build_MDD ───
+        while (DFS.size() < L)
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        while (VDFS.size() < L)
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        // ──────────────────────────────────────────────
+
+        Build_MDD(temp_vec, temp_lim);
+    }
+
+    return true;
+}
+
+
+bool Load_items(string &inst_name) {
+	// std::cerr << "[SANITY] In Load_items: inst_name='"
+	// << inst_name << "'" << std::endl;
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        if (N % 1000000 == 0)
+            cout << "Found " << N << " sequence, with max line len "
+                 << M << ", and " << L << " items, and " << E
+                 << " enteries\n";
+
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        vector<int> temp_lim;
+
+        while (word >> itm) {
+            ditem = stoi(itm);
+
+            if (ditem > 0)
+                itmset_exists = true;
+
+            if (L < static_cast<unsigned int>(std::abs(ditem))) {
+                L = static_cast<unsigned int>(std::abs(ditem));
+                // Immediately grow DFS/VDFS to handle new L
+                while (DFS.size() < L)
+                    DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+                while (VDFS.size() < L)
+                    VDFS.emplace_back(static_cast<int>(VDFS.size()));
+            }
+
+            if (temp_vec.size() < (size_t)mlim)
+                temp_vec.push_back(ditem);
+            else
+                temp_lim.push_back(ditem);
+        }
+         E += static_cast<unsigned long long>(temp_vec.size() + temp_lim.size());
+        if (temp_vec.size() + temp_lim.size() > (size_t)M)
+            M = static_cast<unsigned int>(temp_vec.size() + temp_lim.size());
+
+        // ─── Ensure DFS/VDFS size before Build_MDD ───
+        while (DFS.size() < L)
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        while (VDFS.size() < L)
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        // ──────────────────────────────────────────────
+
+        Build_MDD(temp_vec, temp_lim);
+    }
+
+    return true;
+}
+
+} // namespace largehm

effspm/largehm/src/load_inst.hpp

@@ -0,0 +1,64 @@
+#ifndef LARGEHM_LOAD_INST_HPP
+#define LARGEHM_LOAD_INST_HPP
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include <ctime>     // for clock_t
+
+// We need Pattern and VPattern, so include freq_miner.hpp here:
+#include "freq_miner.hpp"
+
+namespace largehm {
+
+//
+// ─── Globals & Function Prototypes ───────────────────────────────────────────
+//
+
+// Output/folder:
+extern std::string out_file;
+extern std::string folder;
+
+// Flags:
+extern bool b_disp;
+extern bool b_write;
+extern bool use_dic;
+extern bool use_list;
+extern bool just_build;
+extern bool pre_pro;
+extern bool itmset_exists;
+
+// Database statistics:
+extern unsigned int M;
+extern unsigned int L;
+extern unsigned int mlim;
+extern unsigned int time_limit;
+
+extern unsigned long long int N;
+extern unsigned long long int theta;
+extern unsigned long long int E;
+
+// Timing:
+extern clock_t start_time;
+
+// In‐memory sequences (only if “in‐memory” mode):
+extern std::vector<std::vector<int>> items;
+
+// Preprocessing dictionary (maps original → compressed IDs):
+extern std::vector<int> item_dic;
+
+// DFS stacks used by the miner (Pattern / VPattern):
+extern std::vector<Pattern>   DFS;
+extern std::vector<VPattern>  VDFS;
+
+// Internal loader functions:
+bool Load_items_pre(std::string &inst_name);
+bool Load_items(std::string &inst_name);
+bool Preprocess(std::string &inst, double thresh);
+
+// Main entry‐point for loading & building the MDD:
+bool Load_instance(std::string &items_file, double thresh);
+
+} // namespace largehm
+
+#endif // LARGEHM_LOAD_INST_HPP

effspm/largehm/src/utility.cpp

@@ -0,0 +1,38 @@
+#include "utility.hpp"
+#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;
+
+}
+
+
+
+// float give_time(clock_t kk) {
+// 	float ll = ((float)kk) / CLOCKS_PER_SEC;
+// 	return ll;
+// }
+}

effspm/largehm/src/utility.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <vector>
+#include <time.h>
+#include <string>
+#include "build_mdd.hpp"
+
+namespace largehm {
+using namespace std;
+
+  extern std::vector<std::vector<int>> collected;
+
+  // Helpers to clear and fetch collected patterns from Python:
+  inline void ClearCollected() {
+    collected.clear();
+  }
+  inline const std::vector<std::vector<int>>& GetCollected() {
+    return collected;
+  }
+
+  // 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);
+
+
+}

effspm/largepp/src/freq_miner.cpp

@@ -0,0 +1,170 @@
+#include <iostream>
+#include <time.h>
+#include "freq_miner.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;
+
+void Freq_miner() {
+
+	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) {
+		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();
+	}
+
+}
+
+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;
+	}
+
+}
+
+
+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();
+	}
+}
+}
+
+
+
+

effspm/largepp/src/freq_miner.hpp

@@ -0,0 +1,43 @@
+#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;
+
+	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;
+	}
+
+
+	Pattern(int item) {
+		seq.push_back(item);
+		freq = 0;
+	}
+
+	Pattern() {
+		freq = 0;
+	}
+
+};
+
+extern vector<Pattern> DFS;				//DFS queue of potential patterns to extend
+
+extern unsigned long long int num_patt;
+}