effspm 0.1.5__cp310-cp310-win_amd64.whl → 0.3.0__cp310-cp310-win_amd64.whl

effspm/largehm/src/freq_miner.hpp

@@ -0,0 +1,77 @@
+#ifndef LARGEHM_FREQ_MINER_HPP
+#define LARGEHM_FREQ_MINER_HPP
+#include <cstdint>
+#include <vector>
+#include <string>
+#include <fstream>
+#include <ctime>      // for clock_t
+extern std::vector<std::uint64_t> ancest_base;
+namespace largehm {
+
+//
+// ─── Pattern & VPattern ──────────────────────────────────────────────────────
+//
+
+class Pattern {
+public:
+    std::vector<int>            seq;
+    unsigned int                freq;
+    std::vector<int>            list;
+    std::vector<unsigned long long int> str_pnt;
+
+    Pattern(int start_code = 0) : freq(0) {
+        if (start_code != 0)
+            seq.push_back(start_code);
+    }
+};
+
+class VPattern {
+public:
+    std::vector<unsigned long long int> str_pnt;
+    std::vector<unsigned long long int> seq_ID;
+    int                                 ass_patt;
+
+    VPattern(int assoc = -1) : ass_patt(assoc) {}
+};
+
+//
+// ─── Globals used by Freq_miner ──────────────────────────────────────────────
+//
+extern std::vector<Pattern>    DFS;
+extern std::vector<VPattern>   VDFS;
+
+extern unsigned long long int num_patt;
+
+extern std::vector<bool>       ilist;
+extern std::vector<bool>       slist;
+
+extern std::vector<Pattern>    pot_patt;
+extern std::vector<VPattern>   pot_vpatt;
+extern std::vector<unsigned long long int> last_strpnt;
+
+extern std::vector<int>       DFS_numfound;
+
+extern Pattern                 _patt;
+extern VPattern                _vpatt;
+
+extern int                     itmset_size;
+extern int                     last_neg;
+extern bool                    ilist_nempty;
+
+//
+// ─── Function Prototypes ─────────────────────────────────────────────────────
+//
+void Freq_miner();
+void Extend_patt(Pattern& _patt);
+void Mine_vec(std::uint64_t seq_ID,
+              int pos,
+              int num_found,
+              std::vector<std::uint64_t>& ancest,
+              std::vector<int>& items,
+              std::uint64_t pnt,
+              int sgn);
+void Out_patt(std::vector<int>& seq, unsigned int freq);
+
+} // namespace largehm
+
+#endif // LARGEHM_FREQ_MINER_HPP

effspm/largehm/src/load_inst.cpp

@@ -0,0 +1,375 @@
+// ─── effspm/largehm/src/load_inst.cpp ────────────────────────────────────────
+
+#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;
+
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Load_instance
+// ─────────────────────────────────────────────────────────────────────────────
+bool Load_instance(string& items_file, double thresh) {
+    // 1) CLEAR leftover state
+    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();
+
+    // root
+    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);
+
+        start_time = clock();
+    }
+    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);
+
+        start_time = clock();
+    }
+
+    // 👇 only print when verbose/b_disp
+    if (b_disp) {
+        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;
+}
+
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Preprocess
+// ─────────────────────────────────────────────────────────────────────────────
+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()) {
+        if (b_disp)
+            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 (b_disp && 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;
+        }
+    }
+
+    if (b_disp)
+        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);
+
+        if (b_disp)
+            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) {
+                if (b_disp)
+                    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;
+        }
+    }
+
+    if (b_disp)
+        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;
+}
+
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Load_items_pre
+// ─────────────────────────────────────────────────────────────────────────────
+bool Load_items_pre(string &inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        if (b_disp)
+            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;
+
+        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 (b_disp && 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());
+
+        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;
+}
+
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Load_items (no preprocess)
+// ─────────────────────────────────────────────────────────────────────────────
+bool Load_items(string &inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        if (b_disp)
+            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 (b_disp && 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));
+
+                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());
+
+        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);
+
+
+}