Generate a new Erdos-Renyi random graph, returning a new
  Clair::Network object

  my $self = shift;
  my $n = shift;
  my $p = shift;

  my %parameters = @_;

  my $type = "";
  if (defined $parameters{type}) {
    $type = $parameters{type};
  } else {
    $type = $self->{type};
  }

  my $directed = 1;
  if (defined $parameters{directed}) {
    $directed = $parameters{directed};
  }

  my $weights = 0;
  if (defined $parameters{weights}) {
    $weights = $parameters{weights};
  }

  if ($type eq "") {
    croak "Must set Erdos-Renyi graph type before calling generate\n";
    return;
  }

  my $net = Clair::Network->new(directed => $directed);

  # Add nodes
  for(my $i = 0; $i < $n; $i++) {
    $net->add_node($i);
  }

  # Add edges
  if ($type eq "gnm") {
    # set number of edges
    my $i = 0;
    while ($i < $p) {
      my $v1 = $self->get_random_uniform_integer(1, 0, $n - 1);
      my $v2 = $self->get_random_uniform_integer(1, 0, $n - 1);

      # No self-loops (perhaps later?)
      # No multi-edges
      if (($v1 ne $v2) and (not $net->has_edge($v1, $v2))) {
        $net->add_edge($v1, $v2);
        $i++;
      }
    }
  } else {
    # random number of edges
    for(my $i = 0; $i < $n; $i++) {
      for(my $j = 0; $j < $n; $j++) {
        if (($i != $j) and ($self->get_random_uniform() < $p)) {
          $net->add_edge($i, $j);
          if ($weights) {
            my $w = $self->get_random_uniform();
            $net->set_edge_weight($i, $j, $w);
          }
        }
      }
    }
  }

  return $net;

  my $class = shift;

  # Call superclass constructor
  my $self = $class->SUPER::new();

  $self->{type} = "";

  return $self;

  my $self = shift;
  my $type = shift;

  if (($type eq "gnp") or ($type eq "gnm")) {
    $self->{type} = $type;
  } else {
    croak "Unsupported Erdos-Renyi graph type, must be gnp or gnm\n";
  }