# Read in from file
  my $graphio = Bio::Graph::IO->new(-file   => 'myfile.dat',
                                    -format => 'dip');
  my $graph   = $graphio->next_network();

  # Remove duplicate interactions from within a dataset
  $graph->remove_dup_edges();

  # Get a node (represented by a sequence object) from the graph.
  my $seqobj = $gr->nodes_by_id('P12345');

  # Get clustering coefficient of a given node.
  my $cc = $gr->clustering_coefficient($graph->nodes_by_id('NP_023232'));
  if ($cc != -1) {  ## result is -1 if cannot be calculated
    print "CC for NP_023232 is $cc";
  }

  # Get graph density
  my $density = $gr->density();

  # Get connected subgraphs
  my @graphs = $gr->components();

  # Remove a node
  $gr->remove_nodes($gr->nodes_by_id('P12345'));

  # How many interactions are there?
  my $count = $gr->edge_count;

  # How many nodes are there?
  my $ncount = $gr->node_count();

  # Let's get interactions above a threshold confidence score.
  my $edges = $gr->edges;
  for my $edge (keys %$edges) {
	 if (defined($edges->{$edge}->weight()) &&
      $edges->{$edge}->weight() > 0.6) {
		    print $edges->{$edge}->object_id(), "\t",
             $edges->{$edge}->weight(),"\n";
	 }
  }

  # Get interactors of your favourite protein
  my $node      = $graph->nodes_by_id('NP_023232');
  my @neighbors = $graph->neighbors($node); 
  print "      NP_023232 interacts with ";
  print join " ,", map{$_->object_id()} @neighbors;
  print "\n";

  # Annotate your sequences with interaction info
  my @seqs; ## array of sequence objects
  for my $seq(@seqs) {
    if ($graph->has_node($seq->accession_number)) {
       my $node = $graph->nodes_by_id( $seq->accession_number);
       my @neighbors = $graph->neighbors($node);
       for my $n (@neighbors) {
         my $ft = Bio::SeqFeature::Generic->new(
                      -primary_tag => 'Interactor',
                      -tags        => { id => $n->accession_number }
                      );
            $seq->add_SeqFeature($ft);
        }
     }
  }

  # Get proteins with > 10 interactors
  my @nodes = $graph->nodes();
  my @hubs;
  for my $node (@nodes) {
    if ($graph->neighbor_count($node) > 10) {
       push @hubs, $node;
    }
  }
  print "the following proteins have > 10 interactors:\n";
  print join "\n", map{$_->object_id()} @hubs;

  # Merge graphs 1 and 2 and flag duplicate edges
  $g1->union($g2);
  my @duplicates = $g1->dup_edges();
  print "these interactions exist in $g1 and $g2:\n";
  print join "\n", map{$_->object_id} @duplicates;

  edgeid  node1  node2  score

  my $io = Bio::Root::IO->new(-file => 'mydata');
  my $gr = Bio::Graph::ProteinGraph->new();
  my %seen = (); # to record seen nodes
  while (my $l = $io->_readline() ) {

  # Parse out your data...
  my ($e_id, $n1, $n2, $sc) = split /\s+/, $l;

  # ...then make nodes if they don't already exist in the graph...
  my @nodes =();
    for my $n ($n1, $n2 ) {
		if (!exists($seen{$n})) {
        push @nodes,  Bio::Seq->new(-accession_number => $n);
		  $seen{$n} = $nodes[$#nodes];
      } else {
			push @nodes, $seen{$n};
	   }
    }
  }

  # ...and add a new edge to the graph
  my $edge  = Bio::Graph::Edge->new(-nodes => \@nodes,
                                    -id    => 'myid',
                                    -weight=> 1);
  $gr->add_edge($edge);

 my ($self, $arg) = @_;
 if (!$arg) {
		$self->throw ("I need a sequence identifier!");
   }
 my @nodes = $self->nodes_by_id($arg);
 if (defined($nodes[0])){return 1;}else{return 0};

	my $self  = shift;
	my @nodes  = $self->_ids(@_);
	wantarray? @nodes: $nodes[0];

	my ($self, $other) = @_;
	my $class      = ref($self);
	if (!$other->isa($class)) {
		$self->throw("I need a ". $class . " object, not a [".
						 ref($other). "] object");
	}
	my @common_nodes;
	my %detected_common_nodes;
	my %seen_ids; # holds ids of nodes  already known to be common. 

	## for each node see if Ids are in common between the 2 graphs
	## just get1 common id per sequence.

	## Produces too many common nodes we only need 1 common id between nodes.
	for my $id (sort keys %{$self->{'_id_map'}}) {
		if (exists($other->{'_id_map'}{$id}) ) { 
			## check  if this node has a commonlink kown lready:
			my $node = $self->nodes_by_id($id);
			my $acc = $node->object_id;
			if (!exists($detected_common_nodes{$acc})) {
			   push @common_nodes, $id; ## we store the common id
			   $detected_common_nodes{$acc} = undef; ## this means we won't store >1 common identifier
			}
		}
	}

	## now cyle through common nodes..
	$self->debug( "there are ". scalar @common_nodes. " common nodes\n");
	my $i = 0;
	for my $common (@common_nodes) {
		if ($i++ % 10 ==0 ) {
			$self->debug(".");
		}
		## get neighbours of common node for self and other
		my @self_ns   = $self->neighbors($self->nodes_by_id($common));
		my @other_ns  = $other->neighbors($other->nodes_by_id($common));

		## now get all ids of all neighbours
		my %self_n_ids = $self->_get_ids(@self_ns);	# get all ids of neighbors

		## cycle through other neighbors
		for my $other_n(@other_ns){ 
			my %other_n_ids = $self->_get_ids($other_n); # get ids of single other neighbor

			## case (1) in description
			## do any ids in other graph exist in self ?
			# if yes,  @int_match is defined, interaction does not involve a new node
			my @int_match = grep{exists($self->{'_id_map'}{$_}) } keys %other_n_ids;
			if (@int_match){
				my $i = 0;
				my $edge;

				## we cycle through until we have an edge defined, this deals with 
				## multiple id matches
				while (!$edge && $i <= $#int_match){

					## get edge from other graph
					my $other_edge = $other->edge(
												 [$other->nodes_by_id($common),
												  $other->nodes_by_id($other_n->object_id)]
														  );

					## copy it
					my $edge = Bio::Graph::Edge->new(
													 -weight=> $other_edge->weight(),
													 -id    => $other_edge->object_id(),
													 -nodes =>[$self->nodes_by_id($common),
								   $self->nodes_by_id($int_match[$i])
																 ]);
					## add it to self graph.
					## add_edge() works out if the edge is a new,  
					## duplicate or a redundant edge.
					$self->add_edge($edge);

					$i++;
				}
			}		# end if
			## but if other neighbour is entirely new, clone it and 
			## make connection.
			else  {
				my $other_edge = $other->edge($other->nodes_by_id($other_n->object_id()),
														$other->nodes_by_id($common));
				my $new = clone($other_n);
				$self->add_edge(Bio::Graph::Edge->new(
							  -weight => $other_edge->weight(),
							  -id     => $other_edge->object_id(),
							  -nodes  =>[$new, $self->nodes_by_id($common)],
																 )
									);

				## add new ids to self graph look up table
				map {$self->{'_id_map'}{$_} = $new} keys %other_n_ids;
			} #end if
		} #next neighbor
	} #next node

    my $self = shift;
    return scalar keys %{$self->_edges};

    my $self = shift;
    return scalar keys %{$self->_nodes};

 my ($self, $node) = @_;
 if (!$node->isa('Bio::NodeI')) {
  $self->throw ("I need a Bio::NodeI implementing object here , not a " . ref($node) . ".");
	}
 my @nbors = $self->neighbors($node);
 return scalar @nbors;

	my %ids;
	my $dummy_self = shift;
	while (my $n = shift @_ ){  #ref to node, assume is a Bio::Seq
		if (!$n->isa('Bio::AnnotatableI') || ! $n->isa('Bio::IdentifiableI' )) {
			$n->throw("I need a Bio::AnnotatableI and Bio::IdentifiableI  implementing object, not a [" .ref($n) ."]");
		}

		##if BioSeq getdbxref ids as well.
		my $ac = $n->annotation();	
		for my $an($ac->get_Annotations('dblink')) {
			$ids{$an->database()} = $an->primary_id();
		}
	}
	return %ids;

	my %ids;
	my $dummy_self = shift;
	while (my $n = shift @_ ){  #ref to node, assume is a Bio::Seq
		if (!$n->isa('Bio::AnnotatableI') || ! $n->isa('Bio::IdentifiableI' )) {
			$n->throw("I need a Bio::AnnotatableI and Bio::IdentifiableI  implementing object, not a [" .ref($n) ."]");
		}
		#get ids
		map {$ids{$_} = undef} ($n->object_id);

		##if BioSeq getdbxref ids as well.
		if ($n->can('annotation')) {
			my $ac = $n->annotation();	
			for my $an($ac->get_Annotations('dblink')) {
				$ids{$an->primary_id()} = undef;
			}
		}
	}
	return %ids;

	my $self      = shift;
	my $edges     = $self->_edges;
	my $neighbors = $self->_neighbors;
	my $dup_edges = $self->_dup_edges;
	my $edge;
	while (@_) {
		if ( ref($_[0]) eq 'ARRAY' || !ref($_[0])) {
      	$self->SUPER::add_edges(@_);
			return;
		} 
		elsif ( $_[0]->isa('Bio::Graph::Edge') ) {	# it's already an edge
			$edge = shift;
		}
		else {
			$self->throw(" Invalid edge! - must be an array of nodes, or an edge object");
		}

		my ($m, $n) = $edge->nodes();
		next if $m eq $n;		# no self edges
		last unless defined $m && defined $n;
		($m,$n) = ($n,$m) if "$n" lt "$m";

		if (!exists($edges->{$m,$n})) {
			$self->add_node($m,$n);
			($m,$n)         = $self->nodes($m,$n);
			$edges->{$m,$n} = $edge;
			push(@{$neighbors->{$m}},$n);
			push(@{$neighbors->{$n}},$m);

			## create look up hash for edge ##
			$self->{'_edge_id_map'}{$edge->object_id()} = $edge;
		} else {
			## is it a redundant edge, ie with same edge id?
			my $curr_edge = $edges->{$m,$n};
			if($curr_edge->object_id() eq $edge->object_id()) {
				$self->redundant_edge($edge);
			}
			## else it is a duplicate i.e., same nodes but different edge id
			else {
				$self->add_dup_edge($edge); 
			}
		}
	}
	$self->_is_connected(undef);	# clear cached value

 my $self=shift;

  ## make new graph of same type as parent
  my $class    = ref($self);
  my $subgraph = new $class;
  $subgraph->add_node(@_);
  # add all edges amongst the nodes
  my @nodes=$subgraph->nodes;
  my $i = 1;
  while(@nodes) {
    if ($i++ % 100 == 0) { print STDERR ".";}
    my $m=shift @nodes;
    my $edges = $self->_edges;
    for my $n (@nodes) { 
       if ($self->has_edge([$m,$n])) {
          my ($edge) = $self->edges([$m,$n]); ## returns list of edges
          my $id = $edge->object_id;
          $subgraph->add_edge(Bio::Graph::Edge->new(-nodes=>[$m,$n],
                                                    -id   => $id));
        }
    }
  }#next node
  return $subgraph;

	## get the 2 nodes
	my ($self, $newedge) = @_;
	## prelimaries
	my $newedge_id   = $newedge->object_id();

	## now we have node objects, an edge id.
	## is edge id new?
	my $dup_edges = $self->_dup_edges();
	if(!grep{$_->object_id eq $newedge_id } @$dup_edges) {
		push @$dup_edges, $newedge;
		}
	else {
		$self->redundant_edge($newedge);
	}

 my ($self, $id) = @_;
 if (!$id) {
	$self->warn ("Need a text identifier");
   	return;
	}
 if (ref($id)) {
    $self->throw(" I need a text identifier, not a [" . ref($id) . "].");
    }
  if (defined($self->{'_edge_id_map'}{$id})) {
     return $self->{'_edge_id_map'}{$id};
       }else {return;}

  my ($self, @args) = @_;
  my $dups = $self->_dup_edges(); 
	if (!@args) {
  		$dups   = [];
		}
	else {
		while (my $node = shift @args) {
			my @new_dups;
			for my $dup (@$dups) {
				if (!grep{$node eq $_} $dup->nodes) {
					push @new_dups, $dup;
				}
			}
			$dups =\@ new_dups;
		}
	}
	return 1;

	my ($self, $edge) =@_;
	if ($edge) {
		if (!$edge->isa('Bio::Graph::Edge')) {
			$self->throw ("I need a Bio::Graph::Edge object , not a [". ref($edge). "] object.");
		}
		if (!exists($self->{'_redundant_edges'})) {
			$self->{'_redundant_edges'} = [];
		}
		## add edge to list if not already listed
		if (!grep{$_->object_id eq $edge->object_id} @{$self->{'_redundant_edges'}}){
			push @{$self->{'_redundant_edges'}}, $edge;
		}
	}
	else {
		if (exists ($self->{'_redundant_edges'})){
			return @{$self->{'_redundant_edges'}};
		}
		else{
			
		}
	}

	my $self = shift;
	return $self->redundant_edge(shift);

my ($self, @args) = @_;
  my @dups = $self->redundant_edge(); 
	## if no args remove all 
	if (!@args) {
		$self->{'_redundant_edges'} = [];
		}
	else {
		while (my $node = shift @args) {
			my @new_dups;
			for my $dup (@dups) {
				if (!grep{$node eq $_} $dup->nodes) {
					push @new_dups, $dup;
				}
			}
			$self->{'_redundant_edges'} =\@ new_dups;
		}
	}
	return 1;

	my  ($self, $val)  = @_;
	my $n = $self->_check_args($val);
	$self->throw("[$val] is an incorrect parameter, not presnt in the graph")
		unless defined($n);
	my @n = $self->neighbors($n);
	my $n_count = scalar @n;
	my $c = 0;

	## calculate cc if we can
	if ($n_count >= 2){
		for (my $i = 0; $i <= $#n; $i++ ) {
			for (my $j = $i+1; $j <= $#n; $j++) {
				if ($self->has_edge($n[$i], $n[$j])){
					$c++;
				}
			}
		}
		$c = 2 * $c / ($n_count *($n_count - 1));
		return $c; # can be 0 if unconnected. 
	}else{
		return -1; # if value is not calculable
	}

	my $self = shift @_;
	if (!@_) {
		$self->warn("You have to specify a node");
		return;
		}
	my $edges     = $self->_edges;
	my $ns = $self->_neighbors;
	my $dups      = $self->_dup_edges;
	my $nodes     = $self->_nodes;
	while (my $val = shift @_ ) {

		## check argument
		my $node = $self->_check_args($val);
		$self->throw("[$val] is an incorrect parameter, not present in the graph")
				unless defined($node);

		##1. remove dup edges and redundant edges containing the node ##
		$self->remove_dup_edges($node);
		$self->remove_redundant_edges($node);

		##2. remove node from interactor's neighbours
		my @ns = $self->neighbors($node);
		for my $n (@ns) {
			my @otherns    = $self->neighbors($n); #get neighbors of neighbors 
			my @new_others = ();
			##look for node in neighbor's neighbors
			@new_others    = grep{$node ne $_} @otherns;
			$ns->{$n}   =\@ new_others;
		}

		##3. Delete node from neighbour hash
		delete $ns->{$node};

		##4. Now remove edges involving node
		for my $k (keys %$edges) {
			##access via internal hash rather than by object. 
			if ($edges->{$k}->[0] eq $node ||
			   		$edges->{$k}->[1] eq $node){
                ## delete edge from look up hash
                my $edge_id = $edges->{$k}->object_id();
                delete $self->{'_edge_id_map'}{$edge_id};
				delete($edges->{$k});
			}
		}

		##5. Now remove node itself;
		delete $nodes->{$node}{'_node_id'};
		delete $nodes->{$node};

		##6. now remove aliases from look up hash so it can no longer be accessed.
		## is this wise? or shall we keep the sequence object available??
	}
	return 1;

 my $self = shift;
 my $neighbours = $self->_neighbors;
 my $nodes      = $self->_nodes;
 my $uc_nodes   = [];
 for my $n (keys %$neighbours) {
	 if (@{$neighbours->{$n}} == 0){ 
		 push @$uc_nodes, $nodes->{$n};
	 }
 }
 wantarray?@$uc_nodes:$uc_nodes;

 my $self      = shift;
 ## see if results are cahced already
 $self->{'_artic_points'} ||= '';
 return $self->{'_artic_points'} if $self->{'_artic_points'};

## else calculate...
 $self->debug( "doing subgraphs\n");
 my @subgraphs = $self->components();
 
 my %rts;

 for my $sg (@subgraphs) {
     my $all_nodes = $sg->_nodes;
     $self->debug( "in subgraph - size". scalar (keys %$all_nodes) . "\n");
     ##ignore isolated vertices
     next if scalar keys %$all_nodes <= 2;
     my $neighbors = $sg->_neighbors;

     ## find most connected - will be artic point if has >2 neighbors.
     ## use this to initiate DFS
     my ($c, $id);
     my $max = 0;
     for my $n (keys %$neighbors) {
	 my $c = scalar @{$neighbors->{$n}};#
	 ($max, $id) = ($c, $n) if  $c > $max;#
     }

     my $t      = $sg->node_traversal($all_nodes->{$id},'d');
     my @nodes  = $t->get_all();
     $id = 0;
     #assign node ids
     for my $n(@nodes) {
	 $n->{'_node_id'} = $id;	
	 $id++;
     }

     ## cycle through each node 
     for (my $i       = $#nodes; $i >= 0; $i--) {

	 ## initiate minimumn to node_id
	 my $curr_min = $all_nodes->{$nodes[$i]}{'_node_id'};
	 #print STDERR "currmin - $curr_min, i = $i\n";
	 ## cycle through neighbors, reset minumum if required
	 my $nbors    = $neighbors->{$nodes[$i]};
	 for my $nbor (@$nbors) {	
	     my $nbor_id = $all_nodes->{$nbor}{'_node_id'};

	     ## if is back edge ##
	     if ($nbor_id < $i) {
		 $curr_min  = $nbor_id if $nbor_id < $curr_min ;
	     }

	     ## else is tree edge
	     elsif($nbor_id > $i) {
		 my $wlow   = $all_nodes->{$nbor}{'_wlow'};
		 $curr_min  = $wlow if $wlow < $curr_min;
	     }
	 }#next neighbor

	 ## now we know the minimum, save. 
	 $all_nodes->{$nodes[$i]}{'_wlow'} = $curr_min;

	 ## now get tree nodes and test condition
	 my @treenodes = grep{$all_nodes->{$_}{'_node_id'} > $i}@$nbors;
	 for my $tn (@treenodes) {
	     if(($all_nodes->{$tn}{'_wlow'} >= $i && $i != 0) ||
		($i == 0  && scalar @{$neighbors->{$nodes[0]}} > 1) ){
		 $rts{$nodes[$i]} = $nodes[$i] unless exists $rts{$nodes[$i]};
	     }
	 }

     }#next node
 }#next sg
## cache results and return
$self->{'_artic_points'} =   [values %rts]; ## 
return $self->{'_artic_points'};

	my ($self, $val) = @_;
	my $node = $self->_check_args($val);
 
	## this uses a cached value so it does not have to recalculate each time..
	my $artic_pt_ref = $self->articulation_points();
	my $acc = $node->accession_number;
	if (grep{$_->accession_number eq $acc} @$artic_pt_ref ){
		return 1;
   }
	else {
		return 0;
   }

	my $self = shift;
	my @refs;
	while (my $id = shift@_) {
		push @refs, $self->{'_id_map'}{$id};
	}
	return @refs;

## used to check a parameter is a valid node or a text identifier
	my ($self, $val) = @_;
	my $n;
	if (!$val ) {
		$self->throw( "I need a node that's a Bio::AnnotatableI and Bio::IdentifiableI");
		}

	## if param is text try to get sequence object..
	if (!ref($val)){
		 $n = $self->nodes_by_id($val);
		if(!defined($n)) {
			$self->throw ("Cannnot find node given by the id [$val]");
			}
	}
	# if reference should be a NodeI implementing object.
    elsif (!$val->isa('Bio::AnnotatableI') || !$val->isa('Bio::IdentifiableI')) {
		$self->throw( "I need a node that's a Bio::AnnotatableI and Bio::IdentifiableI ,not a [". ref($val) . "].");
		}

	## is a seq obj
	else {$n = $val};
	return $n; #n is either a node or undef

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

  http://bugzilla.open-bio.org/

 Richard Adams - this module, Graph::IO modules.

 Email richard.adams@ed.ac.uk

 Nat Goodman - SimpleGraph.pm, and all underlying graph algorithms.