# Read in from file
  my $graphio = Bio::Network::IO->new(-file   => 'human.xml',
                                      -format => 'psi25');
  my $graph = $graphio->next_network();

  my @edges = $gr->edges;

  for my $edge (@edges) {
    for my $node ($edge->[0],$edge->[1]) {
      my @proteins = $node->proteins;
      for my $protein (@proteins) {
        print $protein->display_id," ";
      }
    }
  }

  $ecount = $network->edges

  $icount = $network->interactions

	my ($self,@ids) = @_;
	$self->throw("I need an identifier!") unless (@ids);
	my @interx;
	for my $id (@ids) {
	   my @temp;
		push @temp, $self->[$GRAPH_ARRAY_INDEX]->{'_interx_id_map'}->{$id};
		$self->warn("More than 1 Interaction retrieved using id $id") if ($#temp > 0);
		push @interx,@temp;
	}
	scalar @interx == 1 ? return $interx[0] : return @interx;

	my $self = shift;
	my @ids = @_;
	my @nodes  = $self->_ids(@ids);
	unless (@nodes) {
		my $str = join " ",@ids;
		$self->warn("No nodes retrieved using these ids: $str");
		return 0;
	}
	if ($#nodes > 0) {
		my $str = join " ",@ids;
		#$self->warn("Returning >1 node retrieved using these ids: $str");
		return @nodes;
	}
	$nodes[0];

	my ($self,@nodes) = @_;

	$self->throw("The get_interactions method needs 2 nodes, not ". 
					 scalar @nodes . " nodes") if ($#nodes != 1);

	for my $node (@nodes) {
		$self->throw("Node must be a Bio::Network::Node object, not a [". ref($node) . "].") 
		  unless ($node->isa("Bio::Network::Node"));
	}

	my $interactions = $self->get_edge_attributes(@nodes);
	%$interactions;

	my ($g,$id,$interx) = @_;

	$g->throw("Node must be a Bio::Network::Interaction object, not a ["
		   . ref($interx) . "]." ) unless ($interx->isa("Bio::Network::Interaction"));

	$g->[$GRAPH_ARRAY_INDEX]->{'_interx_id_map'}->{$id} = $interx if $id;

	my ($g,$id,$node) = @_;

	$g->throw("Node must be a Bio::Network::Node object, not a ["
			 . ref($node) . "]." ) unless ($node->isa("Bio::Network::Node"));
	$g->throw("Node $node does not exist, cannot add edge")
	  unless ($g->has_node($node));

	if (ref $id eq "ARRAY") {
		my @ids = @$id;
		for my $id (@ids) {
			next unless $id;
			$g->[$GRAPH_ARRAY_INDEX]->{'_id_map'}->{$id} = $node;
		}
	} else {
		$g->[$GRAPH_ARRAY_INDEX]->{'_id_map'}->{$id} = $node if $id;
	}

	my ($graph1, $graph2) = @_;
	my $class = ref($graph1);
	$graph1->throw("add_interaction_from() needs a ". $class . " object, not a [".
					 ref($graph2). "] object") unless ($graph2->isa($class));
	my (%common_ids,%common_nodes);
	
	# get identifiers found in both graphs
	for my $id ( (keys %{$graph1->[$GRAPH_ARRAY_INDEX]->{'_id_map'}}),
					 (keys %{$graph2->[$GRAPH_ARRAY_INDEX]->{'_id_map'}}) ) {
		$common_ids{$id}++;
	}
	# get nodes corresponding to identifiers found in both graphs
	for my $id (keys %common_ids) {
		if ($common_ids{$id} == 2) {
			if (defined $graph1->[$GRAPH_ARRAY_INDEX]->{'_id_map'}{$id} &&
				 defined $graph2->[$GRAPH_ARRAY_INDEX]->{'_id_map'}{$id} ) {
				$common_nodes{$graph2->[$GRAPH_ARRAY_INDEX]->{'_id_map'}{$id}} =
				  $graph1->[$GRAPH_ARRAY_INDEX]->{'_id_map'}{$id};
			}
		}
	}
	# get all the edges in $graph2, if both nodes for a given edge are in
	# $graph1 then interactions can be copied, unless it's already in $graph1
	my @edges = $graph2->edges;
	for my $edgeref (@edges) {
		if (defined $common_nodes{$edgeref->[0]} &&
			 defined $common_nodes{$edgeref->[1]} ) {
			my $attref2 = $graph2->get_edge_attributes($edgeref->[0],$edgeref->[1]);	# nothing		
			if ($graph1->has_edge($common_nodes{$edgeref->[0]},
										 $common_nodes{$edgeref->[1]}) ) {
				# interactions for the given pair are in both graphs...
				my $attref1 = $graph1->get_edge_attributes($common_nodes{$edgeref->[0]},
															          $common_nodes{$edgeref->[1]});
				for my $interxid (keys %$attref2) {
				#...so check to see if their primary id's are the same or not
					unless (defined $attref1->{$interxid}) {
					$graph1->add_interaction(-nodes => [($common_nodes{$edgeref->[0]},
																	 $common_nodes{$edgeref->[1]})],
													 -interaction => $attref2->{$interxid});						
					}
				}
			} else {
				# a pair of nodes in $graph2 interact but don't interact in $graph1
				for my $interxid (keys %$attref2) {
					$graph1->add_interaction(-nodes => [($common_nodes{$edgeref->[0]},
																	 $common_nodes{$edgeref->[1]})],
													 -interaction => $attref2->{$interxid});
				}
			}	
		}
	}

	my ($self,@nodes) = @_;
	my $class = ref($self);
	my $subgraph = new $class;
	my @pairs = ();

	$subgraph->add_node(@nodes);

	# retrieve and add interacting pairs of nodes and Interactions
	@pairs = $self->_all_pairs(@nodes) if ($#nodes > 0);
	for my $pair (@pairs) {
		if ( $self->has_edge(@$pair) ) {
			my $ref = $self->get_edge_attributes(@$pair);
			for my $id (keys %$ref) {
				$subgraph->add_interaction(-nodes       => $pair,
													-interaction => $ref->{$id} );
			}
		}
	}
	# add isolated nodes that weren't found as interacting pairs, above
	for my $node (@nodes) {
		$subgraph->add_node($node) unless ($subgraph->has_node($node))
	}
	$subgraph;

	my %ids;
	my $self = shift;
	while (my $node = shift @_ ){
		$node->throw("I need a Bio::Network::Node object, not a [" .ref($node) ."]")
		  unless ( $node->isa('Bio::Network::Node') );
		## If Bio::Seq get dbxref ids as well.
		my @proteins = $node->proteins;
		for my $protein (@proteins) {
			my $ac = $protein->annotation();	
			for my $an ($ac->get_Annotations('dblink')) {
				$ids{$an->database()} = $an->primary_id();
			}
		}
	}
	return %ids;

	my $self = shift;
   my ($interx,$nodesref) = $self->_rearrange([qw(INTERACTION NODES)],@_);
   my @nodes = @$nodesref;	
   #my $interxid = $interx->primary_id;

	$self->throw("The add_edge method needs 2 nodes, not ". scalar @nodes . 
					 " nodes") if ($#nodes != 1);

	for my $node (@nodes) {
		unless ( $node->isa("Bio::Network::Node") ) {
			if ( $node->isa("Bio::Seq") ) {
				# $self->warn("Node must be a Bio::Node object, not a [Bio::Seq]. " . 
				#				"Will make a Node object from it.");
				$node = Bio::Network::Node->new(-protein => [($node)]);
			} else {			
				$self->throw("Cannot make an interaction using a [". ref($node) . 
								 "].") 
			}
		}
   }

   $self->add_edge($nodes[0], $nodes[1]);
	$self->set_edge_attribute($nodes[0], $nodes[1], $interx->primary_id, $interx);
	$self->add_id_to_interaction($interx->primary_id, $interx);
	# Store the node names in the Interaction object
	$interx->{_nodes} = $nodesref;

	my ($self,@nodes) = @_;

	$self->throw("The add_edge method needs 2 nodes, not ". scalar @nodes . 
					 " nodes")  if ($#nodes != 1);

	for my $node (@nodes) {
		$self->throw("Node must be a Bio::Network::Node object, not a [". ref($node) . "].") 
		  unless ($node->isa("Bio::Network::Node"));
	}
	$self->SUPER::add_edge(@nodes);

	my ($self,$node) = @_;
	$self->throw("Node must be a Node object, not a ["
	 . ref($node) . "]") unless ($node->isa("Bio::Network::Node"));

	if ($self->has_node($node)) {
	#	$self->warn("Graph already has node with id " . $node->display_id 
	#					. ", will not add it.");
		return;
	} 
	$self->SUPER::add_vertex($node);

	my ($self,$node) = @_;
   $self->add_vertex($node);

	my  ($self,$node)  = @_;

	$self->throw("[$node] is an incorrect parameter, not present in the graph")
		unless defined($node);
	$self->throw("[$node] is an incorrect parameter, not present in the graph")
		unless ($node->isa("Bio::Network::Node"));	

	my @n = $self->neighbors($node);
	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,@nodes) = @_;
	my $g = $self->SUPER::delete_vertices(@nodes);
	$g;

	my $self = shift;
	my $e = $self->random_edge;
	$e;

	my $self = shift;
	my $n = $self->random_vertex;
	$n;

	my $self = shift;
	return 1 if (!$self->is_connected && !$self->is_cyclic);
	return "";

	my $self = shift;
	return 1 if ($self->is_connected && !$self->is_cyclic);
	return "";

	my $self = shift;
	my @nodes = $self->vertices;
	return 1 if (scalar @nodes == 0);
	return "";

	my $self = shift;
	return $self->SUPER::isolated_vertices;

 	my $self = shift;
 	my @nodes = $self->SUPER::articulation_points; 
 	wantarray ? @nodes : scalar @nodes;

	my ($self,$node) = @_;

	$self->throw("$node is an incorrect parameter, not present in the graph")
		unless ( $node->isa("Bio::Network::Node") );
	
 	my @artic_points = $self->articulation_points();
 	grep /$node/,@artic_points ? return 1 : return 0;

    my $self = shift;
	 if (wantarray) {
		 my @ns = $self->vertices;
		 return @ns;
	 } else {
		 return scalar $self->vertices;		 
	 }

    my ($self,$node) = @_;
	 return $self->has_vertex($node);

	my $self = shift;
	if (wantarray) {
		my @interx;
		for my $id (keys %{$self->[$GRAPH_ARRAY_INDEX]->{'_interx_id_map'}}) {
			push @interx, $self->[$GRAPH_ARRAY_INDEX]->{'_interx_id_map'}->{$id};
		}
		return @interx;
	} else {
		return scalar keys %{$self->[$GRAPH_ARRAY_INDEX]->{'_interx_id_map'}};
	}

	my $self = shift;
	my @ids = @_;
	return $self->get_nodes_by_id(@ids);

	my $self = shift;
	return scalar $self->edges;

	my ($self,$node) = @_;
	return scalar $self->SUPER::neighbors($node);

	my $self = shift;
	return scalar $self->vertices;

	my $self = shift;
	return $self->connected_components;

	my ($self,@arr) = @_;
	my @pairs = ();
	$self->throw("Must pass an array with at least 2 elements to _all_pairs()") 
	  unless ($#arr > 0);
	for (my $x = 0 ; $x < $#arr ; $x++) {
		for (my $y = $x ; $y < $#arr ; $y++ ) {
			push @pairs, [($arr[$x],$arr[($y + 1)])];
		}
	}
	@pairs;

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

1;

__END__

  # Get a node (represented by a sequence object) from the graph.
  my $node = $graph->get_nodes_by_id('UniProt:P12345');

  # A node that's a protein can be treated just like a Sequence object
  print $node->seq;

  # Remove a node by specifying its identifier
  $graph->remove_nodes($graph->get_nodes_by_id('UniProt:P12345'));

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

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

  # Annotate your sequences with interaction info
  my @seq_objects = ($seq1, $seq2, $seq3);
  for my $seq (@seq_objects) {
    if ( $graph->get_nodes_by_id($seq->accession_number) ) {
       my $node = $graph->get_nodes_by_id( $seq->accession_number);
       my @neighbors = $graph->neighbors($node);
       for my $n (@neighbors) {
          my $ft = Bio::SeqFeature::Generic->new(
                    -primary_tag => 'Interactor',
                    -tag         => { 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->neighbors($node) > 10) {
       push @hubs, $node;
    }
  }
  print "the following proteins have > 10 interactors:\n";
  print join "\n", map {$_->primary_id()} @hubs;

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

  # How many edges are there?
  my $ecount = $graph->edges;

  # Get all the paired nodes, or edges, in the graph as an array
  my @edges = $graph->edges

  # How many interactions are there?
  my $icount = $graph->interactions;

  # Retrieve all interactions
  my @interx = $graph->interactions;

  # Get interactions above a threshold confidence score
  for my $interx (@interx) {
	 if ($interx->weight > 0.6) {
		 print $interx->primary_id, "\t", $interx->weight, "\n";
	 }
  }

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

  # Get connected sub-graphs
  my @graphs = $graph->connected_components();

  # Copy interactions from one graph to another
  $graph1->add_interactions_from($graph2);

  <interaction id>  <protein id 1>  <protein id 2>  <score>

  my $io = Bio::Root::IO->new(-file => 'mydata');
  my $graph = Bio::Network::ProteinNet->new(refvertexed => 1);

  while (my $l = $io->_readline() ) {
     my ($id, $nid1, $nid2, $sc) = split /\s+/, $l;

     my $prot1 = Bio::Seq->new(-accession_number => $nid1);
     my $prot2 = Bio::Seq->new(-accession_number => $nid2);

     # create new Interaction object based on an id and weight
     my $interaction = Bio::Network::Interaction->new(-id   => $id,
                                                    -weight => $sc );
     $graph->add_interaction(-nodes => [($prot1,$prot2)]),
                             -interaction => $interaction );
  }

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

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