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

effspm/btminer/src/load_inst.cpp

@@ -0,0 +1,275 @@
+// effspm/btminer/src/load_inst.cpp
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include <math.h>
+#include <time.h>
+
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+
+namespace btminer {
+
+using namespace std;
+
+// ---------------------------------------------------------------------
+// global definitions (must match load_inst.hpp)
+// ---------------------------------------------------------------------
+int  M = 0;
+int  N = 0;
+int  L = 0;
+unsigned long long E = 0ULL;    // matches header: extern unsigned long long E;
+int  num_nodes = 0;
+int  theta = 0;
+int  cur_node = 0;
+
+map<string, int>  item_map;
+map<int, string>  item_map_rev;
+
+std::vector<int>  freq;
+std::vector<int>  item_dic;
+
+// ✅ REAL DEFINITION lives here:
+std::vector<Pattern> DFS;
+
+string out_file, folder;
+bool   b_disp    = 0;
+bool   b_write   = 0;
+bool   use_dic   = 0;
+bool   just_build= 0;
+bool   pre_pro   = 1;
+
+int    N_mult    = 1;
+int    M_mult    = 1;
+int    time_limit= 30 * 3600;    // 30 hours, same as professor
+
+clock_t start_time;
+
+// ---------------------------------------------------------------------
+// forward decls
+// ---------------------------------------------------------------------
+void Load_items_pre(string &inst_name);
+bool Load_items(string &inst_name);
+bool Preprocess(string &inst, double thresh);
+
+// ---------------------------------------------------------------------
+// main loader
+// ---------------------------------------------------------------------
+bool Load_instance(string &items_file, double thresh) {
+    clock_t kk = clock();
+
+    // root node for MDD
+    Tree.emplace_back(0, 0, 0);
+
+    if (pre_pro) {
+        if (!Preprocess(items_file, thresh))
+            return false;
+
+        cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
+
+        // build empty DFS of size L
+        DFS.clear();
+        DFS.reserve(L);
+        for (int i = 0; i < L; ++i)
+            DFS.emplace_back(-i - 1);
+
+        kk = clock();
+        Load_items_pre(items_file);
+    }
+    else if (!Load_items(items_file)) {
+        return false;
+    }
+    else {
+        if (thresh < 1)
+            theta = static_cast<int>(ceil(thresh * N * N_mult));
+        else
+            theta = static_cast<int>(thresh);
+    }
+
+    cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+    cout << "Found " << N * N_mult
+         << " sequence, with max line len " << M
+         << ", and " << L << " items, and " << E << " enteries\n";
+    cout << "Total MDD nodes: " << Tree.size() << endl;
+
+    return true;
+}
+
+// ---------------------------------------------------------------------
+// preprocessing pass
+// ---------------------------------------------------------------------
+bool Preprocess(string &inst, double thresh) {
+    ifstream file(inst);
+
+    if (file.good()) {
+        string line;
+        while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+            ++N;
+            vector<bool> counted(L, false);
+
+            istringstream word(line);
+            string itm;
+            while (word >> itm) {
+                int ditem = stoi(itm);
+                if (L < abs(ditem))
+                    L = abs(ditem);
+
+                // extend freq / counted if L grew
+                while (static_cast<int>(freq.size()) < L) {
+                    freq.push_back(0);
+                    counted.push_back(false);
+                }
+
+                int idx = abs(ditem) - 1;
+                if (!counted[idx]) {
+                    ++freq[idx];
+                    counted[idx] = true;
+                }
+            }
+        }
+    } else {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    if (thresh < 1)
+        theta = static_cast<int>(ceil(thresh * N * N_mult));
+    else
+        theta = static_cast<int>(thresh);
+
+    // build item_dic with only frequent items
+    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;   // will be recounted in Load_items_pre
+
+    return true;
+}
+
+// ---------------------------------------------------------------------
+// load after preprocessing
+// ---------------------------------------------------------------------
+void Load_items_pre(string &inst_name) {
+    ifstream file(inst_name);
+
+    if (file.good()) {
+        string line;
+        while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+            istringstream word(line);
+            string itm;
+            vector<int> temp_vec;
+            bool sgn = false;
+            while (word >> itm) {
+                int ditem;
+                if (use_dic) {
+                    auto it = item_map.find(itm);
+                    if (it == item_map.end()) {
+                        item_map[itm] = ++L;
+                        item_map_rev[L] = itm;
+                        ditem = L;
+                    } else {
+                        ditem = it->second;
+                    }
+                } else {
+                    ditem = stoi(itm);
+                }
+
+                // drop infrequent items
+                if (freq[abs(ditem) - 1] < theta) {
+                    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;
+                }
+
+                temp_vec.push_back(ditem);
+            }
+
+            if (temp_vec.empty())
+                continue;
+
+            ++N;
+
+            if (static_cast<int>(temp_vec.size()) > M)
+                M = static_cast<int>(temp_vec.size());
+
+            // this increments E inside Build_MDD
+            Build_MDD(temp_vec);
+        }
+    }
+}
+
+// ---------------------------------------------------------------------
+// load without preprocessing
+// ---------------------------------------------------------------------
+bool Load_items(string &inst_name) {
+    ifstream file(inst_name);
+
+    if (file.good()) {
+        string line;
+        while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+            ++N;
+            istringstream word(line);
+            string itm;
+            vector<int> temp_vec;
+            while (word >> itm) {
+                int ditem;
+                if (use_dic) {
+                    auto it = item_map.find(itm);
+                    if (it == item_map.end()) {
+                        item_map[itm] = ++L;
+                        item_map_rev[L] = itm;
+                        ditem = L;
+                    } else {
+                        ditem = it->second;
+                    }
+                } else {
+                    ditem = stoi(itm);
+                    if (L < abs(ditem)) {
+                        L = abs(ditem);
+                        // make sure DFS is large enough (unless just_build)
+                        while (static_cast<int>(DFS.size()) < L && !just_build) {
+                            DFS.reserve(L);
+                            DFS.emplace_back(-((int)DFS.size()) - 1);
+                        }
+                    }
+                }
+
+                temp_vec.push_back(ditem);
+            }
+
+            if (static_cast<int>(temp_vec.size()) > M)
+                M = static_cast<int>(temp_vec.size());
+
+            Build_MDD(temp_vec);
+        }
+    } else {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    return true;
+}
+
+} // namespace btminer

effspm/btminer/src/load_inst.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <ctime>
+
+namespace btminer {
+
+using std::string;
+using std::vector;
+using std::map;
+using std::unordered_map;
+using std::unordered_set;
+
+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;
+
+extern int  N, M, L, theta, num_nodes, M_mult, N_mult, time_limit, cur_node;
+extern unsigned long long E;              // total number of entries (we need this for _effspm.cpp)
+
+extern std::clock_t start_time;
+
+// these 2 are for dictionary mode
+extern map<string,int> item_map;
+extern map<int,string> item_map_rev;
+
+extern vector<int> freq;
+extern vector<int> item_dic;
+
+// expose items so _effspm.cpp can fall back to seeding (it expects btminer::items)
+extern vector<vector<int>> items;
+
+class Pattern;
+extern vector<Pattern> DFS;
+
+} // namespace btminer

effspm/btminer/src/utility.cpp

@@ -0,0 +1,50 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "load_inst.hpp"
+#include <iostream>
+
+namespace btminer {
+
+int find_ID(vector<int>& vec, int itm) {
+    int plc = 0;
+    while (plc < static_cast<int>(vec.size()) && vec[plc] != itm)
+        ++plc;
+
+    if (plc == static_cast<int>(vec.size()))
+        return -1;
+    else
+        return plc;
+}
+
+bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec) {
+
+    std::vector<int> ancestors;
+
+    int cur_anct = Tree[cur_arc].anct;
+
+    while (Tree[cur_anct].itmset > Tree[str_pnt].itmset) {
+        if (Tree[cur_anct].item > 0)
+            ancestors.push_back(cur_anct);
+        cur_anct = Tree[cur_anct].anct;
+    }
+
+    if (Tree[cur_anct].itmset == Tree[str_pnt].itmset)
+        return true;
+    else {
+        for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+            for (int i = start; i < static_cast<int>(strpnt_vec.size()); ++i) {
+                if (strpnt_vec[i] == *it)
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+float give_time(clock_t kk) {
+    float ll = static_cast<float>(kk) / CLOCKS_PER_SEC;
+    return ll;
+}
+
+} // namespace btminer

effspm/btminer/src/utility.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <vector>
+#include <time.h>
+#include <string>
+#include "build_mdd.hpp"
+
+namespace btminer {
+
+using std::vector;
+
+int   find_ID(vector<int>& vec, int itm);
+float give_time(clock_t kk);
+bool  check_parent(int cur_arc, int str_pnt, int start, vector<int>& strpnt_vec);
+
+} // namespace btminer

effspm/freq_miner.hpp

@@ -1,7 +1,11 @@
 #pragma once
-
+#include <vector>
 #include "load_inst.hpp"
+#include <cstdlib> 
+#include <cmath> 
+#include <cstddef>  // for std::size_t
 
+using namespace std;
 void Freq_miner();
 void Out_patt(std::vector<int>& seq, unsigned int freq);
 
@@ -21,6 +25,8 @@ public:
 	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;

effspm/htminer/src/build_mdd.cpp

@@ -0,0 +1,139 @@
+#include <vector>
+#include <iostream>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+
+namespace htminer {
+
+// Forward declarations (unchanged)
+int Add_arc(int item, unsigned int last_arc, int& itmset, std::vector<unsigned int>& ancest_map);
+void Add_vec(std::vector<int>& items_lim, std::vector<unsigned int>& ancest_map, unsigned int last_arc, int itmset);
+
+// Global trees (unchanged)
+std::vector<Arc>  Tree;
+std::vector<VArc> VTree;
+std::vector<CArc> CTree;
+
+void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
+    // Prepare ancestor map of size L
+    std::vector<unsigned int> ancest_map(L, 0);
+
+    unsigned int last_arc = 0;
+    int          itmset   = 0;
+
+    // 1) normal items
+    for (size_t idx = 0; idx < items.size(); ++idx) {
+        int curr_item = items[idx];
+
+        ++E;   // ✅ count this entry, just like in btminer
+
+        last_arc = Add_arc(curr_item, last_arc, itmset, ancest_map);
+    }
+
+    // 2) tail / limited items
+    if (!items_lim.empty()) {
+        Add_vec(items_lim, ancest_map, last_arc, itmset);
+    }
+}
+
+int Add_arc(int item,
+            unsigned int last_arc,
+            int& itmset,
+            std::vector<unsigned int>& ancest_map)
+{
+    unsigned int anct = ancest_map[std::abs(item) - 1];
+    if (item < 0)
+        ++itmset;
+
+    unsigned int last_sibl = Tree[last_arc].chld;
+
+    if (last_sibl == 0) {
+        Tree.emplace_back(item, itmset, anct);
+        last_sibl = static_cast<unsigned int>(Tree.size() - 1);
+        Tree[last_arc].chld = last_sibl;
+
+        if (anct == 0)
+            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+    }
+    else {
+        while (Tree[last_sibl].item != item) {
+            if (Tree[last_sibl].sibl == 0) {
+                Tree.emplace_back(item, itmset, anct);
+                Tree[last_sibl].sibl = static_cast<unsigned int>(Tree.size() - 1);
+                last_sibl            = static_cast<unsigned int>(Tree.size() - 1);
+                if (anct == 0)
+                    DFS[std::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;
+
+    ++Tree[last_sibl].freq;
+
+    ancest_map[std::abs(item) - 1] = last_sibl;
+
+    return static_cast<int>(last_sibl);
+}
+
+void Add_vec(std::vector<int>& items_lim,
+             std::vector<unsigned int>& ancest,
+             unsigned int last_arc,
+             int itmset)
+{
+    items_lim.shrink_to_fit();
+
+    std::vector<bool> counted(L, false);
+
+    if (Tree[last_arc].itmset > 0) {
+        ancest.push_back(0);
+        ancest.shrink_to_fit();
+
+        for (size_t i = 0; i < items_lim.size(); ++i) {
+            int cur_itm = std::abs(items_lim[i]);
+
+            ++E;   // ✅ count this limited-entry too
+
+            if (ancest[cur_itm - 1] == 0 && !counted[cur_itm - 1]) {
+                if (i + 1 < static_cast<int>(items_lim.size())) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(-static_cast<int>(i) - 1);
+                    VDFS[cur_itm - 1].seq_ID.push_back(static_cast<unsigned int>(CTree.size()));
+                }
+                ++DFS[cur_itm - 1].freq;
+                counted[cur_itm - 1] = true;
+            }
+        }
+
+        CTree.emplace_back(ancest, items_lim);
+        Tree[last_arc].chld   = static_cast<unsigned int>(CTree.size() - 1);
+        Tree[last_arc].itmset = -itmset;
+    }
+    else {
+        std::vector<unsigned int>& ancest_ct = CTree[Tree[last_arc].chld].ancest;
+
+        for (size_t i = 0; i < items_lim.size(); ++i) {
+            int cur_itm = std::abs(items_lim[i]);
+
+            ++E;   // ✅ also count in this branch
+
+            if (!counted[cur_itm - 1] && ancest_ct[cur_itm - 1] == 0) {
+                if (i + 1 < static_cast<int>(items_lim.size())) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(static_cast<unsigned int>(i) + 1);
+                    VDFS[cur_itm - 1].seq_ID.push_back(static_cast<unsigned int>(VTree.size()));
+                }
+                ++DFS[cur_itm - 1].freq;
+                counted[cur_itm - 1] = true;
+            }
+        }
+
+        VTree.emplace_back(items_lim, ancest_ct.back());
+        CTree[Tree[last_arc].chld].ancest.back() = static_cast<unsigned int>(VTree.size());
+    }
+}
+
+} // namespace htminer

effspm/htminer/src/build_mdd.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "load_inst.hpp"
+
+namespace htminer {
+    void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim);
+
+    class Arc {
+    public:
+        unsigned int chld;    
+        unsigned int sibl;
+        unsigned int freq;        
+        unsigned int anct;
+        int itmset;
+        int item;
+
+        Arc(unsigned int _itm, int _itmset, unsigned int _anc) {
+            chld = 0;    
+            sibl = 0;
+            freq = 0;
+            itmset = _itmset;
+            anct = _anc;
+            item = _itm;
+        }
+
+        Arc() {
+            chld = 0;    
+            sibl = 0;
+            freq = 0;
+        }
+    };
+
+    class VArc {
+    public:
+        unsigned int sibl;    
+        std::vector<int> seq;
+
+        VArc(std::vector<int>& items, unsigned int _sib) {
+            sibl = _sib;
+            seq.swap(items);
+        }
+        
+        VArc() {
+            sibl = 0;
+        }
+    };
+
+    class CArc {
+    public:
+        std::vector<int> seq;
+        std::vector<unsigned int> ancest;
+
+        CArc(std::vector<unsigned int>& _anc, std::vector<int>& items) {
+            ancest.swap(_anc);
+            seq.swap(items);
+        }
+    };
+
+    extern std::vector<Arc> Tree;
+    extern std::vector<VArc> VTree;
+    extern std::vector<CArc> CTree;
+}