void numberOfCCsMaxCC(Graph* g, int* numberOfCCs, int* maxCC) {
List* intList = g->getAllIDs();
int numberOfCC = 0;
int numberOfNodes = 0;
int maxNumCC = 0;
LinearHashTable *hashTable = g->getHashTable();
BucketList **bucketListTable = hashTable->getTable();
for (int i = 0; i < hashTable->getCurrentBucketNo(); i++) {
BucketList *bucketList = bucketListTable[i];
BucketListItem *cur = (BucketListItem*) bucketList->getHead();
while (cur != NULL) {
Bucket *bucket = cur->getElement();
for (int j = 0; j < bucket->getSize(); j++) {
BucketItem *bi = bucket->getBucketItemByIndex(j);
int startNodeId = bi->getNodeID();
numberOfNodes = 0;
bool skip = true;
IntegerListItem* listNode = (IntegerListItem*) intList->getHead();
while (listNode != NULL) {
if (listNode->getInt() == startNodeId) {
intList->deleteItem(listNode);
numberOfCC++;
numberOfNodes++;
skip = false;
break;
}
listNode = (IntegerListItem*) listNode->getNext();
}
if (!skip) {
//reachNodeN from each node of the graph
ResultSet *res = reachNodeN(startNodeId, g);
Pair* pair;
while (pair = res->next()) {
IntegerListItem* searchListNode = (IntegerListItem*) intList->getHead();
while (searchListNode != NULL) {
if (searchListNode->getInt() == pair->getNodeId()) {
intList->deleteItem(searchListNode);
numberOfNodes++;
break;
}
searchListNode = (IntegerListItem*) searchListNode->getNext();
}
}
//delete res; //free(): invalid next size (fast):
}
if (numberOfNodes > maxNumCC)
maxNumCC = numberOfNodes;
}
cur = (BucketListItem*) cur->getNext();
}
}
delete intList;
*numberOfCCs = numberOfCC;
*maxCC = maxNumCC;
}
void LinearHashTableTest::testConstIterator()
{
const int N = 1000;
LinearHashTable<int, Hash<int> > ht;
for (int i = 0; i < N; ++i)
{
ht.insert(i);
}
std::set<int> values;
LinearHashTable<int, Hash<int> >::ConstIterator it = ht.begin();
while (it != ht.end())
{
assert (values.find(*it) == values.end());
values.insert(*it);
++it;
}
assert (values.size() == N);
values.clear();
const LinearHashTable<int, Hash<int> > cht(ht);
LinearHashTable<int, Hash<int> >::ConstIterator cit = cht.begin();
while (cit != cht.end())
{
assert (values.find(*cit) == values.end());
values.insert(*cit);
++cit;
}
assert (values.size() == N);
}
void LinearHashTableTest::testInsert()
{
const int N = 1000;
LinearHashTable<int> ht;
assert (ht.empty());
for (int i = 0; i < N; ++i)
{
std::pair<LinearHashTable<int>::Iterator, bool> res = ht.insert(i);
assert (*res.first == i);
assert (res.second);
LinearHashTable<int>::Iterator it = ht.find(i);
assert (it != ht.end());
assert (*it == i);
assert (ht.size() == i + 1);
}
assert (!ht.empty());
for (int i = 0; i < N; ++i)
{
LinearHashTable<int>::Iterator it = ht.find(i);
assert (it != ht.end());
assert (*it == i);
}
for (int i = 0; i < N; ++i)
{
std::pair<LinearHashTable<int>::Iterator, bool> res = ht.insert(i);
assert (*res.first == i);
assert (!res.second);
}
}
/**
* Calculates the degree distribution of a graph and visualizes it using GNUPLOT.
* Only considers out_degree.
*/
void degreeDistribution(Graph *g, bool checkFlag) {
int nodeNo = g->getNodeNo();
// Initialize array of N-1 elements to zeros ( holding the P(k)s, for k in (0,n-1) ).
double totalCounters[nodeNo];
for (int i = 0; i < nodeNo; i++)
totalCounters[i] = 0;
// Traverse HashTable and update all counters.
LinearHashTable *hashTable = g->getHashTable();
BucketList **bucketListTable = hashTable->getTable();
for (int i = 0; i < hashTable->getCurrentBucketNo(); i++) {
BucketList *bucketList = bucketListTable[i];
BucketListItem *cur = (BucketListItem*) bucketList->getHead();
while (cur) {
Bucket *bucket = cur->getElement();
// Count neighbors and update appropriate counter.
for (int j = 0; j < bucket->getSize(); j++) {
BucketItem *bi = bucket->getBucketItemByIndex(j);
int count = bi->getEdgeList()->getSize();
totalCounters[count]++;
}
cur = (BucketListItem*) cur->getNext();
}
}
// Divide each counter by N.
for (int i = 0; i < nodeNo; i++)
totalCounters[i] = totalCounters[i] / nodeNo;
if (checkFlag == true) {
assert(int(totalCounters[0] * 10000) == 9898);
assert(int(totalCounters[98] * 10000) == 101);
}
// Make data file.
ofstream myFile;
const char *filename = "graph_metrics/gnuplot/bin/data.txt";
myFile.open(filename);
if (myFile.fail()) {
cout << "ERROR: Unable to open " << filename << endl;
return;
}
myFile << "# K P(K)" << endl;
for (int i = 0; i < nodeNo; i++)
myFile << i << " " << 100 * totalCounters[i] << endl;
myFile.close();
// Run gnuplot to display graph.
#ifdef __CYGWIN__
system("cd graph_metrics/gnuplot/bin; ./gnuplot.exe degree.gnu");
#else
system("cd graph_metrics/gnuplot/bin; wine gnuplot.exe degree.gnu");
#endif
}
void LinearHashTableTest::testErase()
{
const int N = 1000;
LinearHashTable<int, Hash<int> > ht;
for (int i = 0; i < N; ++i)
{
ht.insert(i);
}
assert (ht.size() == N);
for (int i = 0; i < N; i += 2)
{
ht.erase(i);
LinearHashTable<int, Hash<int> >::Iterator it = ht.find(i);
assert (it == ht.end());
}
assert (ht.size() == N/2);
for (int i = 0; i < N; i += 2)
{
LinearHashTable<int, Hash<int> >::Iterator it = ht.find(i);
assert (it == ht.end());
}
for (int i = 1; i < N; i += 2)
{
LinearHashTable<int, Hash<int> >::Iterator it = ht.find(i);
assert (it != ht.end());
assert (*it == i);
}
for (int i = 0; i < N; i += 2)
{
ht.insert(i);
}
for (int i = 0; i < N; ++i)
{
LinearHashTable<int, Hash<int> >::Iterator it = ht.find(i);
assert (it != ht.end());
assert (*it == i);
}
}
