effspm 0.1.7__cp312-cp312-macosx_11_0_arm64.whl → 0.2.7__cp312-cp312-macosx_11_0_arm64.whl

effspm/htminer/src/build_mdd.cpp

@@ -0,0 +1,192 @@
+#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) {
+    // 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);    
+
+    unsigned int last_arc = 0;
+    int itmset = 0;
+
+    // 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;
+        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) {
+    unsigned int anct = ancest_map[std::abs(item) - 1];
+    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) {
+            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) {
+                    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) {
+        ++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) {
+    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]);
+            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].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]);
+            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 

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;
+}

effspm/htminer/src/freq_miner.cpp

@@ -0,0 +1,350 @@
+#include <iostream>
+#include <time.h>
+#include "freq_miner.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+
+namespace htminer {
+void Out_patt(vector<int>& seq, unsigned int freq);
+void Extend_patt(Pattern& _patt);
+void Mine_vec(unsigned int seq_ID, int pos, int num_found, vector<unsigned int>& ancest, vector<int>& items, unsigned int inod, int sgn);
+
+unsigned long long int num_patt = 0;
+
+vector<bool> ilist;
+vector<bool> slist;
+
+vector<Pattern> pot_patt;
+vector<VPattern> pot_vpatt;
+vector<unsigned int> last_strpnt;
+vector<unsigned int> ancest_base;
+vector<int> DFS_numfound;
+
+Pattern _patt;
+VPattern _vpatt;
+
+int itmset_size;
+int last_neg;
+
+bool ilist_nempty;
+
+void Freq_miner() {
+    collectedPatterns.clear();    
+	vector<int> list;
+
+	for (int i = 0; i < L; ++i) {
+		if (DFS[i].freq >= theta) {
+			list.push_back(-i-1);
+			if (itmset_exists)
+				list.push_back(i+1);
+		}
+	}
+
+	for (int i = 0; i < DFS.size(); ++i) 
+		DFS[i].list = list;
+			
+	while (!DFS.empty() && give_time(clock() - start_time) < time_limit) {
+		if (DFS.back().freq >= theta)
+			Extend_patt(DFS.back());
+		else {
+			DFS.pop_back();
+			if (!VDFS.empty() && VDFS.back().ass_patt == DFS.size())
+				VDFS.pop_back();
+		}
+	}
+}
+
+void Extend_patt(Pattern& _pattern) {
+
+	swap(_patt, _pattern);
+	DFS.pop_back();
+
+	slist = vector<bool>(L, 0);
+	ilist_nempty = 0;
+
+	if (itmset_exists) {
+		ilist = vector<bool>(L, 0);
+		for (vector<int>::iterator it = _patt.list.begin(); it != _patt.list.end(); ++it) {
+			if (*it < 0)
+				slist[-(*it) - 1] = 1;
+			else {
+				ilist[(*it) - 1] = 1;
+				ilist_nempty = 1;
+			}
+		}
+	}
+	else {
+		for (vector<int>::iterator it = _patt.list.begin(); it != _patt.list.end(); ++it)
+			slist[-(*it) - 1] = 1;
+	}
+	
+	last_neg = _patt.seq.size() - 1;
+	while (_patt.seq[last_neg] > 0) 
+		--last_neg;
+	itmset_size = _patt.seq.size() - last_neg;
+	
+	pot_patt = vector<Pattern>(L + L * ilist_nempty);
+	if (!CTree.empty()) 
+		pot_vpatt = vector<VPattern>(L + L * ilist_nempty);
+
+	last_strpnt = vector<unsigned int>(L, 0);
+
+	if (!VDFS.empty() && VDFS.back().ass_patt == DFS.size()) {
+		swap(_vpatt, VDFS.back());
+		VDFS.pop_back();
+		for (unsigned int pnt = 0; pnt < _vpatt.str_pnt.size(); ++pnt) {
+			if (_vpatt.str_pnt[pnt] < 0)
+				Mine_vec(_vpatt.seq_ID[pnt], -_vpatt.str_pnt[pnt], -1, ancest_base, CTree[_vpatt.seq_ID[pnt]].seq, 0, -1);	//starting search from vpatt should start from 1 position ahead of pointer
+			else															//-1:no need to check ancest for remaining itemset items
+				Mine_vec(_vpatt.seq_ID[pnt], _vpatt.str_pnt[pnt], -1, ancest_base, VTree[_vpatt.seq_ID[pnt]].seq, 0, 1);
+		}
+	} 
+
+	vector<unsigned int> DFS_itm;			//for initial itemset extention
+	vector<unsigned int> DFS_seq;			//for initial itemset extention
+	if (ilist_nempty)
+		DFS_numfound.clear();			//tracks whether the current itemset is found anywhere along the search path, by counting how many of the current items in the itemset are found
+	for (unsigned int pnt = 0; pnt < _patt.str_pnt.size(); ++pnt) {
+		DFS_itm.push_back(_patt.str_pnt[pnt]);
+		while(!DFS_itm.empty()) { 
+			unsigned int cur_sibl = DFS_itm.back();
+			DFS_itm.pop_back();
+			if (Tree[cur_sibl].itmset < 0) {
+				unsigned int carc = Tree[cur_sibl].chld;
+				Mine_vec(carc, 0, -1, CTree[carc].ancest, CTree[carc].seq, _patt.str_pnt[pnt], -1);
+				cur_sibl = CTree[carc].ancest.back();
+				while (cur_sibl != 0) {
+					Mine_vec(cur_sibl - 1, 0, -1, CTree[carc].ancest, VTree[cur_sibl - 1].seq, _patt.str_pnt[pnt], 1);
+					cur_sibl = VTree[cur_sibl - 1].sibl;
+				}
+				continue;
+			}
+			cur_sibl = Tree[cur_sibl].chld;
+			while (cur_sibl != 0) {
+				int cur_itm = Tree[cur_sibl].item;
+				if (cur_itm < 0) {
+					cur_itm = -cur_itm;
+					if (slist[cur_itm - 1]) {
+						pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+						if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+							pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);	
+					}
+					if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0) {
+						DFS_seq.push_back(cur_sibl);
+						if (ilist_nempty) {
+							if (cur_itm == -_patt.seq[last_neg])
+								DFS_numfound.push_back(1);
+							else
+								DFS_numfound.push_back(0);
+						}
+					}
+				}
+				else {
+					if (ilist[cur_itm - 1]) {
+						pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+						if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+							pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+					}
+					if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+						DFS_itm.push_back(cur_sibl);
+				}
+				cur_sibl = Tree[cur_sibl].sibl;
+			}
+		}
+		if (ilist_nempty) {
+			for (int i = 0; i < L; ++i) {
+				if (ilist[i])
+					last_strpnt[i] = pot_patt[i + L].str_pnt.size();
+			}
+		}
+		while(!DFS_seq.empty()) {
+			unsigned int cur_sibl = DFS_seq.back();
+			DFS_seq.pop_back();
+			int num_found = 0;
+			if (ilist_nempty) {
+				num_found = DFS_numfound.back();
+				DFS_numfound.pop_back();
+			}
+			if (Tree[cur_sibl].itmset < 0) {
+				unsigned int carc = Tree[cur_sibl].chld;
+				Mine_vec(carc, 0, num_found, CTree[carc].ancest, CTree[carc].seq, _patt.str_pnt[pnt], -1);
+				cur_sibl = CTree[carc].ancest.back();
+				while (cur_sibl != 0) {
+					Mine_vec(cur_sibl - 1, 0, num_found, CTree[carc].ancest, VTree[cur_sibl - 1].seq, _patt.str_pnt[pnt], 1);
+					cur_sibl = VTree[cur_sibl - 1].sibl;
+				}
+				continue;
+			}
+			cur_sibl = Tree[cur_sibl].chld;
+			while (cur_sibl != 0) {
+				int cur_itm = Tree[cur_sibl].item;
+				if (cur_itm > 0) {
+					if (num_found == itmset_size && ilist[cur_itm - 1] && (abs(Tree[Tree[cur_sibl].anct].itmset) < abs(Tree[_patt.str_pnt[pnt]].itmset) || !check_parent(Tree[cur_sibl].anct, _patt.str_pnt[pnt], last_strpnt[cur_itm - 1], pot_patt[cur_itm + L - 1].str_pnt))) {
+						pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+						if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+							pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+					}
+					if (slist[cur_itm - 1] && abs(Tree[Tree[cur_sibl].anct].itmset) <= abs(Tree[_patt.str_pnt[pnt]].itmset)) {
+						pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+						if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+							pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+					}
+					if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0) {
+						DFS_seq.push_back(cur_sibl);
+						if (ilist_nempty) {
+							if (num_found < itmset_size && cur_itm == abs(_patt.seq[last_neg + num_found])) 
+								DFS_numfound.push_back(num_found + 1);
+							else
+								DFS_numfound.push_back(num_found);
+						}
+					}
+				}
+				else {
+					cur_itm = -cur_itm;
+					if (slist[cur_itm - 1] && abs(Tree[Tree[cur_sibl].anct].itmset) <= abs(Tree[_patt.str_pnt[pnt]].itmset)) {
+						pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+						if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0)
+							pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+					}
+					if (Tree[cur_sibl].chld != 0 || Tree[cur_sibl].itmset < 0) {
+						DFS_seq.push_back(cur_sibl);
+						if (ilist_nempty) {
+							if (cur_itm == -_patt.seq[last_neg])
+								DFS_numfound.push_back(1);
+							else
+								DFS_numfound.push_back(0);
+						}
+					}
+				}
+				cur_sibl = Tree[cur_sibl].sibl;
+			}
+		}
+	}
+
+	vector<int> ilistp;
+	vector<int> slistp;
+	for (vector<int>::iterator it = _patt.list.begin(); it != _patt.list.end(); ++it) {
+		if (*it > 0 && pot_patt[(*it) + L - 1].freq >= theta) 
+			ilistp.push_back(*it);
+		else if (*it < 0 && pot_patt[-(*it) - 1].freq >= theta) {
+			if (itmset_exists) 
+				slistp.push_back(-(*it));
+			ilistp.push_back(*it);
+			slistp.push_back(*it);
+		}
+	} 
+
+	for (vector<int>::iterator it = ilistp.begin(); it != ilistp.end(); ++it) {
+		int p;
+		if (*it < 0) 
+			p = -(*it) - 1;
+		else
+			p = (*it) - 1 + L;
+		DFS.emplace_back();
+		swap(DFS.back(), pot_patt[p]);
+		DFS.back().seq = _patt.seq;
+		DFS.back().seq.push_back(*it);
+		if (*it < 0)
+			DFS.back().list = slistp;
+		else
+			DFS.back().list = ilistp;
+		if (!CTree.empty() && !pot_vpatt[p].str_pnt.empty()) {
+			pot_vpatt[p].ass_patt = DFS.size() - 1;
+			VDFS.emplace_back();
+			swap(VDFS.back(), pot_vpatt[p]);
+		}
+		if (b_disp || b_write) 
+			Out_patt(DFS.back().seq, DFS.back().freq);
+		 htminer::collectedPatterns.emplace_back(DFS.back().seq);  
+		++num_patt;
+		
+	}
+}
+
+
+void Mine_vec(unsigned int seq_ID, int pos, int num_found, vector<unsigned int>& ancest, vector<int>& items, unsigned int pnt, int sgn) {
+	
+	vector<bool> found(L + L * ilist_nempty, 0);
+	int num_ext = 0;
+
+	if (num_found == -1) {
+		while (pos < items.size() && items[pos] > 0 && num_ext < _patt.list.size()) {
+			int cur_itm = items[pos];
+			if (ilist[cur_itm - 1] && !found[cur_itm + L - 1]) {
+				if (pos + 1 < items.size()) {
+					pot_vpatt[cur_itm + L - 1].seq_ID.push_back(seq_ID);
+					pot_vpatt[cur_itm + L - 1].str_pnt.push_back(sgn * (pos + 1));
+				}
+				++pot_patt[cur_itm + L - 1].freq;
+				found[cur_itm + L - 1] = 1;
+				++num_ext;						
+			}
+			++pos;
+		}
+	}
+
+	for (unsigned int k = pos; k < items.size() && num_ext < _patt.list.size(); ++k) {
+		int cur_itm = abs(items[k]);
+		if (items[k] < 0) 
+			num_found = 0;
+		if (slist[cur_itm - 1] && !found[cur_itm - 1]) {
+			if (ancest.empty() || abs(Tree[ancest[cur_itm - 1]].itmset) <= abs(Tree[pnt].itmset)) {
+				if (k + 1 < items.size()) {
+					pot_vpatt[cur_itm - 1].seq_ID.push_back(seq_ID);
+					pot_vpatt[cur_itm - 1].str_pnt.push_back(sgn * (k + 1));
+				}
+				++pot_patt[cur_itm - 1].freq;
+			}
+			found[cur_itm - 1] = 1;
+			++num_ext;
+		}
+		if (num_found == itmset_size) {
+			if (ilist[cur_itm - 1] && !found[cur_itm + L - 1]) {
+				if (ancest.empty() || abs(Tree[ancest[cur_itm - 1]].itmset) < abs(Tree[pnt].itmset) || !check_parent(ancest[cur_itm - 1], pnt, last_strpnt[cur_itm - 1], pot_patt[cur_itm + L - 1].str_pnt)) {
+					if (k + 1 < items.size()) {
+						pot_vpatt[cur_itm + L - 1].seq_ID.push_back(seq_ID);
+						pot_vpatt[cur_itm + L - 1].str_pnt.push_back(sgn * (k + 1));
+					}
+					++pot_patt[cur_itm + L - 1].freq;
+				}
+				found[cur_itm + L - 1] = 1;
+				++num_ext;
+			}
+		}
+		else if (cur_itm == abs(_patt.seq[last_neg + num_found])) 
+			++num_found;
+	}
+}
+
+
+void Out_patt(vector<int>& seq, unsigned int freq) {
+
+	ofstream file_o;
+	if (b_write) 
+		file_o.open(out_file, std::ios::app);
+
+	for (int ii = 0; ii < seq.size(); ii++) {
+		if (b_disp)
+			cout << seq[ii] << " ";
+		if (b_write) 
+			file_o << seq[ii] << " ";
+	}
+	if (b_disp)
+		cout << endl;
+	if (b_write) 
+		file_o << endl;
+	
+	if (b_disp)
+		cout << "************** Freq: " << freq << endl;
+	if (b_write) {
+		file_o << "************** Freq: " << freq << endl;
+		file_o.close();
+	}
+	
+}
+  
+
+}
+
+
+

effspm/htminer/src/freq_miner.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+
+namespace htminer {
+void Freq_miner();
+
+class Pattern {
+public:
+
+	vector<int> seq;
+	vector<unsigned int> str_pnt;
+	vector<int> list;
+
+	unsigned long long int freq;
+
+	Pattern(int item) {
+		seq.push_back(item);
+		freq = 0;
+	}
+
+	Pattern(size_t _pnt, bool _res) {
+		str_pnt.reserve(_pnt);
+		freq = 0;
+	}
+
+	Pattern() {
+		freq = 0;
+	}
+
+
+};
+
+class VPattern {
+public:
+
+	unsigned long long int ass_patt;
+	
+	vector<int> str_pnt;
+	vector<unsigned int> seq_ID;
+
+	VPattern(unsigned long long int _patt) {
+		ass_patt = _patt;
+	}
+
+	VPattern(size_t _pnt, bool a) {
+		str_pnt.reserve(_pnt);
+	}
+
+	VPattern() {}
+};
+
+
+extern unsigned long long int num_patt;
+extern vector<Pattern> DFS;
+extern vector<VPattern> VDFS;
+
+}
+