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 () );
}
}
}
}
}
void bbrc_extend ( LastLegOccurrences &legoccurrencesdata ) {
// we're trying hard to avoid repeated destructor/constructor calls for complex types like vectors.
// better reuse previously allocated memory, if possible!
vector<LastLegOccurrence> &legoccurrences = legoccurrencesdata.elements; ///////////////////////////////////////AM : BUG!!!
LastTid lastself[fm::last_Lastcandidatelegsoccurrences.size ()];
for ( int i = 0; i < (int) fm::last_Lastcandidatelegsoccurrences.size (); i++ ) {
fm::last_Lastcandidatelegsoccurrences[i].elements.resize ( 0 );
//fm::last_Lastcandidatelegsoccurrences[i].elements.reserve ( legoccurrences.size () ); // increases memory usage, but also speed!
fm::last_Lastcandidatelegsoccurrences[i].parent = &legoccurrencesdata;
fm::last_Lastcandidatelegsoccurrences[i].number = legoccurrencesdata.number + 1;
fm::last_Lastcandidatelegsoccurrences[i].maxdegree = 0;
fm::last_Lastcandidatelegsoccurrences[i].frequency = 0;
fm::last_Lastcandidatelegsoccurrences[i].selfjoin = 0;
lastself[i] = NOTID;
}
fm::last_Lastcloselegsoccsused = false; // we are lazy with the initialization of close leg arrays, as we may not need them at all in
// many cases
for ( LastOccurrenceId i = 0; i < legoccurrences.size (); i++ ) {
LastLegOccurrence &legocc = legoccurrences[i];
LastDatabaseTreePtr tree = fm::last_database->trees[legocc.tid];
LastDatabaseTreeNode &node = tree->nodes[legocc.tonodeid];
for ( int j = 0; j < node.edges.size (); j++ ) {
if ( node.edges[j].tonode != legocc.fromnodeid ) {
LastEdgeLabel edgelabel = node.edges[j].edgelabel;
int number = nocycle ( tree, node, node.edges[j].tonode, i, &legoccurrencesdata );
if ( number == 0 ) {
vector<LastLegOccurrence> &candidatelegsoccs = fm::last_Lastcandidatelegsoccurrences[edgelabel].elements;
if ( candidatelegsoccs.empty () ) fm::last_Lastcandidatelegsoccurrences[edgelabel].frequency++;
else {
if ( candidatelegsoccs.back ().tid != legocc.tid )
fm::last_Lastcandidatelegsoccurrences[edgelabel].frequency++;
if ( candidatelegsoccs.back ().occurrenceid == i &&
lastself[edgelabel] != legocc.tid ) {
lastself[edgelabel] = legocc.tid;
fm::last_Lastcandidatelegsoccurrences[edgelabel].selfjoin++;
}
}
candidatelegsoccs.push_back ( LastLegOccurrence ( legocc.tid, i, node.edges[j].tonode, legocc.tonodeid ) );
Lastsetmax ( fm::last_Lastcandidatelegsoccurrences[edgelabel].maxdegree, fm::last_database->trees[legocc.tid]->nodes[node.edges[j].tonode].edges.size () );
}
else if ( number - 1 != fm::last_graphstate->nodes.back().edges[0].tonode ) {
candidateLastCloseLastLegsAllocate ( number, legoccurrencesdata.number + 1 );
vector<CloseLastLegOccurrence> &candidatelegsoccs = fm::last_candidatecloselegsoccs[number][edgelabel].elements;
if ( !candidatelegsoccs.size () || candidatelegsoccs.back ().tid != legocc.tid )
fm::last_candidatecloselegsoccs[number][edgelabel].frequency++;
candidatelegsoccs.push_back ( CloseLastLegOccurrence ( legocc.tid, i ) );
Lastsetmax ( fm::last_Lastcandidatelegsoccurrences[edgelabel].maxdegree, fm::last_database->trees[legocc.tid]->nodes[node.edges[j].tonode].edges.size () );
}
}
}
}
}
