my $self = shift;

  if (defined $self->{adjacency_matrix}) {
    untie %{$self->{adjacency_matrix}};
  }
  if (defined $self->{adjacency_matrix_file}) {
    unlink $self->{adjacency_matrix_file} or die "Couldn't delete " .
      $self->{adjacency_matrix_file} . ": $!\n";
  }

  if (defined $self->{path_length_matrix}) {
    untie %{$self->{path_length_matrix}};
  }
  if (defined $self->{path_length_matrix_filename}) {
    unlink $self->{path_length_matrix_filename} or die "Couldn't delete " .
      $self->{path_length_matrix_filename} . ": $!\n";
  }

  my $self = shift;
  my $graph = $self->{graph};

  my %parameters = @_;

  my $write_to_file = 0;
  my $filename = "";
  if (exists $parameters{filename}) {
    $write_to_file = 1;
    $filename = $parameters{filename};
    open(WATT, "> $filename") or die("Could not open file: $filename\n");
  }

  my %link_hash;

  if ($write_to_file == 1) {
    print WATT "reading the input...\n";
  }

  %link_hash = $self->get_adjacency_matrix(undirected => 1);

  if ($write_to_file == 1) {
    print WATT "done!\n";
  }

  my $sum = 0;
  my $count = 0;
  my $skipped = 0;

  foreach my $v (keys %link_hash) {
    my $c = 0;
    my $connected = 0;
    my %nn;
    my @neighbors;

    if (exists $link_hash{$v}) {
      @neighbors = keys %{$link_hash{$v}};
      if (@neighbors > 1) {
        if (@neighbors > 5000) {
          $skipped++;
          next;
        }
        foreach my $n1 (0..$#neighbors) {
          foreach my $n2 ($n1+1..$#neighbors) {
            if (exists $link_hash{$neighbors[$n1]}{$neighbors[$n2]}) {
              $connected++;
            }
          }
        }
        $c = 2 * $connected / (@neighbors * (@neighbors-1));
      }
    }

    $count++;

    if ($write_to_file == 1) {
      print WATT "clustering coefficient for $v is $c\n";
    }

    $sum += $c;
  }

  if ($write_to_file == 1) {
    print WATT "\nnumber of nodes skipped (with degree > 5000): $skipped\n";
  }

  close WATT;

  if ($count == 0) {
    return 0;
  } else {
    return $sum/$count;
  }

  my $self = shift;
  my $graph = $self->{graph};

  my %parameters = @_;

  my $write_to_file = 0;
  my $filename = "";
  if (exists $parameters{filename}) {
    $write_to_file = 1;
    $filename = $parameters{filename};
    open(WATT, "> $filename") or die("Could not open file: $filename\n");
  }

  my %link_hash;

  if ($write_to_file == 1) {
    print WATT "reading the input...\n";
  }

  %link_hash = $self->get_adjacency_matrix();

  my $skipped = 0;
  my %local_cc = ();

  foreach my $v (keys %link_hash) {
    my $c = 0;
    my $connected = 0;
    my %nn;
    my @neighbors;

    if (exists $link_hash{$v}) {
      @neighbors = keys %{$link_hash{$v}};
      if (@neighbors > 1) {
        if (@neighbors > 5000) {
          $skipped++;
          next;
        }
        foreach my $n1 (0..$#neighbors) {
          foreach my $n2 ($n1+1..$#neighbors) {
            if (exists $link_hash{$neighbors[$n1]}{$neighbors[$n2]}) {
              $connected++;
            }
          }
        }
        $c = 2 * $connected / (@neighbors * (@neighbors-1));
      }
    }

    if ($write_to_file == 1) {
      print WATT "clustering coefficient for $v is $c\n";
    }

    $local_cc{$v} = $c;
  }

  if ($write_to_file == 1) {
    print WATT "\nnumber of nodes skipped (with degree > 5000): $skipped\n";
  }

  close WATT;

  return %local_cc;

        my $self = shift;

        my $u = shift;
        my $v = shift;

        my $graph = $self->{graph};

        $graph->add_edge($u, $v);
        $self->clear_cache();

        my $self = shift;

        my $node = shift;
        my @remaining_args = @_;

        # my $text = shift;

        my %parameters = @_;

        my $graph = $self->{graph};

        $graph->add_vertex($node);

        foreach $key (keys %parameters) {
                $graph->set_vertex_attribute($node, $key, $parameters{$key});
        }
        $self->clear_cache();

  my $self = shift;

  my $u = shift;
  my $v = shift;
  my $w = shift;

  my $graph = $self->{graph};

  $graph->add_weighted_edge($u, $v, $w);
  $self->clear_cache();

        my $self = shift;
        my $graph = $self->{graph};

        my $cm = shift;
        my %cos_matrix = %$cm;

        my $tot_link_cos = 0;
        my $link_count = 0;

        my $tot_nl_cos = 0;
        my $nl_count = 0;

        foreach my $doc1 (keys %cos_matrix) {
                foreach my $doc2 (keys %{ $cos_matrix{$doc1} }) {
                        if ($graph->has_edge($doc1, $doc2)) {
                                $tot_link_cos += $cos_matrix{$doc1}{$doc2};
                                $link_count++;
                        } else {
                                $tot_nl_cos += $cos_matrix{$doc1}{$doc2};
                                $nl_count++;
                        }
                }
        }

        my $link_avg = 0;
        if ($link_count > 0) {
                $link_avg = $tot_link_cos/$link_count;
        }

        my $nl_avg = 0;
        if ($nl_count > 0) {
                $nl_avg = $tot_nl_cos/$nl_count;
        }

        return ($link_avg, $nl_avg);

  my $self = shift;
  my $graph = $self->{graph};

  my $directed = $self->{directed};

  my $asp_matrix = $self->get_shortest_path_matrix(directed => $directed);

  my %avg = ();
  my $total_cnt = 0;
  foreach my $v1 (keys %{$asp_matrix}) {
    my $sum = 0;
    my $cnt = 0;
    foreach my $v2 (keys %{$asp_matrix->{$v1}}) {
      my $len = $asp_matrix->{$v1}{$v2};
      if ($len >= 0) {
        $sum += $len;
        $cnt++;
      }
    }
    if ($cnt > 1) {
      $avg{$v1} = $sum / $cnt;
      $total_cnt++;
    }
  }

  my $sum = 0;
  foreach my $k (keys %avg) {
    $sum += $avg{$k};
  }

  if (int(scalar(keys %avg)) == 0) {
    return 0;
  } else {
    return $sum / int(scalar(keys %avg));
  }

        my $self = shift;
        my %histogram = $self->compute_in_link_histogram();

        my $total_in = 0;
        my $num_nodes = scalar $self->get_vertices();
        foreach my $value (keys %histogram)
        {
                #skip nodes that have no links
                next if $value == 0;

                my $num = $histogram{$value};

                $total_in += $value * $num;
        }

        return $total_in/$num_nodes;

        my $self = shift;
        my %histogram = $self->compute_out_link_histogram();

        my $total_out = 0;
        my $num_nodes = scalar $self->get_vertices();
        foreach my $value (keys %histogram)
        {
                #skip nodes that have no links
                next if $value == 0;

                my $num = $histogram{$value};
                $total_out += $value * $num;
        }
        return $total_out/$num_nodes;

        my $self = shift;
        my %histogram = $self->compute_total_link_histogram();

        if (!$self->{directed}) {
          return $self->{graph}->average_degree();
        }
        my $total = 0;
        my $num_nodes = 0;
        foreach my $value (keys %histogram)
        {
                #skip nodes that have no links
                next if $value == 0;

                my $num = $histogram{$value};
                $total += $value * $num;
                $num_nodes += $num;
        }
        my $deg = 0;
        if ($self->{directed}) {
          $deg = $total / $num_nodes;
        } else {
          $deg = ($total / $num_nodes) / 2;
        }
        return $deg;

        my $self = shift;
        my %parameters = @_;

        my $text_of = $self->{text_of};

        my %cosine_of;

        my $graph = $self->{graph};

        foreach $u ($graph->vertices) {
                my %cosines_of_u;

                foreach $v ($graph->vertices) {
                        if ($u < $v) {
                                my $text_of_u = $text_of->{$u};
                                my $text_of_v = $text_of->{$v};

                                my $cosine = GetLexSim($text_of_u, $text_of_v);
                                print "$u $v, $cosine\n";
                                $cosines_of_u{$v} = $cosine;
                        }
                }

                if (scalar(keys(%u_cosine_of)) > 0) {
                        $cosine_of{$u} =\% cosines_of_u;
                }
        }

        return %cosine_of;

        my $self = shift;
        my $graph = $self->{graph};

        my %histogram = ();

        foreach my $v ($graph->vertices)
        {
                my $num_in = $graph->predecessors($v);
                if (not exists $histogram{$num_in} )
                {
                        $histogram{$num_in} = 1;
                } else {
                        $histogram{$num_in}++;
                }
        }

        return %histogram;

        my $self = shift;
        my $graph = $self->{graph};

        my %histogram = ();

        foreach my $v ($graph->vertices)
        {
                my $num_out = $graph->successors($v);
                if (not exists $histogram{$num_out})
                {
                        $histogram{$num_out} = 1;
                } else {
                        $histogram{$num_out}++;
                }
        }

        return %histogram;

        my $self = shift;
        my %params = @_;

        my $pagerank_value = 'pagerank_value';
        if (exists $params{pagerank_value}) {
                $pagerank_value = $params{pagerank_value};
        }

        my $pagerank_transition = 'pagerank_transition';
        if (exists $params{pagerank_transition}) {
                $pagerank_transition = $params{pagerank_transition};
        }

        my $pagerank_bias = 'pagerank_bias';
        if (exists $param{pagerank_bias}) {
                $pagerank_bias = $params{pagerank_bias};
        }

        my $jump = 0;
        if (exists $params{jump}) {
                $jump = $params{jump};
        }

        my $tolerance = 0;
        if (exists $params{tolerance}) {
                $tolerance = $params{tolerance};
        }

        my $max_iterations = 0;
        if (exists $params{max_iterations}) {
                $max_iterations = $params{max_iterations};
        }

        return $self->compute_rank_result($pagerank_value, $pagerank_transition, $jump,
                                          $pagerank_bias, tolerance => $tolerance,
                                                                                                                                                max_iterations => $max_iterations);

        my $self = shift;
        my $graph = $self->{graph};

        my $cur_prob = shift;
        my $trans_matrix = shift;

        my $result = $trans_matrix->multiply($cur_prob)<