effspm 0.2.8__cp39-cp39-win_amd64.whl → 0.3.3__cp39-cp39-win_amd64.whl

effspm/largehm/src/build_mdd.cpp

@@ -1,173 +1,138 @@
-// ─── effspm/largehm/src/build_mdd.cpp ─────────────────────────────────────────
-
-#include "build_mdd.hpp"
-
-// ─── Definitions of the extern globals declared in build_mdd.hpp ─────────────
-std::vector<largehm::Arc>       largehm::Tree;
-std::vector<largehm::VArc>      largehm::VTree;
-std::vector<largehm::CArc>      largehm::CTree;
-
 #include <vector>
 #include <iostream>
-#include <cmath>           // for std::abs
 #include <unordered_map>
-#include <cstdint>         // for std::uint64_t
 #include "load_inst.hpp"
+#include "build_mdd.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
 
 namespace largehm {
 
-//
-// ─── Build the MDD by sequentially calling Add_arc() then possibly Add_vec() ──
-//
-void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
-    // SANITY CHECK: show sizes before building
-    
-    std::unordered_map<int, std::uint64_t> ancest_map;
-    std::uint64_t last_arc = 0;
-    int itmset = 0;
+using namespace std;
+
+int Add_arc(int item,
+            unsigned long long int last_arc,
+            int& itmset,
+            unordered_map<int, unsigned long long int>& ancest_map);
 
-    // Insert each prefix item as an arc
-    for (auto it = items.begin(); it != items.end(); ++it) {
+void Add_vec(vector<int>& items_lim,
+             unordered_map<int, unsigned long long int>& ancest_map,
+             unsigned long long int last_arc,
+             int itmset);
+
+vector<Arc>  Tree;
+vector<VArc> VTree;
+vector<CArc> CTree;
+
+void Build_MDD(vector<int>& items, vector<int>& items_lim) {
+
+    unordered_map<int, unsigned long long int> ancest_map;
+
+    unsigned long long int last_arc = 0;
+    int itmset = 0;
+    for (vector<int>::iterator it = items.begin(); it != items.end(); ++it)
         last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
-    }
 
-    // If there is a suffix beyond mlim, attach it via Add_vec()
-    if (!items_lim.empty()) {
+    if (!items_lim.empty())
         Add_vec(items_lim, ancest_map, last_arc, itmset);
-    }
 }
 
-
-//
-// ─── Add_arc: insert a single “item” into the MDD under parent last_arc. ──────
-//
 int Add_arc(int item,
-            std::uint64_t last_arc,
+            unsigned long long int last_arc,
             int& itmset,
-            std::unordered_map<int, std::uint64_t>& ancest_map)
-{
-    // Ensure DFS is at least size |item|
-    size_t needed = static_cast<size_t>(std::abs(item));
-    if (DFS.size() < needed) {
-        size_t old = DFS.size();
-        DFS.resize(needed);
-        for (size_t i = old; i < needed; ++i) {
-            DFS[i] = Pattern(-static_cast<int>(i) - 1);
-        }
-    }
+            unordered_map<int, unsigned long long int>& ancest_map) {
 
-    unsigned int anct = 0;
-    auto p = ancest_map.find(std::abs(item));
-    if (p != ancest_map.end()) {
+    unsigned int anct;
+    unordered_map<int, unsigned long long int>::iterator p = ancest_map.find(abs(item));
+    if (p == ancest_map.end())
+        anct = 0;
+    else
         anct = p->second;
-    }
 
-    if (item < 0) {
+    if (item < 0)
         ++itmset;
-    }
 
-    std::uint64_t last_sibl = Tree[last_arc].chld;
+    unsigned long long int last_sibl = Tree[last_arc].chld;
+
     if (last_sibl == 0) {
-        // No child yet: create a new Arc
         Tree.emplace_back(item, itmset, anct);
         last_sibl = Tree.size() - 1;
         Tree[last_arc].chld = last_sibl;
-        if (anct == 0) {
-            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-        }
+        if (anct == 0)
+            DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+
     }
     else {
-        // Traverse siblings until we find a match or append
         while (Tree[last_sibl].item != item) {
             if (Tree[last_sibl].sibl == 0) {
                 Tree.emplace_back(item, itmset, anct);
                 Tree[last_sibl].sibl = Tree.size() - 1;
                 last_sibl = Tree.size() - 1;
-                if (anct == 0) {
-                    DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-                }
+                if (anct == 0)
+                    DFS[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;
-    }
+    if (anct == 0)
+        ++DFS[abs(item) - 1].freq;
+
     ++Tree[last_sibl].freq;
-    ancest_map[std::abs(item)] = last_sibl;
-    return static_cast<int>(last_sibl);
-}
 
+    ancest_map[abs(item)] = last_sibl;
 
-//
-// ─── Add_vec: attach the “items_lim” vector as children/vertical arcs ─────────
-//
-void Add_vec(std::vector<int>& items_lim,
-             std::unordered_map<int, std::uint64_t>& ancest_map,
-             std::uint64_t last_arc,
-             int itmset)
-{
-    // Ensure VDFS and DFS are at least size L
-    if (VDFS.size() < static_cast<size_t>(L)) {
-        size_t old = VDFS.size();
-        VDFS.resize(static_cast<size_t>(L));
-        for (size_t i = old; i < VDFS.size(); ++i) {
-            VDFS[i] = VPattern(static_cast<int>(i));
-        }
-    }
-    if (DFS.size() < static_cast<size_t>(L)) {
-        size_t old = DFS.size();
-        DFS.resize(static_cast<size_t>(L));
-        for (size_t i = old; i < DFS.size(); ++i) {
-            DFS[i] = Pattern(-static_cast<int>(i) - 1);
-        }
-    }
+    return last_sibl;
+}
+
+void Add_vec(vector<int>& items_lim,
+             unordered_map<int, unsigned long long int>& ancest_map,
+             unsigned long long int last_arc,
+             int itmset) {
 
     items_lim.shrink_to_fit();
-    std::vector<bool> counted(L, false);
-
-    // If this node has positive itmset (>0) or no CTree child yet, create first child entry
-    if (Tree[last_arc].itmset > 0 || Tree[last_arc].chld == 0) {
-        std::vector<std::uint64_t> ancest(L + 1, 0ULL);
-        for (auto& kv : ancest_map) {
-            ancest[kv.first - 1] = kv.second;
-            counted[kv.first - 1] = true;
+    vector<bool> counted(L, 0);
+
+    if (Tree[last_arc].itmset > 0) {
+        vector<unsigned long long int> ancest(L + 1, 0); // last element is CArc child
+        for (unordered_map<int, unsigned long long int>::iterator p = ancest_map.begin();
+             p != ancest_map.end(); ++p) {
+            ancest[p->first - 1] = p->second;
+            counted[p->first - 1] = 1;
         }
-        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
-            int cur_itm = std::abs(items_lim[i]);
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
+            int cur_itm = abs(items_lim[i]);
             if (!counted[cur_itm - 1]) {
-                if (i + 1 < static_cast<int>(items_lim.size())) {
-                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1);
+                if (i + 1 < (int)items_lim.size()) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1); // negative = CTree
                     VDFS[cur_itm - 1].seq_ID.push_back(CTree.size());
                 }
                 ++DFS[cur_itm - 1].freq;
-                counted[cur_itm - 1] = true;
+                counted[cur_itm - 1] = 1;
             }
         }
         CTree.emplace_back(ancest, items_lim);
-        Tree[last_arc].chld  = CTree.size() - 1;
-        Tree[last_arc].itmset = -itmset;
+        Tree[last_arc].chld = CTree.size() - 1;
+        Tree[last_arc].itmset = -itmset; // negative itmset = connection to CTree
     }
     else {
-        // Normal “existing CTree child” path
-        auto& ancest = CTree[ Tree[last_arc].chld ].ancest;
-        for (int i = 0; i < static_cast<int>(items_lim.size()); ++i) {
-            int cur_itm = std::abs(items_lim[i]);
-            if (!counted[cur_itm - 1] && ancest[cur_itm - 1] == 0ULL) {
-                if (i + 1 < static_cast<int>(items_lim.size())) {
+        vector<unsigned long long int>& ancest = CTree[Tree[last_arc].chld].ancest;
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
+            int cur_itm = abs(items_lim[i]);
+            if (!counted[cur_itm - 1] && ancest[cur_itm - 1] == 0) {
+                if (i + 1 < (int)items_lim.size()) {
                     VDFS[cur_itm - 1].str_pnt.push_back(i + 1);
                     VDFS[cur_itm - 1].seq_ID.push_back(VTree.size());
                 }
                 ++DFS[cur_itm - 1].freq;
-                counted[cur_itm - 1] = true;
+                counted[cur_itm - 1] = 1;
             }
         }
-        VTree.emplace_back(items_lim, CTree[ Tree[last_arc].chld ].ancest.back());
-        CTree[ Tree[last_arc].chld ].ancest.back() = VTree.size();
+        VTree.emplace_back(items_lim,
+                           CTree[Tree[last_arc].chld].ancest.back());
+        // VTree siblings and CTree children are +1 of their actual position
+        CTree[Tree[last_arc].chld].ancest.back() = VTree.size();
     }
 }
 

effspm/largehm/src/build_mdd.hpp

@@ -1,93 +1,73 @@
-#ifndef LARGEHM_BUILD_MDD_HPP
-#define LARGEHM_BUILD_MDD_HPP
+#pragma once
 
 #include <vector>
-#include <unordered_map>
-#include <cstddef>          // for size_t
-#include <cstdint>          // for uint64_t
-
-#include "load_inst.hpp"    // defines L, DFS, VDFS, Tree, etc.
-#include "freq_miner.hpp"   // for Pattern, VPattern
-#include "utility.hpp"      // if you need check_parent or collected
+#include <cmath>
+#include "load_inst.hpp"
 
 namespace largehm {
 
-//
-// ─── Types & Globals ─────────────────────────────────────────────────────────
-//
-
-struct Arc;
-struct VArc;
-struct CArc;
-
-extern std::vector<Arc>       Tree;
-extern std::vector<VArc>      VTree;
-extern std::vector<CArc>      CTree;
-
-//
-// ─── Public API ───────────────────────────────────────────────────────────────
-//
-
-void Build_MDD(std::vector<int>& items,
-               std::vector<int>& items_lim);
-
-//
-// ─── Internal Helpers ─────────────────────────────────────────────────────────
-//
-
-int Add_arc(int item,
-            std::uint64_t last_arc,
-            int& itmset,
-            std::unordered_map<int, std::uint64_t>& ancest_map);
-
-void Add_vec(std::vector<int>& items_lim,
-             std::unordered_map<int, std::uint64_t>& ancest_map,
-             std::uint64_t last_arc,
-             int itmset);
-
-//
-// ─── Struct Definitions ───────────────────────────────────────────────────────
-//
-
-struct Arc {
-    int                item;
-    int                itmset;
-    std::uint64_t      anct;
-    std::uint64_t      chld;
-    std::uint64_t      sibl;
-    unsigned long long freq;
+using namespace std;
+
+void Build_MDD(vector<int>& items, vector<int>& items_lim);
+
+class Arc {
+public:
+    unsigned long long int chld;
+    unsigned long long int sibl;
+    unsigned long long int freq;
+    unsigned long long int anct;
+    int itmset;
+    int item;
+
+    Arc(unsigned int _itm, int _itmset, unsigned long long int _anc) {
+        chld  = 0;
+        sibl  = 0;
+        freq  = 0;
+        itmset = _itmset;
+        anct   = _anc;
+        item   = _itm;
+    }
 
-    Arc(int _item, int _itmset, std::uint64_t _anct)
-      : item(_item), itmset(_itmset), anct(_anct),
-        chld(0), sibl(0), freq(0u) {}
+    Arc() {
+        chld  = 0;
+        sibl  = 0;
+        freq  = 0;
+        anct  = 0;
+        itmset = 0;
+        item  = 0;
+    }
 };
 
-struct VArc {
-    std::vector<int>            seq;
-    std::uint64_t               sibl;
-    unsigned long long          freq;
+class VArc {
+public:
+    unsigned long long int sibl;
+    vector<int> seq;
 
-    explicit VArc(std::vector<int>& items, std::uint64_t _sibl)
-      : seq(), sibl(_sibl), freq(0u)
-    {
+    VArc(vector<int>& items, unsigned long long int _sib) {
+        sibl = _sib;
         seq.swap(items);
     }
+
+    VArc() {
+        sibl = 0;
+    }
 };
 
-struct CArc {
-    std::vector<std::uint64_t>  ancest;
-    std::vector<int>            seq;
-    unsigned long long          freq;
+class CArc {
+public:
+    vector<int> seq;
+    vector<unsigned long long int> ancest;
 
-    explicit CArc(std::vector<std::uint64_t>& _anc,
-                  std::vector<int>& items)
-      : ancest(), seq(), freq(0u)
-    {
+    CArc(vector<unsigned long long int>& _anc, vector<int>& items) {
         ancest.swap(_anc);
         seq.swap(items);
     }
+
+    CArc() = default;
 };
 
-} // namespace largehm
+extern vector<Arc>  Tree;
+extern vector<VArc> VTree;
+extern vector<CArc> CTree;
 
-#endif // LARGEHM_BUILD_MDD_HPP
+} // namespace largehm