Clair::Network::Sample

SampleBase


SummaryPackage variablesSynopsisDescriptionGeneral documentationMethods

SummaryTop
Clair::Network::Sample::SampleBase - Abstract class for network sampling

Package variablesTop
No package variables defined.

Included modulesTop
Carp
Math::Random

SynopsisTop
Clair::Network::Sample::SampleBase should not be called directly, but instead
inherited from a concrete SampleBase class.

DescriptionTop
This object is for sampling networks.

MethodsTop
get_old_netDescriptionCode
get_random_edgesNo descriptionCode
get_random_nodesNo descriptionCode
get_unique_integersDescriptionCode
newNo descriptionCode
sampleDescriptionCode

Methods description


get_old_netcode    nextTop
Return the original network

get_unique_integerscodeprevnextTop
Return a list of random integers from a uniform distribution with no
duplicates.

samplecodeprevnextTop
Return a new random network sampled from the original network

Methods code


get_old_netdescriptionprevnextTop
sub get_old_net {
  my $self = shift;

  return $self->{oldnet};
}

get_random_edgesdescriptionprevnextTop
sub get_random_edges {
  my $self = shift;
  my $num_edges = shift;

  my %parameters = @_;

  my @edges = ();
  # Allow choosing from a limited set of edges
  if (defined $parameters{subset})  {
    my $s = $parameters{subset};
    @edges = @{$s};
  } else {
    @edges = $self->{oldnet}->get_edges();
  }

  if (not defined $num_edges) {
    $num_edges = 1;
  }

  if ($num_edges > 2147483561) {
    die "Network too large\n";
  }

  if ($num_edges > scalar(@edges)) {
#    print STDERR "Warning, wanted $num_edges edges but only returning " .
#      scalar(@edges) . "\n";
    $num_edges = scalar(@edges);
  }


  my $max = scalar @edges;
  my @sample_edges = $self->get_unique_integers($num_edges, 0, $max - 1);
  map {$_ = $edges[$_]} @sample_edges;

  return @sample_edges;
}

get_random_nodesdescriptionprevnextTop
sub get_random_nodes {
  my $self = shift;
  my $num_nodes = shift;

  my %parameters = @_;

  my @vertices = ();
  # Allow choosing from a limited set of vertices
  if (defined $parameters{subset})  {
    my $s = $parameters{subset};
    @vertices = @{$s};
  } else {
    @vertices = $self->{oldnet}->get_vertices();
  }

  if (not defined $num_nodes) {
    $num_nodes = 1;
  }

  if ($num_nodes > 2147483561) {
    die "Network too large\n";
  }

  if ($num_nodes > scalar(@vertices)) {
#    print STDERR "Warning, wanted $num_nodes vertices but only returning " .
#      scalar(@vertices) . "\n";
    $num_nodes = scalar(@vertices);
  }

  my $max = scalar @vertices;
  my @sample_vertices = $self->get_unique_integers($num_nodes, 0, $max - 1);
  map {$_ = $vertices[$_]} @sample_vertices;

  return @sample_vertices;
}

get_unique_integersdescriptionprevnextTop
sub get_unique_integers {
  my $self = shift;
  my $num = shift;
  my $low = shift;
  my $high = shift;

  my %hash = ();

  my $i = 0;
  while ($i < $num) {
    my $x = random_uniform_integer(1, $low, $high);
    if (not defined $hash{$x}) {
      $hash{$x} = 1;
      $i++;
    }
  }

  return keys %hash;
}

newdescriptionprevnextTop
sub new {
  my $class = shift;
  my $net = shift;

  my $self = {};

  if (defined $net) {
    $self->{oldnet} = $net;
  }

  bless($self, $class);

  return $self;
}

sampledescriptionprevnextTop
sub sample {
  croak "dist_function has not been implemented\n";
  return;
}

General documentation


No general documentation available.