void Run(UI* ui)
{ if(ui == NULL) return;
NewGame(ui->game);
NextTurn(ui->game);
int c, running = 1;
while(running && ui->game->status != GAME_STATUS_ERROR)
{ DisplayGame(ui);
c = getch();
switch(c)
{
case KEY_LEFT:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushLeft(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_RIGHT:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushRight(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_UP:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushUp(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_DOWN:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushDown(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case 'q':
running = 0;
break;
case 'n':
NewGame(ui->game);
NextTurn(ui->game);
break;
case 'r':
StartGame(ui->game);
NextTurn(ui->game);
break;
default:
break;
}
}
}
//-----------------------------------------------------------------------------------
//mining frequent itemsets from a conditional database represented by an AFOPT-tree
//------------------------------------------------------------------------------------
void CAFOPTMine::DepthAFOPTGrowth(HEADER_TABLE pheader_table, int num_of_freqitems, int nstart_pos)
{
int i;
AFOPT_NODE *pcurroot;
ITEM_COUNTER* pnewfreqitems;
int *pitem_suporder_map;
int num_of_newfreqitems;
HEADER_TABLE pnewheader_table;
int k, nend_pos;
ARRAY_NODE *pitem_list;
clock_t start;
gntotal_call++;
pnewfreqitems = new ITEM_COUNTER[num_of_freqitems];
//goMemTracer.IncBuffer(num_of_freqitems*sizeof(ITEM_COUNTER));
pitem_suporder_map = new int[num_of_freqitems];
//goMemTracer.IncBuffer(num_of_freqitems*sizeof(int));
if(gnmax_trans_len<gndepth+1)
gnmax_trans_len = gndepth+1;
nend_pos = num_of_freqitems-MAX_BUCKET_SIZE;
for(k=nstart_pos;k<nend_pos;k++)
{
OutputOnePattern(pheader_table[k].item, pheader_table[k].nsupport);
pcurroot = pheader_table[k].pafopt_conddb;
if(pcurroot==NULL)
continue;
gpheader_itemset[gndepth] = pheader_table[k].item;
gndepth++;
//if the tree contains only one single branch, then directly enumerate all frequent itemsets from the tree
if(pcurroot->flag>0)
{
pitem_list = pcurroot->pitemlist;
for(i=0;i<pcurroot->flag && pitem_list[i].support>=gnmin_sup;i++)
{
pnewfreqitems[i].item = pheader_table[pitem_list[i].order].item;
pnewfreqitems[i].support = pitem_list[i].support;
}
OutputSinglePath(pnewfreqitems, i);
if(pcurroot->flag>1 && pitem_list[0].order<nend_pos)
{
InsertTransaction(pheader_table, pitem_list[0].order, &(pitem_list[1]), pcurroot->flag-1);
}
delete []pitem_list;
//goMemTracer.DelSingleBranch(pcurroot->flag);
delete pcurroot;
//goMemTracer.DelOneAFOPTNode();
pheader_table[k].pafopt_conddb = NULL;
}
else if(pcurroot->flag==0)
{
//count frequent items from AFOPT-tree
for(i=k+1;i<num_of_freqitems;i++)
pitem_suporder_map[i] = 0;
start = clock();
CountFreqItems(pcurroot, pitem_suporder_map);
//goTimeTracer.mdAFOPT_count_time += (double)(clock()-start)/CLOCKS_PER_SEC;
num_of_newfreqitems = 0;
for(i=k+1;i<num_of_freqitems;i++)
{
if(pitem_suporder_map[i]>=gnmin_sup)
{
pnewfreqitems[num_of_newfreqitems].item = pheader_table[i].item;
pnewfreqitems[num_of_newfreqitems].support = pitem_suporder_map[i];
pnewfreqitems[num_of_newfreqitems].order = i;
num_of_newfreqitems++;
}
pitem_suporder_map[i] = -1;
}
if(num_of_newfreqitems>0)
{
qsort(pnewfreqitems, num_of_newfreqitems, sizeof(ITEM_COUNTER), comp_item_freq_asc);
for(i=0;i<num_of_newfreqitems;i++)
pitem_suporder_map[pnewfreqitems[i].order] = i;
}
if(num_of_newfreqitems==1)
{
if(gnmax_trans_len<gndepth+1)
gnmax_trans_len = gndepth+1;
OutputOnePattern(pnewfreqitems[0].item, pnewfreqitems[0].support);
}
else if(num_of_newfreqitems>1)
{
if(num_of_newfreqitems<=MAX_BUCKET_SIZE)
{
start = clock();
memset(gpbuckets, 0, sizeof(int)*(1<<num_of_newfreqitems));
BucketCountAFOPT(pcurroot, pitem_suporder_map, gpbuckets);
bucket_count(gpbuckets, num_of_newfreqitems, pnewfreqitems);
//goTimeTracer.mdBucket_count_time += (double)(clock()-start)/CLOCKS_PER_SEC;
}
else
{
start = clock();
pnewheader_table = new HEADER_NODE[num_of_newfreqitems];
//goMemTracer.IncBuffer(sizeof(HEADER_NODE)*num_of_newfreqitems);
for(i=0;i<num_of_newfreqitems;i++)
{
pnewheader_table[i].item = pnewfreqitems[i].item;
pnewheader_table[i].nsupport = pnewfreqitems[i].support;
pnewheader_table[i].pafopt_conddb = NULL;
pnewheader_table[i].order = i;
pnewheader_table[i].flag = AFOPT_FLAG;
}
memset(gpbuckets, 0, sizeof(int)*(1<<MAX_BUCKET_SIZE));
BuildNewTree(pcurroot, pnewheader_table, pitem_suporder_map, num_of_newfreqitems, gpbuckets);
//goTimeTracer.mdAFOPT_construct_time += (double)(clock()-start)/CLOCKS_PER_SEC;
bucket_count(gpbuckets, MAX_BUCKET_SIZE, &(pnewfreqitems[num_of_newfreqitems-MAX_BUCKET_SIZE]));
DepthAFOPTGrowth(pnewheader_table, num_of_newfreqitems, 0);
delete []pnewheader_table;
//goMemTracer.DecBuffer(sizeof(HEADER_NODE)*num_of_newfreqitems);
}
}
start = clock();
PushRight(pheader_table, k, nend_pos);
//if(gndepth==1)
//goTimeTracer.mdInitial_pushright_time += (double)(clock()-start)/CLOCKS_PER_SEC;
//else
//goTimeTracer.mdAFOPT_pushright_time += (double)(clock()-start)/CLOCKS_PER_SEC;
}
else
{
delete pcurroot;
//goMemTracer.DelOneAFOPTNode();
pheader_table[k].pafopt_conddb = NULL;
}
gndepth--;
}
delete []pnewfreqitems;
//goMemTracer.DecBuffer(num_of_freqitems*sizeof(ITEM_COUNTER));
delete []pitem_suporder_map;
//goMemTracer.DecBuffer(num_of_freqitems*sizeof(int));
return;
}
//------------------------------------------------------------------------------------
//mining frequent itemsets from a conditional database represented by array structure
//------------------------------------------------------------------------------------
void CArrayMine::DepthArrayGrowth(HEADER_TABLE pheader_table, int num_of_freqitems)
{
int t, k;
ITEM_COUNTER* pnewfreqitems;
int *pitem_suporder_map;
int num_of_newfreqitems;
HEADER_TABLE pnewheader_table;
clock_t start;
gntotal_call++;
pnewfreqitems = new ITEM_COUNTER[num_of_freqitems];
//goMemTracer.IncBuffer(num_of_freqitems*sizeof(ITEM_COUNTER));
pitem_suporder_map = new int[num_of_freqitems];
//goMemTracer.IncBuffer(num_of_freqitems*sizeof(int));
if(gnmax_pattern_len<gndepth+1)
gnmax_pattern_len = gndepth+1;
for(k=0;k<num_of_freqitems-BUILD_TREE_ITEM_THRESHOLD;k++)
{
OutputOnePattern(pheader_table[k].item, pheader_table[k].nsupport);
if(pheader_table[k].parray_conddb != NULL)
{
gpheader_itemset[gndepth] = pheader_table[k].item;
gndepth++;
//scan the conditional database to count frequent items
for(t=k;t<num_of_freqitems;t++)
pitem_suporder_map[t] = 0;
start = clock();
CountFreqItems(pheader_table[k].parray_conddb, pitem_suporder_map);
//goTimeTracer.mdHStruct_count_time += (double)(clock()-start)/CLOCKS_PER_SEC;
num_of_newfreqitems = 0;
for(t=k;t<num_of_freqitems;t++)
{
if(pitem_suporder_map[t]>=gnmin_sup)
{
pnewfreqitems[num_of_newfreqitems].item = pheader_table[t].item;
pnewfreqitems[num_of_newfreqitems].support = pitem_suporder_map[t];
pnewfreqitems[num_of_newfreqitems].order = t;
num_of_newfreqitems++;
}
pitem_suporder_map[t] = -1;
}
if(num_of_newfreqitems>0)
{
qsort(pnewfreqitems, num_of_newfreqitems, sizeof(ITEM_COUNTER), comp_item_freq_asc);
for(t=0;t<num_of_newfreqitems;t++)
pitem_suporder_map[pnewfreqitems[t].order] = t;
}
if(num_of_newfreqitems==1)
{
if(gnmax_pattern_len<gndepth+1)
gnmax_pattern_len = gndepth+1;
OutputOnePattern(pnewfreqitems[0].item, pnewfreqitems[0].support);
}
else if(num_of_newfreqitems>1)
{
if(num_of_newfreqitems <= MAX_BUCKET_SIZE)
{
start = clock();
memset(gpbuckets, 0, sizeof(int)*(1<<num_of_newfreqitems));
BucketCount(pheader_table[k].parray_conddb, pitem_suporder_map, gpbuckets);
bucket_count(gpbuckets, num_of_newfreqitems, pnewfreqitems);
//goTimeTracer.mdBucket_count_time += (double)(clock()-start)/CLOCKS_PER_SEC;
}
else
{
start = clock();
pnewheader_table = new HEADER_NODE[num_of_newfreqitems];
//goMemTracer.IncBuffer(sizeof(HEADER_NODE)*num_of_newfreqitems);
for(t=0;t<num_of_newfreqitems;t++)
{
pnewheader_table[t].item = pnewfreqitems[t].item;
pnewheader_table[t].nsupport = pnewfreqitems[t].support;
pnewheader_table[t].pafopt_conddb = NULL;
pnewheader_table[t].order = t;
}
if(num_of_newfreqitems<=BUILD_TREE_ITEM_THRESHOLD )
{
for(t=0;t<num_of_newfreqitems;t++)
pnewheader_table[t].flag = AFOPT_FLAG;
}
else
{
for(t=0;t<num_of_newfreqitems-BUILD_TREE_ITEM_THRESHOLD;t++)
pnewheader_table[t].flag = 0;
for(t=num_of_newfreqitems-BUILD_TREE_ITEM_THRESHOLD;t<num_of_newfreqitems;t++)
pnewheader_table[t].flag = AFOPT_FLAG;
}
memset(gpbuckets, 0, sizeof(int)*(1<<MAX_BUCKET_SIZE));
BuildNewCondDB(pheader_table[k].parray_conddb, pnewheader_table, pitem_suporder_map, num_of_newfreqitems, gpbuckets);
//goTimeTracer.mdHStruct_construct_time += (double)(clock()-start)/CLOCKS_PER_SEC;
bucket_count(gpbuckets, MAX_BUCKET_SIZE, &(pnewfreqitems[num_of_newfreqitems-MAX_BUCKET_SIZE]));
if(num_of_newfreqitems<=BUILD_TREE_ITEM_THRESHOLD)
goAFOPTMiner.DepthAFOPTGrowth(pnewheader_table, num_of_newfreqitems, 0);
else
{
DepthArrayGrowth(pnewheader_table, num_of_newfreqitems);
goAFOPTMiner.DepthAFOPTGrowth(pnewheader_table, num_of_newfreqitems, num_of_newfreqitems-BUILD_TREE_ITEM_THRESHOLD);
}
delete []pnewheader_table;
//goMemTracer.DecBuffer(num_of_newfreqitems*sizeof(HEADER_NODE));
}
}
start = clock();
PushRight(pheader_table, k, num_of_freqitems-MAX_BUCKET_SIZE);
//if(gndepth==1)
//goTimeTracer.mdInitial_pushright_time += (double)(clock()-start)/CLOCKS_PER_SEC;
//else
//goTimeTracer.mdHStruct_pushright_time += (double)(clock()-start)/CLOCKS_PER_SEC;
gndepth--;
}
}
delete []pnewfreqitems;
//goMemTracer.DecBuffer(num_of_freqitems*sizeof(ITEM_COUNTER));
delete []pitem_suporder_map;
//goMemTracer.DecBuffer(num_of_freqitems*sizeof(int));
return;
}
