pagerank

#include <string>

#include <iostream>

#include <fstream>

#include <vector>

#include <cmath>

#include <cstdlib>

#include <cstring>

#include <errno.h>

#include <dirent.h>

#include "table.h"

using namespace std;

const double EPSILON = 0.0001;

void error(const char *p,const char *p2) {

    cerr << p <<  ' ' << p2 <<  '\n';

    exit(1);

}

void error(const string p,const string p2) {

    cerr << p <<  ' ' << p2 <<  '\n';

    exit(1);

}

int main(int argc, char *argv[]) {

    Table t;

    bool numeric = false;

    if (argc != 2 && argc != 3) {

        cerr << "Usage: pagerank_test [-n] <test_suite>" << endl;

        exit(1);

    }

    if (argc == 3) {

        if (!strcmp(argv[1], "-n")) {

            numeric = true;

        } else {

            cerr << "Usage: pagerank_test [-n] <test_suite>" << endl;

            exit(1);

        }

    }

    string tests_filename = argv[argc - 1];

    ifstream tests_file(tests_filename.c_str());

    if (!tests_file.is_open()) {

        error("Cannot open file", tests_filename);

    }

    while (!tests_file.eof()) {

        string test_line;

        getline(tests_file, test_line);

        if (test_line.empty()) {

            continue;

        }

        cout << "testing " << test_line << "... ";

        /* Get graph file and pagerank file names */

        string graph_filename = test_line + ".txt";

        string pagerank_filename = test_line + "-pr.txt";

        /* Open pagerank file */

        ifstream pagerank_file(pagerank_filename.c_str());

        if (!pagerank_file.is_open()) {

            cerr << endl;

            error("Cannot open pagerank file", pagerank_filename);

        }

        /* Read graph file */

        t.set_numeric(numeric);

        t.set_delim(" ");

        t.set_trace(false);

        t.read_file(graph_filename);

        /* Calculate pagerank */

        t.pagerank();

        /* Read pagerank test results file */

        vector<double> pagerank_test_values;

        while (!pagerank_file.eof()) {

            string pagerank_line;

            getline(pagerank_file, pagerank_line);

            if (pagerank_line.find("s = ") != string::npos) {

                break;

            }

            string::size_type sep = pagerank_line.find(" = ");

            if (sep == string::npos) {

                    break;

            }

            string index_str = pagerank_line.substr(0, sep);

            size_t index = strtol(index_str.c_str(), NULL, 10);

            string value_str = pagerank_line.substr(sep + 3);

            double value;

            value = strtod(value_str.c_str(), NULL);

            if (index >= pagerank_test_values.size()) {

                pagerank_test_values.resize(index + 1);

            }

            pagerank_test_values[index] = value;

        }

        pagerank_file.close();

        /* Compare test results with calculated results */

        vector<double> pagerank_results = t.get_pagerank();

        bool test_ok = true;

        for (unsigned int i = 0; i < pagerank_results.size(); i++) {

            double result = pagerank_results[i];

            string name = t.get_node_name(i);

            size_t test_index = strtol(name.c_str(), NULL, 10);

            double test_result = pagerank_test_values[test_index];

            double diff = abs(result - test_result);

            if (diff > EPSILON) {

                cout << " error in calculation for " << name << ": "

                     << "result=" << result << " "

                     << "expected=" << test_result << " "

                     << "diff=" << diff << " ";

                test_ok = false;

                break;

            }

        }

        if (test_ok) {

            cout << "OK" << endl;

        } else {

            cout << "Failed" << endl;

        }

    }

}