effspm 0.2.7__cp312-cp312-win_amd64.whl → 0.3.3__cp312-cp312-win_amd64.whl

effspm/largehm/src/load_inst.cpp

@@ -1,131 +1,106 @@
 #include <iostream>
 #include <sstream>
 #include <algorithm>
-#include <fstream>
-#include <cmath>
-#include <ctime>
-
+#include <math.h>
 #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;
+using namespace std;
 
-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, L = 0, mlim;
+unsigned long long int N = 0, theta, E = 0;
 
-unsigned int M         = 0;
-unsigned int L         = 0;
-unsigned int mlim      = 0;
-unsigned int time_limit = 0;
+bool itmset_exists = 0;
 
-unsigned long long int N     = 0;
-unsigned long long int theta = 0;
-unsigned long long int E     = 0;
+vector<int>      item_dic;
+vector<Pattern>  DFS;
+vector<VPattern> VDFS;
 
-clock_t start_time = 0;
+string out_file, folder;
 
-vector<vector<int>> items;
+bool b_disp      = 0;
+bool b_write     = 0;
+bool use_dic     = 0;
+bool just_build  = 0;
+bool pre_pro     = 1;
 
-vector<int> item_dic;
-vector<Pattern> DFS;
-vector<VPattern> VDFS;
+unsigned int time_limit = 10 * 3600;
+clock_t start_time;
 
+void Load_items_pre(string &inst_name);
+bool Load_items(string &inst_name);
+bool Preprocess(string& inst, double thresh);
 
 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();
+    Tree.emplace_back(0, 0, 0);
 
-    // Insert fresh dummy root node:
-	
-
-   
+    if (pre_pro) {
+        if (!Preprocess(items_file, thresh))
+            return 0;
 
-    Tree.emplace_back(0, 0, 0);
+        // ✅ KEEP THIS: Preprocess timing
+        if (b_disp)
+           cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
 
-    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);
-        }
+        for (int i = 0; i < (int)L; ++i)
+            DFS.emplace_back(-i - 1);
+
+        kk = clock();
+        Load_items_pre(items_file);
+
     }
+    else if (!Load_items(items_file))
+        return 0;
     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);
-        }
+        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";
+    // ✅ KEEP THIS: MDD build timing
+    if (b_disp)
+       cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+
+    // ✅ KEEP THIS: main summary line
+    if (b_disp)
+       cout << "Found " << N << " sequence, with max line len " << M
+            << ", and " << L << " items, and " << E << " enteries\n";
+
+    // ❌ COMMENT OUT: extra debug
     // cout << "Total Trie nodes: " << Tree.size()
     //      << " Total CTree nodes: " << CTree.size()
     //      << " Total VTree nodes: " << VTree.size() << endl;
 
-    return true;
+    return 1;
 }
 
-
 bool Preprocess(string &inst, double thresh) {
-    vector<unsigned long long int> MN(100, 0);
-    vector<vector<bool>> ML(100, vector<bool>(1000000, false));
 
+    vector<unsigned long long int> MN(100, 0);
+    vector<vector<bool>> ML(100, vector<bool>(1000000, 0));
     ifstream file(inst);
+
+    vector<unsigned long long int> freq(1000000);
+    vector<unsigned long long int> counted(1000000, 0);
+
     if (!file.good()) {
-        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
-        return false;
+        // cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return 0;
     }
 
-    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;
+        // if (N % 10000000 == 0) cout << "N: " << N << endl;
 
         istringstream word(line);
         string itm;
@@ -135,107 +110,114 @@ bool Preprocess(string &inst, double thresh) {
             ditem = stoi(itm);
 
             if (ditem > 0)
-                itmset_exists = true;
+                itmset_exists = 1;
             else
-                ditem = -ditem;
+                ditem *= -1;
 
             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);
+                if (ML[size_m - 1].size() < (size_t)ditem) {
+                    ML[size_m - 1].reserve(ditem);
+                    while (ML[size_m - 1].size() < (size_t)ditem)
+                        ML[size_m - 1].push_back(0);
                 }
-                ML[size_m - 1][ditem - 1] = true;
+                ML[size_m - 1][ditem - 1] = 1;
             }
 
-            if (L < static_cast<unsigned int>(ditem)) {
-                L = static_cast<unsigned int>(ditem);
-            }
+            if (L < (unsigned int)ditem)
+                L = ditem;
 
-            if ((int)freq.size() < ditem) {
-                freq.resize(ditem, 0ULL);
-                counted.resize(ditem, 0ULL);
+            if (freq.size() < L) {
+                freq.reserve(L);
+                counted.reserve(L);
+                while (freq.size() < L) {
+                    freq.push_back(0);
+                    counted.push_back(0);
+                }
             }
+
             if (counted[ditem - 1] != N) {
                 ++freq[ditem - 1];
                 counted[ditem - 1] = N;
             }
+
+            ++E; // count entries
         }
         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);
-    }
+    if (thresh < 1)
+        theta = ceil(thresh * N);
+    else
+        theta = thresh;
 
     int real_L = 0;
-    item_dic.assign(L, -1);
-    vector<bool> item_in(L, false);
+    item_dic = vector<int>(L, -1);
+    vector<bool> item_in(L, 0);
     for (int i = 0; i < (int)L; ++i) {
         if (freq[i] >= theta) {
             item_dic[i] = ++real_L;
-            item_in[i] = true;
+            item_in[i]  = 1;
         }
     }
 
-    cout << "Original number of items: " << L << " Reduced to: " << real_L << endl;
+    // ❌ COMMENTED: extra stats
+    // 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;
-
+    int coef = 1 + 1 * itmset_exists;
     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;
+        LpM *= ml * coef;
+        // 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) {
+                // 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;
+                i += 1;
             }
             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;
+    // 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) {
+    if (mlim < M) {
         for (int i = 0; i < real_L; ++i)
             VDFS.emplace_back(i);
     }
 
-    L = static_cast<unsigned int>(real_L);
+    L = real_L;
     N = 0;
     M = 0;
-    return true;
+
+    return 1;
 }
 
+void Load_items_pre(string &inst_name) {
 
-bool Load_items_pre(string &inst_name) {
     ifstream file(inst_name);
-    if (!file.good()) {
-        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
-        return false;
-    }
+    if (!file.good())
+        return;
 
     string line;
     int ditem;
@@ -244,12 +226,11 @@ bool Load_items_pre(string &inst_name) {
         string itm;
         vector<int> temp_vec;
         vector<int> temp_lim;
-        bool sgn = false;
-
-        // L is final from Preprocess
+        bool sgn = 0;
         while (word >> itm) {
             ditem = stoi(itm);
-            if (item_dic[std::abs(ditem) - 1] == -1) {
+
+            if (item_dic[abs(ditem) - 1] == -1) {
                 if (!sgn)
                     sgn = (ditem < 0);
                 continue;
@@ -259,99 +240,81 @@ bool Load_items_pre(string &inst_name) {
                 else
                     ditem = -item_dic[-ditem - 1];
             }
+
             if (sgn) {
                 if (ditem > 0)
                     ditem = -ditem;
-                sgn = false;
+                sgn = 0;
             }
-            if (temp_vec.size() <= (size_t)mlim)
+
+            if (temp_vec.size() <= mlim)
                 temp_vec.push_back(ditem);
             else
                 temp_lim.push_back(ditem);
+
+            ++E;
         }
 
         if (temp_vec.empty())
             continue;
 
         ++N;
-        if (N % 10000000 == 0)
-            cout << N << endl;
+        // 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()));
-        // ──────────────────────────────────────────────
+        if (temp_vec.size() + temp_lim.size() > M)
+            M = temp_vec.size() + temp_lim.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;
+        // cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return 0;
     }
 
     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";
+        // 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()));
+                itmset_exists = 1;
+            if (L < (unsigned int)abs(ditem)) {
+                L = abs(ditem);
+                while (DFS.size() < L) {
+                    DFS.reserve(L);
+                    DFS.emplace_back(-DFS.size() - 1);
+                }
             }
 
-            if (temp_vec.size() < (size_t)mlim)
+            if (temp_vec.size() < mlim)
                 temp_vec.push_back(ditem);
             else
                 temp_lim.push_back(ditem);
+
+            ++E;
         }
-         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()));
-        // ──────────────────────────────────────────────
+        if (temp_vec.size() + temp_lim.size() > M)
+            M = temp_vec.size();
 
         Build_MDD(temp_vec, temp_lim);
     }
 
-    return true;
+    return 1;
 }
 
 } // namespace largehm

effspm/largehm/src/load_inst.hpp

@@ -1,64 +1,27 @@
-#ifndef LARGEHM_LOAD_INST_HPP
-#define LARGEHM_LOAD_INST_HPP
+#pragma once
 
-#include <string>
 #include <vector>
+#include <string>
 #include <fstream>
-#include <ctime>     // for clock_t
-
-// We need Pattern and VPattern, so include freq_miner.hpp here:
-#include "freq_miner.hpp"
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <time.h>
 
 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;
+using namespace std;
 
-// Database statistics:
-extern unsigned int M;
-extern unsigned int L;
-extern unsigned int mlim;
-extern unsigned int time_limit;
+bool Load_instance(string& items_file, double thresh);
 
-extern unsigned long long int N;
-extern unsigned long long int theta;
-extern unsigned long long int E;
+extern string out_file, folder;
 
-// 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;
+extern bool b_disp, b_write, use_dic, just_build, pre_pro, itmset_exists;
 
-// DFS stacks used by the miner (Pattern / VPattern):
-extern std::vector<Pattern>   DFS;
-extern std::vector<VPattern>  VDFS;
+extern unsigned int M, L, mlim, time_limit;
 
-// 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);
+extern unsigned long long int N, theta, E;
 
-// Main entry‐point for loading & building the MDD:
-bool Load_instance(std::string &items_file, double thresh);
+extern clock_t start_time;
 
 } // namespace largehm
-
-#endif // LARGEHM_LOAD_INST_HPP

effspm/largehm/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"
+
+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";
+
+	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;
+}