void extend ( LegOccurrences &legoccurrencesdata, EdgeLabel minlabel, EdgeLabel neglect ) {
// we're trying hard to avoid repeated destructor/constructor calls for complex types like vectors.
// better reuse previously allocated memory, if possible!
vector<LegOccurrence> &legoccurrences = legoccurrencesdata.elements;
int lastself[candidatelegsoccurrences.size ()];
for ( int i = 0; i < candidatelegsoccurrences.size (); i++ ) {
candidatelegsoccurrences[i].elements.resize ( 0 );
candidatelegsoccurrences[i].parent = &legoccurrencesdata;
candidatelegsoccurrences[i].number = legoccurrencesdata.number + 1;
candidatelegsoccurrences[i].maxdegree = 0;
candidatelegsoccurrences[i].selfjoin = 0;
lastself[i] = NOTID;
candidatelegsoccurrences[i].frequency = 0;
}
closelegsoccsused = false; // we are lazy with the initialization of close leg arrays, as we may not need them at all in
// many cases
for ( OccurrenceId i = 0; i < legoccurrences.size (); i++ ) {
LegOccurrence &legocc = legoccurrences[i];
DatabaseTreePtr tree = database.trees[legocc.tid];
DatabaseTreeNode &node = tree->nodes[legocc.tonodeid];
for ( int j = 0; j < node.edges.size (); j++ ) {
if ( node.edges[j].tonode != legocc.fromnodeid ) {
EdgeLabel edgelabel = node.edges[j].edgelabel;
int number = nocycle ( tree, node, node.edges[j].tonode, i, &legoccurrencesdata );
if ( number == 0 ) {
if ( edgelabel >= minlabel && edgelabel != neglect ) {
vector<LegOccurrence> &candidatelegsoccs = candidatelegsoccurrences[edgelabel].elements;
if ( candidatelegsoccs.empty () )
candidatelegsoccurrences[edgelabel].frequency++;
else {
if ( candidatelegsoccs.back ().tid != legocc.tid )
candidatelegsoccurrences[edgelabel].frequency++;
if ( candidatelegsoccs.back ().occurrenceid == i &&
lastself[edgelabel] != legocc.tid ) {
lastself[edgelabel] = legocc.tid;
candidatelegsoccurrences[edgelabel].selfjoin++;
}
}
candidatelegsoccs.push_back ( LegOccurrence ( legocc.tid, i, node.edges[j].tonode, legocc.tonodeid ) );
setmax ( candidatelegsoccurrences[edgelabel].maxdegree, database.trees[legocc.tid]->nodes[node.edges[j].tonode].edges.size () );
}
}
else if ( number - 1 != graphstate.nodes.back().edges[0].tonode ) {
candidateCloseLegsAllocate ( number, legoccurrencesdata.number + 1 );
vector<CloseLegOccurrence> &candidatelegsoccs = candidatecloselegsoccs[number][edgelabel].elements;
if ( !candidatelegsoccs.size () || candidatelegsoccs.back ().tid != legocc.tid )
candidatecloselegsoccs[number][edgelabel].frequency++;
candidatelegsoccs.push_back ( CloseLegOccurrence ( legocc.tid, i ) );
setmax ( candidatelegsoccurrences[edgelabel].maxdegree, database.trees[legocc.tid]->nodes[node.edges[j].tonode].edges.size () );
}
}
}
}
}
CloseLegOccurrencesPtr join ( LegOccurrences &legoccsdata, CloseLegOccurrences &closelegoccsdata ) {
Frequency frequency = 0;
Tid lasttid = NOTID;
vector<CloseLegOccurrence> &closelegoccs = closelegoccsdata.elements;
vector<LegOccurrence> &legoccs = legoccsdata.elements;
closelegoccurrences.elements.resize ( 0 );
unsigned int legoccssize = legoccs.size (), closelegoccssize = closelegoccs.size ();
OccurrenceId j = 0, k = 0;
int comp;
while ( true ) {
comp = legoccs[j].occurrenceid - closelegoccs[k].occurrenceid;
if ( comp < 0 ) {
j++;
if ( j == legoccssize )
break;
}
else {
if ( comp == 0 ) {
closelegoccurrences.elements.push_back ( CloseLegOccurrence ( legoccs[j].tid, j ) );
if ( legoccs[j].tid != lasttid ) {
lasttid = legoccs[j].tid;
frequency++;
}
j++;
if ( j == legoccssize )
break;
}
else {
k++;
if ( k == closelegoccssize )
break;
}
}
}
if ( frequency >= minfreq ) {
closelegoccurrences.frequency = frequency;
return &closelegoccurrences;
}
else
return NULL;
}
CloseLegOccurrencesPtr join ( CloseLegOccurrences &closelegoccsdata1, CloseLegOccurrences &closelegoccsdata2 ) {
Frequency frequency = 0;
Tid lasttid = NOTID;
vector<CloseLegOccurrence> &closelegoccs1 = closelegoccsdata1.elements,
&closelegoccs2 = closelegoccsdata2.elements;
unsigned int closelegoccs1size = closelegoccs1.size (), closelegoccs2size = closelegoccs2.size ();
closelegoccurrences.elements.resize ( 0 );
OccurrenceId j = 0, k = 0;
int comp;
while ( true ) {
comp = closelegoccs1[j].occurrenceid - closelegoccs2[k].occurrenceid;
if ( comp < 0 ) {
j++;
if ( j == closelegoccs1size )
break;
}
else {
if ( comp == 0 ) {
closelegoccurrences.elements.push_back ( CloseLegOccurrence ( closelegoccs1[j].tid, closelegoccs1[j].occurrenceid ) );
if ( closelegoccs1[j].tid != lasttid ) {
lasttid = closelegoccs1[j].tid;
frequency++;
}
j++;
if ( j == closelegoccs1size )
break;
}
k++;
if ( k == closelegoccs2size )
break;
}
}
if ( frequency >= minfreq ) {
closelegoccurrences.frequency = frequency;
return &closelegoccurrences;
}
else
return NULL;
}
