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

effspm/htminer/src/build_mdd.cpp

@@ -7,186 +7,108 @@
 
 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);
+using std::vector;
 
-// Global trees (unchanged)
-std::vector<Arc> Tree;
-std::vector<VArc> VTree;
-std::vector<CArc> CTree;
+int Add_arc(int item, unsigned int last_arc, int& itmset, vector<unsigned int>& ancest_map);
+void Add_vec(vector<int>& items_lim, vector<unsigned int>& ancest_map, unsigned int last_arc, int itmset);
 
-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;
+vector<Arc> Tree;
+vector<VArc> VTree;
+vector<CArc> CTree;
 
-    // // Prepare ancestor map of size L
-    std::vector<unsigned int> ancest_map(L, 0);    
+void Build_MDD(vector<int>& items, vector<int>& items_lim) {
+
+    vector<unsigned int> ancest_map(L, 0);
 
     unsigned 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);
 
-    // Iterate over 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);
-
-        // std::cerr << "[HTMiner::Build_MDD] returned from Add_arc, new last_arc=" 
-        //           << last_arc << "  itmset=" << itmset << std::endl;
-    }
-
-    // If there are limited items, handle them
-    if (!items_lim.empty()) {
-        // std::cerr << "[HTMiner::Build_MDD] items_lim is not empty; size=" 
-        //           << items_lim.size() << std::endl;
+    if (!items_lim.empty())
         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, 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);
+        last_sibl = (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) {
+                Tree[last_sibl].sibl = (unsigned int)Tree.size() - 1;
+                last_sibl = (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);
+    return (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::cerr << "[HTMiner::Add_vec] called with items_lim.size()=" << items_lim.size()
-    //           << "  last_arc=" << last_arc << "  itmset=" << itmset << std::endl;
+void Add_vec(vector<int>& items_lim, vector<unsigned int>& ancest, unsigned int last_arc, int itmset) {
 
-    std::vector<bool> counted(L, false);
+    items_lim.shrink_to_fit();
+    vector<bool> counted(L, 0);
 
     if (Tree[last_arc].itmset > 0) {
-        ancest.push_back(0);
+        ancest.push_back(0);  // last element of ancest is CArc child
         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) {
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
             int cur_itm = std::abs(items_lim[i]);
             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;
+                if (i + 1 < (int)items_lim.size()) {
+                    VDFS[cur_itm - 1].str_pnt.push_back(-i - 1);  // CTree positions: negative pointers
+                    VDFS[cur_itm - 1].seq_ID.push_back((unsigned int)CTree.size());
                 }
                 ++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;
+                counted[cur_itm - 1] = 1;
             }
         }
-
         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].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;
-    //
-     }
+        Tree[last_arc].chld = (unsigned int)CTree.size() - 1;
+        Tree[last_arc].itmset = -itmset;  // Tree→CTree edge is marked by negative itmset
+    }
     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) {
+        vector<unsigned int>& ancest_ref = CTree[Tree[last_arc].chld].ancest;
+        for (int i = 0; i < (int)items_lim.size(); ++i) {
             int cur_itm = std::abs(items_lim[i]);
-            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;
+            if (!counted[cur_itm - 1] && ancest_ref[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((unsigned int)VTree.size());
                 }
                 ++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;
+                counted[cur_itm - 1] = 1;
             }
         }
-
-        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;
+        VTree.emplace_back(items_lim, CTree[Tree[last_arc].chld].ancest.back());
+        CTree[Tree[last_arc].chld].ancest.back() = (unsigned int)VTree.size();
+        // VTree siblings and CTree children are +1 of actual index to mark end
     }
-
-    //std::cerr << "[HTMiner::Add_vec] exiting" << std::endl;
 }
 
-} // namespace htminer 
+} // namespace htminer

effspm/htminer/src/build_mdd.hpp

@@ -5,60 +5,67 @@
 #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;
+using std::vector;
 
-        Arc(unsigned int _itm, int _itmset, unsigned int _anc) {
-            chld = 0;    
-            sibl = 0;
-            freq = 0;
-            itmset = _itmset;
-            anct = _anc;
-            item = _itm;
-        }
+void Build_MDD(vector<int>& items, vector<int>& items_lim);
 
-        Arc() {
-            chld = 0;    
-            sibl = 0;
-            freq = 0;
-        }
-    };
+class Arc {
+public:
+    unsigned int chld;
+    unsigned int sibl;
+    unsigned int freq;
+    unsigned int anct;
+    int itmset;
+    int item;
 
-    class VArc {
-    public:
-        unsigned int sibl;    
-        std::vector<int> seq;
+    Arc(unsigned int _itm, int _itmset, unsigned int _anc) {
+        chld = 0;
+        sibl = 0;
+        freq = 0;
+        itmset = _itmset;
+        anct = _anc;
+        item = _itm;
+    }
 
-        VArc(std::vector<int>& items, unsigned int _sib) {
-            sibl = _sib;
-            seq.swap(items);
-        }
-        
-        VArc() {
-            sibl = 0;
-        }
-    };
+    Arc() {
+        chld = 0;
+        sibl = 0;
+        freq = 0;
+        itmset = 0;
+        anct = 0;
+        item = 0;
+    }
+};
 
-    class CArc {
-    public:
-        std::vector<int> seq;
-        std::vector<unsigned int> ancest;
+class VArc {
+public:
+    unsigned int sibl;
+    vector<int> seq;
 
-        CArc(std::vector<unsigned int>& _anc, std::vector<int>& items) {
-            ancest.swap(_anc);
-            seq.swap(items);
-        }
-    };
+    VArc(vector<int>& items, unsigned int _sib) {
+        sibl = _sib;
+        seq.swap(items);
+    }
 
-    extern std::vector<Arc> Tree;
-    extern std::vector<VArc> VTree;
-    extern std::vector<CArc> CTree;
-}
+    VArc() {
+        sibl = 0;
+    }
+};
+
+class CArc {
+public:
+    vector<int> seq;
+    vector<unsigned int> ancest;
+
+    CArc(vector<unsigned int>& _anc, vector<int>& items) {
+        ancest.swap(_anc);
+        seq.swap(items);
+    }
+};
+
+extern vector<Arc> Tree;
+extern vector<VArc> VTree;
+extern vector<CArc> CTree;
+
+} // namespace htminer