# barabasi.game

##### Generate scale-free graphs according to the Barabasi-Albert model

The BA-model is a very simple stochastic algorithm for building a graph.

- Keywords
- graphs

##### Usage

```
barabasi.game(n, power = 1, m = NULL, out.dist = NULL, out.seq = NULL,
out.pref = FALSE, zero.appeal = 1, directed = TRUE, time.window = NULL)
```

##### Arguments

- n
- Number of vertices.
- power
- The power of the preferential attachment, the default is one, ie. linear preferential attachment.
- m
- Numeric constant, the number of edges to add in each time
step This argument is only used if both
`out.dist`

and`out.seq`

are omitted or NULL. - out.dist
- Numeric vector, the distribution of the number of
edges to add in each time step. This argument is only used if the
`out.seq`

argument is omitted or NULL. - out.seq
- Numeric vector giving the number of edges to add in each time step. Its first element is ignored as no edges are added in the first time step.
- out.pref
- Logical, if true the total degree is used for calculating the citation probability, otherwise the in-degree is used.
- zero.appeal
- The
attractiveness of the vertices with no adjacent edges. See details below. - directed
- Whether to create a directed graph.
- time.window
- Integer constant, if given only edges added in the
previous
`time.window`

time steps are counted as the basis of preferential attachment.

##### Details

This is a simple stochastic algorithm to generate a graph. It is a discrete time step model and in each time step a single vertex is added.

We start with a single vertex and no edges in the first time
step. Then we add one vertex in each time step and the new vertex
initiates some edges to old vertices. The probability that an old vertex
is chosen is given by
$$P[i] \sim k_i^\alpha+a$$
where $k_i$ is the in-degree of vertex $i$ in the
current time step (more precisely the number of adjacent edges of
$i$ which were not initiated by $i$ itself) and
$\alpha$ and $a$ are parameters given by the
`power`

and `zero.appeal`

arguments.

The number of edges initiated in a time step is given by the `m`

,
`out.dist`

and `out.seq`

arguments. If `out.seq`

is
given and not NULL then it gives the number of edges to add in a
vector, the first element is ignored, the second is the number of
edges to add in the second time step and so on. If `out.seq`

is
not given or null and `out.dist`

is given and not NULL then it is
used as a discrete distribution to generate the number of edges in
each time step. Its first element is the probability that no edges
will be added, the second is the probability that one edge is added,
etc. (`out.dist`

does not need to sum up to one, it normalized
automatically.) `out.dist`

should contain non-negative numbers
and at east one element should be positive.

If both `out.seq`

and `out.dist`

are omitted or NULL then
`m`

will be used, it should be a positive integer constant and
`m`

edges will be added in each time step.

`barabasi.game`

generates a directed graph by default, set
`directed`

to `FALSE`

to generate an undirected graph. Note
that even if an undirected graph is generated $k_i$ denotes
the number of adjacent edges not initiated by the vertex itself and
not the total (in- + out-) degree of the vertex, unless the
`out.pref`

argument is set to `TRUE`

.

If the `time.window`

argument is not NULL then $k_i$ is
the number of adjacent edges of $i$ added in the previous
`time.window`

time steps.

Note that `barabasi.game`

might generate graphs with multiple
edges.

##### Value

- A graph object.

##### References

Barabasi, A.-L. and Albert R. 1999. Emergence of scaling
in random networks *Science*, 286 509--512.

##### See Also

##### Examples

```
g <- barabasi.game(10000)
degree.distribution(g)
```

*Documentation reproduced from package igraph, version 0.4.4, License: GPL version 2 or later (June, 1991)*