void GLCM::calG(ItemSet is, const vector<BinaryMatrix *> & vBM, BinaryMatrix& res)
{
int isSize = is.size();
if (isSize == 0)
return;
res = *vBM[is.getItemAt(0)];
for (int i = 1; i < isSize; i++)
res &= *vBM[is.getItemAt(i)];
}
void GLCM::dumpItemset(std::ostream &os, ItemSet itemset, int freq){
//os << "[ ";
for (int i = 0 ; i < itemset.size() ; i++)
{
if ((itemset.getItemAt(i) % 2) == 0) os << itemset.getItemAt(i)/2 +1 << "+ ";
else os << itemset.getItemAt(i)/2 +1 << "- ";
}
//os << "] ";
os<<" ("<<freq<<")\n";
}
void GLCM::Print_An_Itemset(ItemSet IS)
{
list<ItemSet>::iterator it;
cout << " [";
for (int i = 0; i < IS.size(); i++)
{
if ((IS.getItemAt(i) % 2) == 0) cout << IS.getItemAt(i)/2 +1 << "+";
else cout << IS.getItemAt(i)/2 +1 << "-";
}
cout << "]" << endl;
}
void GLCM::Print_All_Closed_Pattern()
{
list<ItemSet>::iterator it;
cout << "Print all Closed Item set" << endl;
for (it = ClosedItemSetList.begin (); it != ClosedItemSetList.end (); it++)
{
ItemSet itSet = *it;
for (int i = 0 ; i < itSet.size() ; i++)
{
if ((itSet.getItemAt(i) % 2) == 0) cout << itSet.getItemAt(i)/2 +1 << "+ ";
else cout << itSet.getItemAt(i)/2 +1 << "- ";
}
cout << endl;
}
}
void ItemSetBuilder::build_successors(const ItemSet& set) {
// reset
for (auto& item : set.m_closure) item.complete = false;
for (auto& item : set.m_closure) {
if (item.complete) continue;
auto& production = m_grammar.get_production(item.production_id());
auto dot = item.dot();
// skip item whose dot is at right end
if (dot >= production.rhs_count()) {
item.complete = true;
continue;
}
auto& symbol = production[dot + 1]; // symbol after dot
// for each item which has 'symbol' after its dot
for (auto& item2 : set.m_closure) {
if (item2.complete) continue;
auto& production2 = m_grammar.get_production(item2.production_id());
auto dot2 = item2.dot();
if (dot2 >= production2.rhs_count()) {
// 'item2' has no successor
item2.complete = true;
continue;
}
auto& symbol2 = production2[dot2 + 1]; // symbol after dot
if (symbol == symbol2) {
// each item becomes complete after contibuting a successor
item2.complete = true;
auto& add = m_curr_item_set.add_kernel(production2, dot2 + 1);
add.lookaheads().resize(m_grammar.symbol_count());
// add backward propagation link
auto& new_node = new_link();
new_node->next = add.backward_plink();
add.backward_plink() = new_node;
new_node->item = &item2;
}
}
// build set from new kernels
auto& new_set = build_item_set();
if (symbol.type() == SymbolType::NONTERMINAL) {
auto& act = set.add_action(symbol, ActionType::GOTO, new_set.id());
}
else {
auto& act = set.add_action(symbol, ActionType::SHIFT, new_set.id());
assert(act.type != ActionType::SSCONFLICT);
}
}
}
const Item* Library::addBook(const string& title, const string& author, const int nPages)
{
Item * book = new Book(author, nPages, title);
BookList.insert(book);
MasterList.insert(book);
if (byAuthor.find(author) != byAuthor.end())
{
byAuthor[author].insert(book);
}
else{
ItemSet* temp = new ItemSet;
temp->insert(book);
byAuthor.insert(pair<string, ItemSet>(author, temp));
}
return book;
}
const Item* Library::addMusicAlbum(const string& title, const string& band, const int nSongs)
{
Item * album = new MusicAlbum(band, nSongs, title);
AlbumList.insert(album);
MasterList.insert(album);
if (byBand.find(band) != byBand.end())
{
byBand[band].insert(album);
}
else{
ItemSet* temp = new ItemSet;
temp->insert(album);
byBand.insert(pair<string, ItemSet*>(album, temp));
}
return album;
}
ItemSet
ReferenceSpatialCache::FindIntersectingItems(const BRect &rect) const
{
printf("ReferenceSpatialCache::FindIntersectingItems()");
bigtime_t startTime = system_time();
ItemSet res;
ItemSet::const_iterator it = fItems.begin();
for(; it != fItems.end(); it++) {
if ((*it)->Frame().Intersects(rect))
res.insert(*it);
}
bigtime_t time = system_time() - startTime;
printf(" %lluµs\n", time);
return res;
}
void GLCM::write_to_file(string freType)//const char * filename
{
TimeTracker tt2;
tt2.Start();
//print to file
string st = "OUT/out";
time_t tim=time(NULL);
tm *now=localtime(&tim);
stringstream ssm,ssd,ssh,ssmi,sss;//create a stringstream
ssm << now->tm_mon + 1;//add number to the stream
ssd << now->tm_mday;
ssh << now->tm_hour;
ssmi << now->tm_min;
sss << now->tm_sec;
st = st + ssm.str() + ssd.str() + ssh.str() + ssmi.str() + sss.str();
char * filename = (char*) st.c_str();
ofstream outf(filename);
outf << ClosedItemSetList.size() <<" closed gradual frequent Item sets" << endl;
list<ItemSet>::iterator it;
for (it = ClosedItemSetList.begin (); it != ClosedItemSetList.end (); it++)
{
outf << "[ ";
ItemSet itSet = *it;
for (int i = 0 ; i < itSet.size() ; i++)
{
if ((itSet.getItemAt(i) % 2) == 0) outf << itSet.getItemAt(i)/2 +1 << "+ ";
else outf << itSet.getItemAt(i)/2 +1 << "- ";
}
outf << "]" << endl;
}
outf.close();
cout << "All Item sets have been written to file: " << st << endl;
double ts2 = tt2.Stop();
cout << endl << "Writing took " << setw(5) << ts2 << " sec" << endl;
ostringstream ost1;
ost1 << getpid ();
string cmd1="ps -p "+ost1.str ()+" -o rss";
cout << "Memory usage at writing step: " << endl;
//system(cmd1.c_str());
cout << endl;
}
void GLCM::GLCMloop(ItemSet P, BinaryMatrix& res, vector< vector< pair<int,int> > > G1Item, const vector<BinaryMatrix *> & vBM, string freType, string so , std::ostream &output, int & resFre, bool printTSsFlag)
{
if ((P.size() != 0) && (resFre < _threshold))
{
return;
}
if (P.size() != 0)
{
if (resFre != G1Item[0].size()){
dumpItemset(output,P,resFre);
nbIS++;
if (printTSsFlag){
list<TransactionSequence> TSl;
TSl.clear();
TSl = buildTSList(res);
dumpTSs(output,TSl);
}
}
}
int k = 0;
int core_i = -1;
if (P.size() != 0) core_i = P.getCore_i();
if ((core_i % 2 != 0) || core_i == -1) k = core_i;
else k = core_i + 1;
BinaryMatrix calGBM(vBM[0]->getSize());
int G1ItemSize = G1Item.size();
for (int i = k + 1; i < G1ItemSize; i++)
{
ItemSet P1 = P.addItemwCore_i(i);
if (P != P1)
{
calGBM = (*vBM[i]);
if (res.getSize() != 0)
calGBM &= res;
int resourceFre = 0;
ItemSet Q = calF(&calGBM,G1Item,vBM,freType,resourceFre);
if (Q.size() != 0)
{
Q.setCore_i(P1.getCore_i());
if (Q.prefixEqual(P1))
{
GLCMloop(Q, calGBM, G1Item, vBM, freType, so, output, resourceFre, printTSsFlag);
}
}
}
}
}
void
CLxItemSelection::GetSet (
ItemSet &set)
{
CLxUser_Item item;
LXtScanInfoID scan;
void *pkt;
set.clear ();
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.GetItem (pkt, item);
if (Include (item))
set.insert (item);
}
}
const Item* Library::addMovie(const string& title, const string& director, const int nScenes)
{
Item * movie = new Movie(director, nScenes, title);
BookList.insert(movie);
MasterList.insert(movie);
if (byDirector.find(director) != byDirector.end())
{
byDirector[director].insert(movie);
}
else{
ItemSet* temp = new ItemSet;
temp->insert(movie);
byDirector.insert(pair<string, ItemSet*>(director, temp));
}
return movie;
}
int main(void) {
ItemSet a;
a.insert("A");
a.insert("B");
a.insert("C");
if(a.contains(string("B"))) {
cout << "contains B" << endl;
}
if(a.contains(string("D"))) {
cout << "contains D" << endl;
}
if(a.contains(string("A"))) {
cout << "contains A" << endl;
}
for(auto & i: a.subItemSets()) {
cout << "-> ";
for(auto &j: i->getItemSet()) {
cout << j.first << " ";
}
cout << endl;
delete(i);
}
}
bool ItemSet<T>::operator==(const ItemSet<T>& rhs) const {
if (rhs.getNumItems() != items_.size())
return false;
bool result = true;
for (size_t i = 0; ((result == true) && (i < items_.size())); ++i)
result = (items_[i] == rhs.items_[i]);
return result;
}
void Library::addBandMembers(const Item* const musicAlbum, const int nBandMembers, ...)
{
va_list members;
char *member;
set<string> itemsMembers = static_cast<const MusicAlbum*>(musicAlbum)->getMembers();
va_start(members, nBandMembers);
for (int i = 0; i < nBandMembers; i++) {
member = va_arg(members, char*);
itemsMembers.insert(member);
if (byMusician.find(member) != byMusician.end())
{
byMusician[member].insert(musicAlbum);
}
else{
ItemSet* temp = new ItemSet;
temp->insert(musicAlbum);
byMusician.insert(pair<string, ItemSet*>(member, temp));
}
}
va_end(members);
}
void Library::addCastMembers(const Item* const movie, const int nCastMembers, ...)
{
va_list members;
char *member;
set<string> itemsMembers = static_cast<const Movie*>(movie)->getCast();
va_start(members, nCastMembers);
for (int i = 0; i < nCastMembers; i++) {
member = va_arg(members, char*);
itemsMembers.insert(member);
if (byCastMember.find(member) != byCastMember.end())
{
byCastMember[member].insert(movie);
}
else{
ItemSet* temp = new ItemSet;
temp->insert(movie);
byCastMember.insert(pair<string, ItemSet*>(member, temp));
}
}
va_end(members);
}
bool ViewItemSet::checkItemSet(node nodeleaf,vector<node> &nodeitemset,vector<edge> &path,ItemSet& its){
Graph *graph=getGlMainWidget()->getGraph();
StringProperty *name =graph->getLocalProperty<StringProperty>("viewLabel");
string leaf=name->getNodeStringValue(nodeleaf);
Item *itemleaf=new Item(leaf);
node cursor=nodeleaf;
for(int j=its.numberOfItem()-1;j>-1;j--){
while(!graph->indeg(cursor)==0){
if((*its.getItem(j))>*itemleaf)
return false;
if(*(itemleaf)==(*(its.getItem(j)))){
nodeitemset.push_back(cursor);
cursor=graph->getInNode(cursor,1);
leaf=name->getNodeStringValue(cursor);
itemleaf->setName(leaf);
break;
}else{
cursor=graph->getInNode(cursor,1);
leaf=name->getNodeStringValue(cursor);
itemleaf->setName(leaf);
}
}
}
if(nodeitemset.size()>1)
{ cursor=nodeitemset[0];
while(cursor!=nodeitemset[nodeitemset.size()-1]){
path.push_back((graph->getInEdges(cursor))->next());
cursor=graph->getInNode(cursor,1);
}
}
if(nodeitemset.size()==its.numberOfItem())
return true;
else return false;
}
ItemSet Parse(std::istream& in)
{
ItemSet items;
std::string currentItem;
int openBraces = 0;
while (!in.eof() && !in.fail())
{
std::string currentLine;
std::getline(in, currentLine);
auto commentPos = currentLine.find('#');
if (commentPos != std::string::npos)
currentLine.erase(commentPos); // remove any comment
if (!currentItem.empty())
currentItem.push_back('\n'); // preserve new-lines within an item
currentItem += currentLine;
openBraces += std::count(currentLine.begin(), currentLine.end(), '{');
openBraces -= std::count(currentLine.begin(), currentLine.end(), '}');
if (openBraces <= 0)
{
auto lastCharPos = currentItem.find_last_not_of(" \t");
if (lastCharPos != std::string::npos && currentItem[lastCharPos] != '=')
{
auto parsedItem = ParseItem(currentItem);
if (parsedItem)
items.push_back(std::move(parsedItem));
currentItem.clear();
openBraces = 0;
}
}
}
return items;
}
inline int isContained_DBSizeEqual(struct PROJ_DB *pDB, TreeNode *currentLevel, TreeNode *candidate)
{
int myItem = pDB->Item;
bool myItemIsIntra = pDB->ItemIsIntra;
int dir;
bool isContained;
TreeNode *supNode;
TreeNode *subNode;
if ((myItem != candidate->Item) || (candidate->Items == (currentLevel->Items+1)))
return 0;
if ( candidate->Items > (currentLevel->Items + 1))
dir=1;
else
dir=-1;
if (candidate->ItemIsIntra) {
if (myItemIsIntra) {
candidate=candidate->Parent;
}
else {
//in this case, supNode must be candidate, subNode must be currentLevel
while (candidate->ItemIsIntra && candidate->Items >0)
candidate = candidate ->Parent;
candidate=candidate->Parent;
if ((candidate->Items < currentLevel->Items) || (candidate->ItemsetNumber < currentLevel->ItemsetNumber))
return 0;
}
}
else {
if (myItemIsIntra) {
//in this case, supNode must be currentLevel, subNode must be candidate
while (currentLevel->ItemIsIntra && currentLevel->Items >0)
currentLevel = currentLevel ->Parent;
currentLevel=currentLevel->Parent;
if ((candidate->Items > currentLevel->Items) || (candidate->ItemsetNumber > currentLevel->ItemsetNumber))
return 0;
}
else {
candidate=candidate->Parent;
}
}
if (currentLevel->Items == 0) {
return 1;
}
if (candidate->Items == 0) {
return -1;
}
if ( dir == 1) {
supNode=candidate;
subNode=currentLevel;
}
else {
supNode=currentLevel;
subNode=candidate;
}
isContained=false;
supNode=GetLastItemSet(supNode, &supSet);
subNode=GetLastItemSet(subNode, &subSet);
while (1) {
if (subSet.IsSubsetOf(&supSet)) {
if (subNode->Items == 0) {
isContained=true;
break;
}
if ((supNode->Items >= subNode->Items) && (supNode->ItemsetNumber >= subNode->ItemsetNumber)) {
supNode=GetLastItemSet(supNode, &supSet);
subNode=GetLastItemSet(subNode, &subSet);
}
else
break;
}
else {
if (supNode->Items == 0) // unnecessary to check any more.
break;
if ((supNode->Items >= subNode->Items) && (supNode->ItemsetNumber >= subNode->ItemsetNumber)) {
supNode=GetLastItemSet(supNode, &supSet);
}
else
break;
}
}
if (isContained)
return dir;
else
return 0;
}
void Yield::instantiate(ItemSet &contents) const {
for (auto entry : _entries) {
contents.set(entry.first, generateInitialQuantity(entry.second));
}
}
void ViewItemSet::reBuildTree(const ItemSet& it){
Graph *graph=getGlMainWidget()->getGraph();
vector<ItemSet> data;
DataSet dataset;
bool b=graph->getAttribute("datasetitem",dataset);
bool c=dataset.get("ItemSet",data);
graph->holdObservers();
graph->clear();
StringProperty *labelItemSet=graph->getLocalProperty<StringProperty>("viewLabel");
DoubleProperty *frequentItemSet=graph->getLocalProperty<DoubleProperty>("viewFrequent");
//ItemSet itemset;
node nodeNull=graph->addNode();
node curNode;
node pointerSon;
labelItemSet->setNodeValue(nodeNull,"NULL");
frequentItemSet->setNodeValue(nodeNull,0);
int x=data.size();
for(int i=0;i<x;i++){
ItemSet &itemset=data[i];
int size=itemset.numberOfItem();
double fr= atof(itemset.getItem(size-1)->getName().c_str());
itemset.removeItem(size);
if(size!=0){
curNode=nodeNull; //cursor node
for(int i=0;i<size-1;i++)
if(it.isExitItem(*itemset.getItem(i)))
itemset.getItem(i)->setPriority(true);
itemset.sortItems();
for(int i=0;i<size-1;i++)
{
pointerSon=isNodeSon(itemset.getItem(i)->getName(),curNode);
if(!pointerSon.isValid()){
node n= node();
n=graph->addNode();
labelItemSet->setNodeStringValue(n,itemset.getItem(i)->getName());
frequentItemSet->setNodeValue(n,fr);
edge e=graph->addEdge(curNode,n);
curNode=n;
}else{
curNode= pointerSon;
frequentItemSet->setNodeValue(curNode,frequentItemSet->getNodeValue(curNode)+fr);
}
}
}
itemset.clear();
}
string erreurMsg;
DataSet tmp;
LayoutProperty * layout = graph->getLocalProperty<LayoutProperty>("viewLayout"); // get the viewLayout property of your graph
StructDef structDef = LayoutProperty::factory->getPluginParameters("Hierarchical Tree (R-T Extended)");
structDef.buildDefaultDataSet(tmp,graph);
// tmp.set<float>("node size", nodeSize);
// tmp.set<float>("layer spacing", 200.);
// tmp.set<float>("node spacing", 20.);
//tmp.set("orthogonal", true);
StringCollection tmpS("vertical;horizontal;");
tmp.set("orientation", tmpS);
LayoutProperty tempLayout(graph);
tempLayout = *layout;
graph->computeProperty<LayoutProperty>("Hierarchical Tree (R-T Extended)", &tempLayout, //"Squarified Tree Map","Hierarchical Graph"
erreurMsg, 0, &tmp); // call to the plugin.
*layout = tempLayout;
graph->unholdObservers();
}
void GLCM::GLCMAlgo( DBMain * DB, float threshold, string freType,string so, std::ostream &output)
{
TimeTracker tt1;
tt1.Start();
nbIS = 0;
ItemSet P = ItemSet();
P.clear();
ClosedItemSetList.clear();
BinaryMatrixList.clear();
vector< vector< pair<int,int> > > G1Item = buildG_1item(DB);
cout << "There are " << G1Item[0].size() << " customers, and " << G1Item.size()/2 << " attributes." << endl << endl;
if ((freType == "nor") || (freType == "norwTSs"))
{
_threshold = (int) ceil(threshold * G1Item[0].size());
}
else if (freType == "gra")
{
_threshold = (int) ceil(((threshold * G1Item[0].size() * (G1Item[0].size() - 1)))/2);
}
vector<BinaryMatrix *> vBM = constructBinaryMatrixAll(G1Item);
BinaryMatrix BM = BinaryMatrix();
cout << "Begin GLCM" << endl;
int G1ItemSized2 = G1Item.size()/2;
for (int i = 0; i < G1ItemSized2; i++)
{
cout << "Item Sets start with: " << i + 1 << "+" << endl;
ItemSet P1 = P.addItemwCore_i(i*2);
BM = (*vBM[i*2]);
int resFre = 0;
int BMSize = BM.getSize();
BinaryMatrix * calFBM = new BinaryMatrix(BMSize);
calFBM->setContrastTo0(BM);
if (freType == "gra")
resFre = calFBM->getActive();
else {
vector<int> freMap;
freMap.clear();
for (int i = 0; i < BMSize; i++)
{
freMap.push_back(-1);
}
loop_Chk_Freq(calFBM,freMap);
resFre = frequentCount(freMap);
}
delete calFBM;
bool printTSsFlag = false;
if (freType == "norwTSs") printTSsFlag = true;
GLCMloop(P1, BM, G1Item, vBM, freType, so, output, resFre, printTSsFlag);
}
double ts1 = tt1.Stop();
cout << endl << "Execution took " << setw(5) << ts1 << " sec" << endl;
vector<BinaryMatrix*>::const_iterator posVBM ;
for (posVBM = vBM.begin() ; posVBM != vBM.end() ; ++posVBM)
delete *posVBM ;
vBM.clear() ;
ostringstream ost1;
ost1 << getpid ();
string cmd1="ps -p "+ost1.str ()+" -o rss";
cout << "Execution Memory usage : " << endl;
//system(cmd1.c_str());
cout << endl;
}
bool ItemSet::checkSubSet(ItemSet &it) {
for(int i=0; i<it.numberOfItem(); i++)
if(!this->isExitItem(*(it.getItem(i))))
return false;
return true;
}
