NodeShuffler/src/Algorithms/RandomGraphGenerator.java

package Algorithms;

import Model.LayeredGraphNode;
import Model.LayeredNode;

public class RandomGraphGenerator {

    private double pSubgraph;
    private double pEdge;
    private int minLayer;
    private int maxLayer;
    private int minNodePerLayer;
    private int maxNodePerLayer;
    private int maxDepth;
    
    public RandomGraphGenerator( double pSubgraph, double pEdge, int minLayer, int maxLayer, int minNodePerLayer, int maxNodePerLayer, int maxDepth )
    {
        this.pSubgraph = pSubgraph;
        this.pEdge = pEdge;
        this.minLayer = minLayer;
        this.maxLayer = maxLayer;
        this.minNodePerLayer = minNodePerLayer;
        this.maxNodePerLayer = maxNodePerLayer;
        this.maxDepth = maxDepth;
    }
    
    public LayeredGraphNode createRandomNode( LayeredGraphNode parent, int depth )
    {
        LayeredGraphNode node = new LayeredNode( null, null );
        if( parent != null )
            node = parent.createNode( null );
        if( Math.random() <= pSubgraph && depth < maxDepth )
        {
            int layer = (int)( Math.random() * ( maxLayer - minLayer ) ) + minLayer;
            for( int i = 0; i < layer; i++ )
            {
                int knoten = (int)( Math.random() * ( maxNodePerLayer - minNodePerLayer ) ) + minNodePerLayer;
                for( int j = 0; j < knoten; j++ )
                {
                    LayeredGraphNode n = createRandomNode( node, depth + 1 );
                    n.setLayer( i );
                    if( i > 0 )
                    {
                        for( LayeredGraphNode n2 : node.getContainedLayers().get( i - 1 ) )
                        {
                            if( Math.random() <= pEdge )
                                node.createSimpleEdge( null, n2, n );
                        }
                    }
                }
            }
        }
        return node;
    }
}