java.lang.Object
- com.jgalgo.gen.BarabasiAlbertGraphGenerator<V,E>

Type Parameters:

V - the vertices type

E - the edges type

All Implemented Interfaces:

GraphGenerator<V,E>
```
public class BarabasiAlbertGraphGenerator<V,E>
extends Object
implements GraphGenerator<V,E>
```
Generates a Barabási–Albert graph.
A Barabási–Albert graph is a random graph with a power law degree distribution, which is a good model for many real networks. The graph begins with an initial clique of size initCliqueSize, and then adds vertices one by one, each with edgesPerStep edges that are attached to existing vertices. The probability that a new vertex is connected to vertex \(v\) is proportional to the degree of \(v\) divided by the sum of degrees of all vertices in the graph.
By default the initial clique size is \(20\) and the number of edges added each step is \(10\). The generated graph(s) may be directed or undirected, and by default it is undirected. Self edges are never created.
In the following example, an undirected graph with \(10\) vertices is generated. The initial clique size is \(3\), and at each step \(4\) edges are added. The seed is set to some fixed value to get deterministic behavior.
```
 
 Graph<Integer, Integer> g = new BarabasiAlbertGraphGenerator<>(IntGraphFactory.undirected())
 		.directed(false)
 		.vertices(10)
 		.edges(IdBuilderInt.defaultBuilder())
 		.initialCliqueSize(3)
 		.edgesPerStep(4)
 		.seed(0x7d0c16fa09e05751L)
 		.generate();
  
```
For deterministic behavior, set the seed of the generator using seed(long).
Based on 'Emergence of scaling in random networks' by Albert-László Barabási and Réka Albert.
Author:

Barak Ugav

Constructor Summary

Constructors
Constructor	Description
`BarabasiAlbertGraphGenerator()`	Create a new Barabasi-Albert graph generator that will use the default graph factory.
`BarabasiAlbertGraphGenerator(GraphFactory<V,E> factory)`	Create a new Barabasi-Albert graph generator that will use the given graph factory.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`BarabasiAlbertGraphGenerator<V,E>`	`directed(boolean directed)`	Determine if the generated graph(s) is directed or undirected.
`BarabasiAlbertGraphGenerator<V,E>`	`edges(IdBuilder<E> edgeBuilder)`	Set the edge builder that will be used to generate edges.
`BarabasiAlbertGraphGenerator<V,E>`	`edgesPerStep(int edgesPerStep)`	Set the number of edges added each step when generated graph(s).
`GraphBuilder<V,E>`	`generateIntoBuilder()`	Generates a graph into a builder.
`GraphFactory<V,E>`	`graphFactory()`	Get the graph factory that will be used to create the generated graph(s).
`BarabasiAlbertGraphGenerator<V,E>`	`initialCliqueSize(int initCliqueSize)`	Set the initial clique size of the generated graph(s).
`BarabasiAlbertGraphGenerator<V,E>`	`seed(long seed)`	Set the seed of the random number generator used to generate the graph(s).
`BarabasiAlbertGraphGenerator<V,E>`	`vertices(int verticesNum)`	Set the number of vertices that will be generated for each graph.
`BarabasiAlbertGraphGenerator<V,E>`	`vertices(int verticesNum, IdBuilder<V> vertexBuilder)`	Set the number of vertices that will be generated for each graph, and the vertex builder that will be used to generate them.
`BarabasiAlbertGraphGenerator<V,E>`	`vertices(Collection<? extends V> vertices)`	Set the vertices set of the generated graph(s).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.jgalgo.gen.GraphGenerator
generate, generateMutable

- Constructor Detail
  - BarabasiAlbertGraphGenerator
```
public BarabasiAlbertGraphGenerator()
```
    Create a new Barabasi-Albert graph generator that will use the default graph factory.
    The default graph factory does not have vertex builder, so if only the number of vertices is set using vertices(int), the vertex builder must be set explicitly using graphFactory().setVertexBuilder(...). Same holds for edges, for which the number of them is determine by edgesPerStep(int) and initialCliqueSize(int). Alternatively, the methods vertices(int, IdBuilder) and edges(IdBuilder) can be used to set the number of vertices and provide a vertex/edge builder that will override the (maybe non existing) vertex/edge builder of the graph factory. The vertex set can also be set explicitly using vertices(Collection).
  - BarabasiAlbertGraphGenerator
```
public BarabasiAlbertGraphGenerator(GraphFactory<V,E> factory)
```
    Create a new Barabasi-Albert graph generator that will use the given graph factory.
    If the factory has a vertex builder it will be used to generate the vertices of the generated graph(s) if only the number of vertices is set using vertices(int). If the factory has an edge builder it will be used to generate the edges of the generated graph(s) if it will not be overridden by edges(IdBuilder).
    During the graph(s) generation, the method GraphFactory.setDirected(boolean) of the given factory will be called to align the created graph with the generator configuration. Parallel edges can always be generated by this generator, therefore also GraphFactory.allowParallelEdges() will be called.
    To generate int graphs, pass an instance of IntGraphFactory to this constructor.
    
    Parameters:
    
    factory - the graph factory that will be used to create the generated graph(s)
- Method Detail
  - graphFactory
```
public GraphFactory<V,E> graphFactory()
```
    Get the graph factory that will be used to create the generated graph(s).
    It's possible to customize the factory before generating the graph(s), for example by using GraphFactory.addHint(GraphFactory.Hint) to optimize the generated graph(s) for a specific algorithm. If the factory has a vertex builder it will be used to generate the vertices of the generated graph(s) if only the number of vertices is set using vertices(int). If the factory has an edge builder it will be used to generate the edges of the generated graph(s) if it will not be overridden by edges(IdBuilder).
    During the graph(s) generation, the method GraphFactory.setDirected(boolean) of the given factory will be called to align the created graph with the generator configuration. Parallel edges can always be generated by this generator, therefore also GraphFactory.allowParallelEdges() will be called.
    
    Returns:
    
    the graph factory that will be used to create the generated graph(s)
  - vertices
```
public BarabasiAlbertGraphGenerator<V,E> vertices(Collection<? extends V> vertices)
```
    Set the vertices set of the generated graph(s).
    If the generator is used to generate multiple graphs, the same vertex set will be used for all of them. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).
    
    Parameters:
    
    vertices - the vertices set
    
    Returns:
    
    this generator
  - vertices
```
public BarabasiAlbertGraphGenerator<V,E> vertices(int verticesNum)
```
    Set the number of vertices that will be generated for each graph.
    The vertices will be generated using the vertex builder of the graph factory, see GraphFactory.setVertexBuilder(IdBuilder). The default graph factory does not have a vertex builder, so it must be set explicitly, or IntGraphFactory, which does have such builder, should be passed in the constructor. Another alternative is to use vertices(int, IdBuilder) which set the number of vertices and provide a vertex builder that will override the (maybe non existing) vertex builder of the graph factory. The generation will happen independently for each graph generated. If there is no vertex builder, an exception will be thrown during generation. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).
    
    Parameters:
    
    verticesNum - the number of vertices that will be generated for each graph
    
    Returns:
    
    this generator
    
    Throws:
    
    IllegalArgumentException - if verticesNum is negative
  - vertices
```
public BarabasiAlbertGraphGenerator<V,E> vertices(int verticesNum,
                                                        IdBuilder<V> vertexBuilder)
```
    Set the number of vertices that will be generated for each graph, and the vertex builder that will be used to generate them.
    The vertices will be generated using the provided vertex builder, and the vertex generator provided by the graph factory (if exists) will be ignored. The generation will happen independently for each graph generated. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).
    
    Parameters:
    
    verticesNum - the number of vertices that will be generated for each graph
    
    vertexBuilder - the vertex builder, or null to use the vertex builder of the graph factory
    
    Returns:
    
    this generator
    
    Throws:
    
    IllegalArgumentException - if verticesNum is negative
  - edges
```
public BarabasiAlbertGraphGenerator<V,E> edges(IdBuilder<E> edgeBuilder)
```
    Set the edge builder that will be used to generate edges.
    The edges will be generated using the provided edge builder, and the edge generator provided by the graph factory (if exists) will be ignored. The generation will happen independently for each graph generated. If this method is not called, or called with a null argument, the edge builder of the graph factory will be used. If the graph factory does not have an edge builder, an exception will be thrown during generation.
    
    Parameters:
    
    edgeBuilder - the edge builder, or null to use the edge builder of the graph factory
    
    Returns:
    
    this generator
  - initialCliqueSize
```
public BarabasiAlbertGraphGenerator<V,E> initialCliqueSize(int initCliqueSize)
```
    Set the initial clique size of the generated graph(s).
    The initial clique is a complete graph of size initCliqueSize. After the initial clique is created, the generator adds vertices one by one, each with edgesPerStep edges that are attached to existing vertices. The probability that a new vertex is connected to vertex \(v\) is proportional to the degree of \(v\) divided by the sum of degrees of all vertices in the graph.
    By default, the initial clique size is \(20\). The initial clique size must not be greater than the number of vertices, which is validated during the graph generation.
    
    Parameters:
    
    initCliqueSize - the initial clique size
    
    Returns:
    
    this generator
  - edgesPerStep
```
public BarabasiAlbertGraphGenerator<V,E> edgesPerStep(int edgesPerStep)
```
    Set the number of edges added each step when generated graph(s).
    The initial clique is a complete graph of size initialCliqueSize(int). After the initial clique is created, the generator adds vertices one by one, each with edgesPerStep edges that are attached to existing vertices. The probability that a new vertex is connected to vertex \(v\) is proportional to the degree of \(v\) divided by the sum of degrees of all vertices in the graph.
    By default, the number of edges added per step is \(10\). The number of edges per step must not be greater than the initial clique size provided by initialCliqueSize(int).
    
    Parameters:
    
    edgesPerStep - the number of edges added to each vertex added to the graph after the initial clique
    
    Returns:
    
    this generator
  - directed
```
public BarabasiAlbertGraphGenerator<V,E> directed(boolean directed)
```
    Determine if the generated graph(s) is directed or undirected.
    By default, the generated graph(s) is undirected.
    
    Parameters:
    
    directed - true if the generated graph(s) will be directed, false if undirected
    
    Returns:
    
    this generator
  - seed
```
public BarabasiAlbertGraphGenerator<V,E> seed(long seed)
```
    Set the seed of the random number generator used to generate the graph(s).
    By default, a random seed is used. For deterministic behavior, set the seed of the generator.
    
    Parameters:
    
    seed - the seed of the random number generator
    
    Returns:
    
    this generator
  - generateIntoBuilder
```
public GraphBuilder<V,E> generateIntoBuilder()
```
    Description copied from interface: GraphGenerator
    
    Generates a graph into a builder.
    This is the a more flexible way to generate a graph. The builder can be used to generate a mutable or immutable graph, or to add additional vertices or edges on top of the generated ones.
    
    Specified by:
    
    generateIntoBuilder in interface GraphGenerator<V,E>
    
    Returns:
    
    a new graph builder populated by the generator with the generator parameters

Class BarabasiAlbertGraphGenerator<V,​E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.jgalgo.gen.GraphGenerator

Constructor Detail

BarabasiAlbertGraphGenerator

BarabasiAlbertGraphGenerator

Method Detail

graphFactory

vertices

vertices

vertices

edges

initialCliqueSize

edgesPerStep

directed

seed

generateIntoBuilder

Class BarabasiAlbertGraphGenerator<V,E>