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

effspm/htminer/src/build_mdd.cpp

@@ -12,181 +12,128 @@ int Add_arc(int item, unsigned int last_arc, int& itmset, std::vector<unsigned i
 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<Arc>  Tree;
 std::vector<VArc> VTree;
 std::vector<CArc> CTree;
 
 void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
-    // DEBUG: entry into Build_MDD
-    // std::cerr << "[HTMiner::Build_MDD] called with items.size()=" << items.size()
-    //           << "  items_lim.size()=" << items_lim.size() << std::endl;
-
-    // // Prepare ancestor map of size L
-    std::vector<unsigned int> ancest_map(L, 0);    
+    // Prepare ancestor map of size L
+    std::vector<unsigned int> ancest_map(L, 0);
 
     unsigned int last_arc = 0;
-    int itmset = 0;
+    int          itmset   = 0;
 
-    // Iterate over items
+    // 1) normal items
     for (size_t idx = 0; idx < items.size(); ++idx) {
         int curr_item = items[idx];
-        // std::cerr << "[HTMiner::Build_MDD] processing items[" << idx 
-        //           << "]=" << curr_item << "  last_arc=" << last_arc 
-        //           << "  itmset=" << itmset << std::endl;
 
-        last_arc = Add_arc(curr_item, last_arc, itmset, ancest_map);
+        ++E;   // ✅ count this entry, just like in btminer
 
-        // std::cerr << "[HTMiner::Build_MDD] returned from Add_arc, new last_arc=" 
-        //           << last_arc << "  itmset=" << itmset << std::endl;
+        last_arc = Add_arc(curr_item, last_arc, itmset, ancest_map);
     }
 
-    // If there are limited items, handle them
+    // 2) tail / limited items
     if (!items_lim.empty()) {
-        // std::cerr << "[HTMiner::Build_MDD] items_lim is not empty; size=" 
-        //           << items_lim.size() << std::endl;
         Add_vec(items_lim, ancest_map, last_arc, itmset);
-        // std::cerr << "[HTMiner::Build_MDD] returned from Add_vec" << std::endl;
-    } else {
-        // std::cerr << "[HTMiner::Build_MDD] items_lim is empty; skipping Add_vec" << std::endl;
     }
-
-    // DEBUG: exit Build_MDD
-//     std::cerr << "[HTMiner::Build_MDD] exiting; Tree.size()=" << Tree.size() 
-//               << "  CTree.size()=" << CTree.size() 
-//               << "  VTree.size()=" << VTree.size() << std::endl;
-// 
 }
 
-int Add_arc(int item, unsigned int last_arc, int& itmset, std::vector<unsigned int>& ancest_map) {
+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) {
+    if (item < 0)
         ++itmset;
-        // std::cerr << "[HTMiner::Add_arc] negative item detected; itmset incremented to " 
-        //           << itmset << std::endl;
-    }
 
     unsigned int last_sibl = Tree[last_arc].chld;
-    // std::cerr << "[HTMiner::Add_arc] starting with last_sibl=" << last_sibl 
-    //           << "  anct=" << anct << std::endl;
 
     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;
-        // std::cerr << "[HTMiner::Add_arc] created new arc at index=" << last_sibl 
-        //           << "  setting Tree[" << last_arc << "].chld=" << last_sibl << std::endl;
-        if (anct == 0) {
+
+        if (anct == 0)
             DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-            // std::cerr << "[HTMiner::Add_arc] appended to DFS[" << (std::abs(item) - 1) 
-            //           << "].str_pnt -> " << last_sibl << std::endl;
-        }
     }
     else {
-        // std::cerr << "[HTMiner::Add_arc] traversing siblings starting at " << last_sibl << std::endl;
         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);
-                // std::cerr << "[HTMiner::Add_arc] created sibling arc at index=" << last_sibl 
-                //           << "  setting Tree[" << (last_sibl - 1) << "].sibl=" << last_sibl << std::endl;
-                if (anct == 0) {
+                last_sibl            = static_cast<unsigned int>(Tree.size() - 1);
+                if (anct == 0)
                     DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-                    // std::cerr << "[HTMiner::Add_arc] appended to DFS[" << (std::abs(item) - 1) 
-                    //           << "].str_pnt -> " << last_sibl << std::endl;
-                }
                 break;
             }
             last_sibl = Tree[last_sibl].sibl;
-            // std::cerr << "[HTMiner::Add_arc] moving to next sibling: " << last_sibl << std::endl;
         }
     }
 
-    if (anct == 0) {
+    if (anct == 0)
         ++DFS[std::abs(item) - 1].freq;
-        // std::cerr << "[HTMiner::Add_arc] incremented DFS[" << (std::abs(item) - 1) 
-        //           << "].freq -> " << DFS[std::abs(item) - 1].freq << std::endl;
-    }
 
     ++Tree[last_sibl].freq;
-    // std::cerr << "[HTMiner::Add_arc] incremented Tree[" << last_sibl << "].freq -> " 
-            //  << Tree[last_sibl].freq << std::endl;
 
     ancest_map[std::abs(item) - 1] = last_sibl;
-    // std::cerr << "[HTMiner::Add_arc] updated ancest_map[" << (std::abs(item) - 1) 
-    //           << "] -> " << last_sibl << std::endl;
 
     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) {
+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::cerr << "[HTMiner::Add_vec] called with items_lim.size()=" << items_lim.size()
-    //           << "  last_arc=" << last_arc << "  itmset=" << itmset << std::endl;
 
     std::vector<bool> counted(L, false);
 
     if (Tree[last_arc].itmset > 0) {
         ancest.push_back(0);
         ancest.shrink_to_fit();
-        // std::cerr << "[HTMiner::Add_vec] Tree[" << last_arc << "].itmset > 0; pushing 0 to ancest" << std::endl;
 
         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()));
-                    // std::cerr << "[HTMiner::Add_vec] appended negative str_pnt to VDFS[" 
-                    //           << (cur_itm - 1) << "] -> " << (-static_cast<int>(i) - 1) << std::endl;
                 }
                 ++DFS[cur_itm - 1].freq;
                 counted[cur_itm - 1] = true;
-                // std::cerr << "[HTMiner::Add_vec] incremented DFS[" << (cur_itm - 1) 
-                //           << "].freq -> " << DFS[cur_itm - 1].freq << std::endl;
             }
         }
 
         CTree.emplace_back(ancest, items_lim);
-        //std::cerr << "[HTMiner::Add_vec] added new CTree node; CTree.size()=" << CTree.size() << std::endl;
-
-        Tree[last_arc].chld = static_cast<unsigned int>(CTree.size() - 1);
+        Tree[last_arc].chld   = static_cast<unsigned int>(CTree.size() - 1);
         Tree[last_arc].itmset = -itmset;
-    //     std::cerr << "[HTMiner::Add_vec] updated Tree[" << last_arc 
-    //               << "].chld=" << Tree[last_arc].chld 
-    //               << "  Tree[" << last_arc << "].itmset=" << Tree[last_arc].itmset << std::endl;
-    //
-     }
+    }
     else {
         std::vector<unsigned int>& ancest_ct = CTree[Tree[last_arc].chld].ancest;
-        // std::cerr << "[HTMiner::Add_vec] Tree[" << last_arc << "].itmset <= 0; using existing CTree node " 
-        //           << Tree[last_arc].chld << std::endl;
 
         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()));
-                    // std::cerr << "[HTMiner::Add_vec] appended positive str_pnt to VDFS[" 
-                    //           << (cur_itm - 1) << "] -> " << (static_cast<unsigned int>(i) + 1) << std::endl;
                 }
                 ++DFS[cur_itm - 1].freq;
                 counted[cur_itm - 1] = true;
-                // std::cerr << "[HTMiner::Add_vec] incremented DFS[" << (cur_itm - 1) 
-                //           << "].freq -> " << DFS[cur_itm - 1].freq << std::endl;
             }
         }
 
         VTree.emplace_back(items_lim, ancest_ct.back());
-        // std::cerr << "[HTMiner::Add_vec] added new VTree node; VTree.size()=" << VTree.size() << std::endl;
-
         CTree[Tree[last_arc].chld].ancest.back() = static_cast<unsigned int>(VTree.size());
-        // std::cerr << "[HTMiner::Add_vec] updated CTree[" << Tree[last_arc].chld 
-        //           << "].ancest.back()=" << CTree[Tree[last_arc].chld].ancest.back() << std::endl;
     }
-
-    //std::cerr << "[HTMiner::Add_vec] exiting" << std::endl;
 }
 
-} // namespace htminer 
+} // namespace htminer

effspm/largebm/src/build_mdd.cpp

@@ -1,137 +1,96 @@
-// File: effspm/largebm/src/load_inst.cpp
-
-#include <vector>
-#include <iostream>
 #include <unordered_map>
-#include "load_inst.hpp"
+#include <cstdlib>
 #include "build_mdd.hpp"
 #include "freq_miner.hpp"
-#include "utility.hpp"
+#include "load_inst.hpp"
 
 namespace largebm {
 
-    // Forward declaration for Add_arc
-    int Add_arc(int item, unsigned long long int last_arc, int& itmset,
-                std::unordered_map<int, unsigned long long int>& ancest_map);
-
-    // Global MDD tree and other globals (declared in headers)
-    std::vector<Arc> Tree;
+std::vector<Arc> Tree;
 
-    void Build_MDD(std::vector<int>& items) {
-        std::unordered_map<int, unsigned long long int> ancest_map;
-        unsigned long long int last_arc = 0;
-        int itmset = 0;
+static int Add_arc(int item,
+                   unsigned long long last_arc,
+                   int& itmset,
+                   std::unordered_map<int, unsigned long long>& ancest_map);
 
-        for (auto it = items.begin(); it != items.end(); ++it) {
-            last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
-        }
+void Build_MDD(const std::vector<int>& items) {
+    std::unordered_map<int, unsigned long long> ancest_map;
+    unsigned long long last_arc = 0;
+    int itmset = 0;
+    for (int v : items) {
+        last_arc = Add_arc(v, last_arc, itmset, ancest_map);
     }
+}
 
+static int Add_arc(int item,
+                   unsigned long long last_arc,
+                   int& itmset,
+                   std::unordered_map<int, unsigned long long>& ancest_map) {
+    ++E;
 
-    int Add_arc(int item, unsigned long long int last_arc, int& itmset,
-                std::unordered_map<int, unsigned long long int>& ancest_map) {
-
-        unsigned idx = std::abs(item) - 1;
+    unsigned idx = static_cast<unsigned>(std::abs(item) - 1);
 
-        // ─── DEBUG ────────────────────────────────────────────────
-        // std::cout << "[Add_arc] item=" << item
-        //           << "  idx=" << idx
-        //           << "  last_arc=" << last_arc
-        //           << "  Tree.size=" << Tree.size()
-        //           << "  DFS.size="  << DFS.size()
-        //           << std::endl;
-
-        // Ensure DFS can hold this index
-        if (idx >= DFS.size()) {
-           // std::cout << "[Add_arc]  • resizing DFS to " << (idx + 1) << std::endl;
-            DFS.reserve(idx + 1);
-            while (DFS.size() <= idx) {
-                DFS.emplace_back(-static_cast<int>(DFS.size()) - 1); // Pattern(-id)
-            }
+    if (idx >= DFS.size()) {
+        DFS.reserve(idx + 1);
+        while (DFS.size() <= idx) {
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
         }
+    }
 
-        unsigned long long int anct;
-        auto p = ancest_map.find(std::abs(item));
-        if (p == ancest_map.end()) {
-            anct = 0;
-        } else {
-            anct = p->second;
-        }
+    unsigned long long anct = 0;
+    {
+        std::unordered_map<int, unsigned long long>::const_iterator p =
+            ancest_map.find(std::abs(item));
+        if (p != ancest_map.end()) anct = p->second;
+    }
 
-        if (item < 0) {
-            ++itmset;
-        }
+    if (item < 0) {
+        ++itmset;
+    }
 
-        // Before accessing Tree[last_arc].chld, check bounds
-        if (last_arc >= Tree.size()) {
-            // std::cout << "[Add_arc]  !!! last_arc OOB  last_arc="
-            //           << last_arc << "  Tree.size=" << Tree.size()
-            //           << std::endl;
-            // We still proceed so we can see crash context:
-        }
+    unsigned long long last_sibl = 0;
+    if (last_arc < Tree.size()) {
+        last_sibl = Tree[last_arc].chld;
+    }
 
-        unsigned long long int last_sibl = 0;
+    if (last_sibl == 0) {
+        Tree.emplace_back(item, itmset, anct);
+        last_sibl = Tree.size() - 1;
         if (last_arc < Tree.size()) {
-            last_sibl = Tree[last_arc].chld;
+            Tree[last_arc].chld = last_sibl;
         }
-
-        if (last_sibl == 0) {
-            // Insert new node as first child
-            Tree.emplace_back(item, itmset, anct);
-            last_sibl = Tree.size() - 1;
-
-            if (last_arc < Tree.size()) {
-                Tree[last_arc].chld = last_sibl;
-            }
-            if (anct == 0) {
-                // Debug before DFS access
-                // std::cout << "[Add_arc]  • DFS access at index=" << (std::abs(item) - 1)
-                //           << "  DFS.size=" << DFS.size() << std::endl;
-                DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+        if (anct == 0) {
+            DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
+        }
+    } else {
+        while (true) {
+            if (last_sibl >= Tree.size()) break;
+            if (Tree[last_sibl].item == item) {
+                break;
             }
-
-        } else {
-
-            // Walk siblings until find matching item or end
-            while (true) {
-                if (last_sibl >= Tree.size()) {
-                    // std::cout << "[Add_arc]  !!! last_sibl OOB  last_sibl="
-                    //           << last_sibl << "  Tree.size=" << Tree.size()
-                    //           << std::endl;
-                    break;
-                }
-                if (Tree[last_sibl].item == item) {
-                    break;
-                }
-                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) {
-                        // std::cout << "[Add_arc]  • DFS access at index=" << (std::abs(item) - 1)
-                        //           << "  DFS.size=" << DFS.size() << std::endl;
-                        DFS[std::abs(item) - 1].str_pnt.push_back(last_sibl);
-                    }
-                    break;
+            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);
                 }
-                last_sibl = Tree[last_sibl].sibl;
+                break;
             }
+            last_sibl = Tree[last_sibl].sibl;
         }
+    }
 
-        if (anct == 0) {
-            // std::cout << "[Add_arc]  • increment DFS.freq at index=" << (std::abs(item) - 1)
-            //           << "  DFS.size=" << DFS.size() << std::endl;
-            DFS[std::abs(item) - 1].freq++;
-        }
-
-        if (last_sibl < Tree.size()) {
-            // std::cout << "[Add_arc]  • increment Tree.freq at node=" << last_sibl
-            //           << "  Tree.size=" << Tree.size() << std::endl;
-            Tree[last_sibl].freq++;
-        }
+    if (anct == 0) {
+        DFS[std::abs(item) - 1].freq++;
+    }
 
-        ancest_map[std::abs(item)] = last_sibl;
-        return last_sibl;
+    if (last_sibl < Tree.size()) {
+        Tree[last_sibl].freq++;
     }
 
-}  // namespace largebm
+    ancest_map[std::abs(item)] = last_sibl;
+    return static_cast<int>(last_sibl);
+}
+
+} // namespace largebm

effspm/largebm/src/build_mdd.hpp

@@ -1,47 +1,32 @@
 #pragma once
-
-#include<vector>
-#include <cmath>
-#include "load_inst.hpp"
+#include <vector>
+#include <cstdint>
 
 namespace largebm {
-void Build_MDD(std::vector<int>& items);
 
 class Arc {
 public:
+    unsigned long long chld = 0;
+    unsigned long long sibl = 0;
+    unsigned long long freq = 0;
+    unsigned long long anct = 0;
+    int itmset = 0;
+    int item = 0;
+
+    Arc() = default;
+    Arc(int _itm, int _itmset, unsigned long long _anc)
+        : chld(0), sibl(0), freq(0), anct(_anc), itmset(_itmset), item(_itm) {}
+    Arc(int _itm, unsigned long long _anc)
+        : chld(0), sibl(0), freq(0), anct(_anc), item(_itm) {}
+};
 
-	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(int _itm, int _itmset, unsigned long long int _anc) {
-		itmset = _itmset;
-		anct = _anc;
-		item = _itm;
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
-
-	Arc(int _itm, int _anc) {
-		item = _itm;
-		anct = _anc;
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
-
-	Arc() {
-		freq = 0;
-		chld = 0;
-		sibl = 0;
-	}
+// Single global MDD, defined in build_mdd.cpp
+extern std::vector<Arc> Tree;
 
+// [2025-10-25 NEW]: const-correct signature used everywhere
+void Build_MDD(const std::vector<int>& items);
 
-};
+// [2025-10-25 NEW]: debug helper to read how many anct==0 ticks we did
+unsigned long long _effspm_dbg_anct0_ticks();
 
-extern std::vector<Arc> Tree;
-}
+} // namespace largebm