Package com.jgalgo.gen

Class GnpBipartiteGraphGenerator<V,​E>

  • Type Parameters:
    V - the vertices type
    E - the edges type
    All Implemented Interfaces:
    GraphGenerator<V,​E>
    public class GnpBipartiteGraphGenerator<V,​E>
extends Object
implements GraphGenerator<V,​E>
    Generates a random bipartite graph using the \(G(n_1,n_2,p)\) model in which every edge exists with probability \(p\).

    The \(G(n_1,n_2,p)\) model generates a bipartite graph by connecting each pair of a left vertex and a right vertex with probability \(p\). Each edge is created with probability independent of the others. The generator accept two sets of vertices, the left and right vertices sets of the bipartite graph, and the probability \(p\).

    Both undirected and directed graphs can be generated. If the graph is directed, there are three options for the considered (each generated independently with probability \(p\)) edges between each pair of left and right vertices: two edges in both directions, one edge from the left vertex to the right vertex, or one edge from the right vertex to the left vertex. See directedAll(), directedLeftToRight() and directedRightToLeft() for more details.

    The generated graph(s) will have vertex boolean weights with key BipartiteGraphs.VertexBiPartitionWeightKey which is the partition of the vertices into the left and right set of vertices. The weight is set to true for vertices in the left set, and false for vertices in the right set. The VertexBiPartition can be created later using BipartiteGraphs.getExistingPartition(Graph).

    By default, the value of \(p\) is \(0.1\) and the graph is undirected. Self and parallel edges are never created.

    In the following example, a bipartite graph with four left vertices and six right vertices is generated. Each edge is created with probability \(0.15\). The graph is directed from left to right, and the seed of the random number generator is set to some fixed value for deterministic behavior. 

     
 Graph<Integer, Integer> g = new GnpBipartiteGraphGenerator<>(IntGraphFactory.directed())
 		.directedLeftToRight()
 		.vertices(4, 6)
 		.edgeProbability(0.15)
 		.seed(0x7d0c16fa09e05751L)
 		.generate();

    For deterministic behavior, set the seed of the generator using seed(long).

    This generator is the bipartite version of GnpGraphGenerator.

    Author:
    Barak Ugav
    See Also:
    BipartiteGraphs

    • Constructor Detail

      • GnpBipartiteGraphGenerator

        public GnpBipartiteGraphGenerator()
        Create a new \(G(n_1,n_2,p)\) 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, int), the vertex builder must be set explicitly using graphFactory().setVertexBuilder(...). Same holds for edges, which there are no fixed number of them. Alternatively, the methods vertices(int, 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, Collection).

      • GnpBipartiteGraphGenerator

        public GnpBipartiteGraphGenerator​(GraphFactory<V,​E> factory)
        Create a new \(G(n_1,n_2,p)\) 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, 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.

        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, 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.

        Returns:
        the graph factory that will be used to create the generated graph(s)

      • vertices

        public GnpBipartiteGraphGenerator<V,​E> vertices​(Collection<? extends V> leftVertices,
                                                      Collection<? extends V> rightVertices)
        Set the vertices of the generated graph(s).

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. This method sets these two sets.

        If the generator is used to generate multiple graphs, the same vertex sets will be used for all of them. This method override all previous calls to any of vertices(Collection, Collection), vertices(int, int) or vertices(int, int, IdBuilder).

        Parameters:
        leftVertices - the set of left vertices of the generated graph(s)
        rightVertices - the set of right vertices of the generated graph(s)
        Returns:
        this generator

      • vertices

        public GnpBipartiteGraphGenerator<V,​E> vertices​(int leftVerticesNum,
                                                      int rightVerticesNum)
        Set the number of vertices that will be generated for each graph.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. This method sets these two sets.

        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, 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, Collection), vertices(int, int) or vertices(int, int, IdBuilder).

        Parameters:
        leftVerticesNum - the number of vertices that will be generated in the left set for each graph
        rightVerticesNum - the number of vertices that will be generated in the right set for each graph
        Returns:
        this generator
        Throws:
        IllegalArgumentException - if leftVerticesNum or rightVerticesNum are negative

      • vertices

        public GnpBipartiteGraphGenerator<V,​E> vertices​(int leftVerticesNum,
                                                      int rightVerticesNum,
                                                      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.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. This method sets these two sets.

        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, Collection), vertices(int, int) or vertices(int, int, IdBuilder).

        Parameters:
        leftVerticesNum - the number of vertices that will be generated in the left set for each graph
        rightVerticesNum - the number of vertices that will be generated in the right set for each graph
        vertexBuilder - the vertex builder, or null to use the vertex builder of the graph factory
        Returns:
        this generator
        Throws:
        IllegalArgumentException - if leftVerticesNum or rightVerticesNum are negative

      • edges

        public GnpBipartiteGraphGenerator<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

      • undirected

        public GnpBipartiteGraphGenerator<V,​E> undirected()
        Sets the generated graph(s) to be undirected.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. Calling this method will cause the generated graph(s) to be undirected, and a single edge between each pair of left and right vertices will considered and generated with probability \(p\). The maximum number of edges will be \(|U| \cdot |V|\).

        By default, the generated graph(s) is undirected.

        Returns:
        this generator
        See Also:
        directedAll(), directedLeftToRight(), directedRightToLeft()

      • directedAll

        public GnpBipartiteGraphGenerator<V,​E> directedAll()
        Sets the generated graph(s) to be directed with edges in both directions.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. Calling this method will cause the generated graph(s) to be directed, and for each pair of left and right vertices, two edges, opposite in direction of one another, will be considered and generated (independently) with probability \(p\). The maximum number of edges will be \(2 \cdot |U| \cdot |V|\).

        By default, the generated graph(s) is undirected.

        Returns:
        this generator
        See Also:
        undirected(), directedLeftToRight(), directedRightToLeft()

      • directedLeftToRight

        public GnpBipartiteGraphGenerator<V,​E> directedLeftToRight()
        Sets the generated graph(s) to be directed with edges from left to right.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. Calling this method will cause the generated graph(s) to be directed, and for each pair of left and right vertices a single edge from the left vertex to the right one will be considered and generated with probability \(p\). The maximum number of edges will be \(|U| \cdot |V|\).

        By default, the generated graph(s) is undirected.

        Returns:
        this generator
        See Also:
        undirected(), directedAll(), directedRightToLeft()

      • directedRightToLeft

        public GnpBipartiteGraphGenerator<V,​E> directedRightToLeft()
        Sets the generated graph(s) to be directed with edges from right to left.

        A bipartite graph is a graph whose vertices can be divided into two disjoint sets \(U\) and \(V\) such that every edge connects a vertex in \(U\) to one in \(V\). The two sets are usually called the left and right vertices. Calling this method will cause the generated graph(s) to be directed, and for each pair of left and right vertices a single edge from the right vertex to the left one will be considered and generated with probability \(p\). The maximum number of edges will be \(|U| \cdot |V|\).

        By default, the generated graph(s) is undirected.

        Returns:
        this generator
        See Also:
        undirected(), directedAll(), directedLeftToRight()

      • edgeProbability

        public GnpBipartiteGraphGenerator<V,​E> edgeProbability​(double p)
        Set the probability each edge will exists in the generated graph(s).

        For each pair of left and right vertices an edge is created with probability \(p\). If the graph is directed, either a single edge (from left to right, or right to left) or two edges (of opposite directions) will be considered and generated with probability \(p\). The direction of edges can be set using undirected(), directedAll(), directedLeftToRight() or directedRightToLeft().

        By default, the probability is \(0.1\).

        Parameters:
        p - the probability each edge will exists in the generated graph(s)
        Returns:
        this generator

      • seed

        public GnpBipartiteGraphGenerator<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