Clair::GraphWrapper

Boost


SummaryIncluded librariesPackage variablesSynopsisDescriptionGeneral documentationMethods

SummaryTop
Clair::GraphWrapper::Boost - Concrete class for Boost graphs

Package variablesTop
No package variables defined.

Included modulesTop
Boost::Graph
Clair::GraphWrapper

InheritTop
Clair::GraphWrapper

SynopsisTop
my $graph = new Clair::GraphWrapper::Boost();
my $network = new Clair::Network(graph => $graph);

DescriptionTop
This object is a class for Boost graph objects used by the Network class.

MethodsTop
add_edgeNo descriptionCode
add_vertexNo descriptionCode
all_pairs_shortest_paths_johnsonNo descriptionCode
breadth_first_searchNo descriptionCode
connected_componentsNo descriptionCode
degreeNo descriptionCode
delete_edgeNo descriptionCode
edgesNo descriptionCode
has_edgeNo descriptionCode
in_degreeNo descriptionCode
is_directedNo descriptionCode
newNo descriptionCode
out_degreeNo descriptionCode
predecessorsNo descriptionCode
successorsNo descriptionCode
verticesNo descriptionCode

Methods description


None available.

Methods code


add_edgedescriptionprevnextTop
sub add_edge {
  my $self = shift;
  my $u = shift;
  my $v = shift;

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

add_vertexdescriptionprevnextTop
sub add_vertex {
  my $self = shift;
  my $n = shift;

  $self->{graph}->add_node($n);
}

all_pairs_shortest_paths_johnsondescriptionprevnextTop
sub all_pairs_shortest_paths_johnson {
  my $self = shift;

  return $self->{graph}->all_pairs_shortest_paths_johnson(@_);
}

breadth_first_searchdescriptionprevnextTop
sub breadth_first_search {
  my $self = shift;

  return $self->{graph}->breadth_first_search(@_);
}

connected_componentsdescriptionprevnextTop
sub connected_components {
  my $self = shift;
  my $graph = $self->{graph};

  my $c = $graph->connected_components();
#  use Data::Dumper;
#  print Dumper($c) . "\n";

  return @{$c};
}

degreedescriptionprevnextTop
sub degree {
  my $self = shift;
  my $v = shift;


  return scalar(@{$self->{graph}->neighbors($v)});
}

delete_edgedescriptionprevnextTop
sub delete_edge {
  my $self = shift;
  my $u = shift;
  my $v = shift;

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

  $graph->remove_edge($u, $v);
}

edgesdescriptionprevnextTop
sub edges {
  my $self = shift;
  my $edges = $self->{graph}->get_edges();

  return map { [$_->[0], $_->[1]] } @{$edges};
}

has_edgedescriptionprevnextTop
sub has_edge {
  my $self = shift;
  my $u = shift;
  my $v = shift;

  return $self->{graph}->has_edge($u, $v);
}

in_degreedescriptionprevnextTop
sub in_degree {
  my $self = shift;
  my $v = shift;


  return scalar(@{$self->{graph}->parents_of_directed($v)});
}

is_directeddescriptionprevnextTop
sub is_directed {
  my $self = shift;
  return $self->{directed};
}

newdescriptionprevnextTop
sub new {
  my $class = shift;
  my %parameters = @_;

  my $directed = 1;
  if ((exists $parameters{directed} and $parameters{directed} == 0) ||
      (exists $parameters{undirected} and $parameters{undirected} == 1)) {
    $directed = 0;
  }

  my $unionfind = 0;
  if (exists $parameters{unionfind} and $parameters{unionfind} == 1) {
    $unionfind = 1;
  }

  my $graph;
  if (exists $parameters{graph}) {
    # If user specified graph, use that
    $graph = $parameters{graph};
    if ($graph->is_directed()) {
      $directed = 1;
    } else {
      $directed = 0;
    }
  } else {
    # Otherwise, create a new graph object
    $graph = Boost::Graph->new(directed => $directed,
                               unionfind => $unionfind);
  }

  my $self = bless {
                    graph => $graph,
                    directed => $directed
                    }, $class;

  return $self;
}

out_degreedescriptionprevnextTop
sub out_degree {
  my $self = shift;
  my $v = shift;


  return scalar(@{$self->{graph}->children_of_directed($v)});
}

predecessorsdescriptionprevnextTop
sub predecessors {
  my $self = shift;
  my $n = shift;

  return @{$self->{graph}->parents_of_directed($n)};
}

successorsdescriptionprevnextTop
sub successors {
  my $self = shift;
  my $n = shift;

  return @{$self->{graph}->children_of_directed($n)};
}

verticesdescriptionprevnextTop
sub vertices {
  my $self = shift;
  my $vertices = $self->{graph}->get_nodes();

  return @{$vertices};
}

General documentation


No general documentation available.