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

effspm/largepp/src/freq_miner.cpp

@@ -0,0 +1,198 @@
+#include <algorithm>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+
+#include "freq_miner.hpp"
+#include "pattern.hpp"
+#include "load_inst.hpp"
+#include "utility.hpp"
+
+namespace largepp {
+
+using std::abs;
+using std::cout;
+using std::endl;
+using std::ofstream;
+using std::swap;
+using std::vector;
+
+static void Out_patt(vector<int>& seq, unsigned int freq);
+static void Extend_patt(Pattern& _pattern);
+
+unsigned long long int num_patt = 0;      // counter for emitted patterns
+static Pattern _patt;                     // scratch pattern (for in-place extend)
+
+/* ------------------------------------------------------------------ */
+/*  Driver                                                            */
+/* ------------------------------------------------------------------ */
+void Freq_miner()
+{
+    // Build the candidate item list once (items that pass minsup at length-1)
+    vector<int> islist;
+    islist.reserve(L);
+    for (unsigned int i = 0; i < L; ++i) {
+        if (DFS[i].freq >= theta) islist.push_back(static_cast<int>(i));
+    }
+
+    // Seed each 1-length pattern’s extension lists
+    for (unsigned int i = 0; i < DFS.size(); ++i) {
+        DFS[i].ilist = islist;
+        DFS[i].slist = islist;
+    }
+
+    // DFS over the stack, extending only nodes whose current support ≥ theta
+    while (!DFS.empty() && give_time(std::clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta) {
+            Extend_patt(DFS.back());
+        } else {
+            DFS.pop_back();
+        }
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Extend_patt: given a frequent pattern, enumerate its i- and s-ext */
+/* ------------------------------------------------------------------ */
+static void Extend_patt(Pattern& _pattern)
+{
+    swap(_patt, _pattern);  // work on local scratch
+    DFS.pop_back();         // remove from stack
+
+    // Quick presence tables for allowed i-/s-extensions
+    vector<bool> slist(L, false);
+    vector<bool> ilist(L, false);
+    for (int idx : _patt.slist) slist[static_cast<size_t>(idx)] = true;
+    for (int idx : _patt.ilist) ilist[static_cast<size_t>(idx)] = true;
+
+    // Potential children buffers:
+    vector<Pattern> pot_patt(L * 2); // [0..L-1] = i-ext, [L..2L-1] = s-ext
+
+    // Find last negative from the end (boundary between itemsets)
+    int last_neg = static_cast<int>(_patt.seq.size()) - 1;
+    while (last_neg >= 0 && _patt.seq[static_cast<size_t>(last_neg)] > 0) --last_neg;
+
+    // Scan occurrences to build supports for all valid next-steps
+    for (size_t i = 0; i < _patt.str_pnt.size(); ++i) {
+        vector<bool> found(L * 2, false);
+
+        unsigned long long seq_id = _patt.seq_ID[i];
+        unsigned int j = _patt.str_pnt[i] + 1;
+
+        // 1) Same itemset (i-extension) forward until end-of-itemset (>0)
+        while (j < items[seq_id].size() && items[seq_id][j] > 0) {
+            int cur_itm = items[seq_id][j];
+            if (ilist[static_cast<size_t>(cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(j);
+                ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                found[static_cast<size_t>(cur_itm - 1)] = true;
+            }
+            ++j;
+        }
+
+        // 2) Later itemsets (s-extension), plus special re-open i-ext rule
+        int num_itmfnd = 0;
+        for (size_t k = j; k < items[seq_id].size(); ++k) {
+            int cur = items[seq_id][k];
+            int cur_itm = abs(cur);
+
+            if (cur < 0) num_itmfnd = 0; // new itemset boundary seen
+
+            // s-extension: add cur_itm as new itemset element
+            if (slist[static_cast<size_t>(cur_itm - 1)] &&
+                !found[static_cast<size_t>(L + cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].str_pnt.push_back(k);
+                ++pot_patt[static_cast<size_t>(L + cur_itm - 1)].freq;
+                found[static_cast<size_t>(L + cur_itm - 1)] = true;
+            }
+
+            // once we've seen the suffix of the last itemset fully,
+            // allow i-extension again (across future itemsets)
+            if (num_itmfnd == static_cast<int>(_patt.seq.size()) - last_neg) {
+                if (ilist[static_cast<size_t>(cur_itm - 1)] &&
+                    !found[static_cast<size_t>(cur_itm - 1)]) {
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(k);
+                    ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                    found[static_cast<size_t>(cur_itm - 1)] = true;
+                }
+            } else if (last_neg + num_itmfnd >= 0 &&
+                       cur_itm == abs(_patt.seq[static_cast<size_t>(last_neg + num_itmfnd)])) {
+                ++num_itmfnd;
+            }
+        }
+    }
+
+    // Filter children by support threshold
+    vector<int> ilistp;
+    vector<int> slistp;
+    ilistp.reserve(_patt.ilist.size());
+    slistp.reserve(_patt.slist.size());
+
+    for (int idx : _patt.ilist) {
+        if (pot_patt[static_cast<size_t>(idx)].freq >= theta)
+            ilistp.push_back(idx);
+    }
+    for (int idx : _patt.slist) {
+        if (pot_patt[static_cast<size_t>(idx + static_cast<int>(L))].freq >= theta)
+            slistp.push_back(idx);
+    }
+
+    // Push all i-extensions
+    for (int idx : ilistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx)]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(idx + 1);
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = ilistp;
+
+        // ALWAYS emit (so collected fills even if !b_disp && !b_write)
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+
+    // Push all s-extensions
+    for (int idx : slistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx + static_cast<int>(L))]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(-(idx + 1));  // negative encodes new itemset
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = slistp;             // as in original code
+
+        // ALWAYS emit
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Out_patt: append to buffer; optionally print/write                */
+/* ------------------------------------------------------------------ */
+static void Out_patt(vector<int>& seq, unsigned int freq)
+{
+    // Always append to in-memory results returned to Python
+    largepp::collected.push_back(seq);
+
+    ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    if (b_disp) {
+        for (int v : seq) cout << v << " ";
+        cout << "\n************** Freq: " << freq << endl;
+    }
+    if (b_write) {
+        for (int v : seq) file_o << v << " ";
+        file_o << "\n************** Freq: " << freq << "\n";
+        file_o.close();
+    }
+}
+
+} // namespace largepp

effspm/largepp/src/freq_miner.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+#include "pattern.hpp"   // defines largepp::Pattern
+#include "load_inst.hpp" // declares externs: items, L, theta, DFS, etc.
+#include "utility.hpp"   // flags, collected buffer, timers, helpers
+
+namespace largepp {
+
+// Public entry point
+void Freq_miner();
+
+// (defined in the .cpp)
+extern unsigned long long int num_patt;
+
+} // namespace largepp

effspm/largepp/src/load_inst.cpp

@@ -0,0 +1,238 @@
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#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.clear();
+        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";
+
+    // ───────────────────────────────────────────────────────────
+    // DEBUG snapshot of seeds right after loading
+    // ───────────────────────────────────────────────────────────
+    {
+        unsigned long long seeds_ge_theta = 0, seeds_nonzero = 0, max_freq = 0;
+        for (size_t i = 0; i < DFS.size(); ++i) {
+            if (DFS[i].freq > 0) ++seeds_nonzero;
+            if (DFS[i].freq >= theta) ++seeds_ge_theta;
+            if (DFS[i].freq > max_freq) max_freq = DFS[i].freq;
+        }
+       // std::cout << " theta=" << theta
+               //   << " | DFS.size=" << DFS.size()
+               //   << " | seeds>=theta=" << seeds_ge_theta
+              //    << " | seeds>0=" << seeds_nonzero
+              //    << " | max_seed_freq=" << max_freq << "\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, static_cast<unsigned int>(seq.size()));
+        E += seq.size();
+        for (int x : seq)
+            max_id = max(max_id, abs(x));
+    }
+    L = static_cast<unsigned int>(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 except minor safety
+ * ================================================================= */
+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, static_cast<unsigned int>(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, static_cast<unsigned int>(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 < static_cast<unsigned int>(abs(ditem))) {
+                L = static_cast<unsigned int>(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, static_cast<unsigned int>(size_m));
+    }
+    return true;
+}
+
+} // namespace largepp  // ─── END namespace ──────────────────────

effspm/largepp/src/load_inst.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <pybind11/pybind11.h>
+
+#include "largepp/src/pattern.hpp"   // ← ensure Pattern is a complete type here
+
+namespace largepp {
+using namespace std;
+
+// public entry points
+bool Load_instance(std::string& items_file, double thresh);
+void Load_py(const pybind11::object& py_data, double thresh);
+
+// shared state (defined in load_inst.cpp)
+extern std::vector<std::vector<int>> items;
+extern std::string                    out_file;
+
+extern bool b_disp, b_write, use_dic, just_build, ovr_count, pre_pro;
+extern bool use_list;
+
+extern unsigned int        M, L, time_limit;
+extern unsigned long long  N;
+extern double              theta;
+extern unsigned long long  E;
+extern std::clock_t        start_time;
+
+// DFS queue of potential patterns to extend
+extern std::vector<largepp::Pattern> DFS;
+
+} // namespace largepp

effspm/largepp/src/pattern.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <vector>
+
+namespace largepp {
+
+class Pattern {
+public:
+    std::vector<int> seq;
+    std::vector<unsigned int> str_pnt;
+    std::vector<unsigned long long> seq_ID;
+
+    std::vector<int> slist;
+    std::vector<int> ilist;
+
+    unsigned long long freq;
+
+    Pattern() : freq(0) {}
+
+    explicit Pattern(int item) : freq(0) {
+        seq.push_back(item);
+    }
+
+    Pattern(std::vector<int>& _seq, int item) : freq(0) {
+        seq.reserve(_seq.size() + 1);
+        for (int i = 0; i < static_cast<int>(_seq.size()); ++i)
+            seq.push_back(_seq[i]);
+        seq.push_back(item);
+    }
+};
+
+} // 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.hpp

@@ -1,25 +1,31 @@
+// effspm/load_inst.hpp
 #pragma once
 
-#include<vector>
-#include<string>
+#include <vector>
+#include <string>
 #include <fstream>
 #include <map>
- // Should work because "effspm" is in include_dirs
-
+#include <ctime>    // for clock_t
 
 using namespace std;
 
-bool Load_instance(string &items_file, double thresh);
-
-extern vector<vector<int>> items;
+// ------------------------------------------------------------
+// forward declare Pattern (defined in freq_miner.hpp)
+struct Pattern;
 
-extern string out_file;
 
-extern bool b_disp, b_write, use_dic, use_list, pre_pro;
+// Main entrypoint: load your file on disk into 'items', build DFS, theta, etc.
+bool Load_instance(string &items_file, double thresh);
 
-extern unsigned int M, L, time_limit;
+// 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 unsigned long long int N, theta;
+extern string              out_file;
+extern bool                b_disp, b_write, use_dic, use_list, pre_pro;
 
-extern clock_t start_time;
+extern unsigned int        M, L, time_limit;
+extern unsigned long long  N, E, theta; // E = total number of entries
 
+extern clock_t             start_time;