/// <summary>
/// Generates random data for current level of block-hierarchic tree.
/// </summary>
/// <node>Current level must be initialized.</node>
private void GenerateData(BitArray[][] treeMatrix,
Int32 currentLevel,
Int32 branchingIndex,
Int32 maxLevel,
Double mu)
{
List <EdgesAddedOrRemoved> edgesOnCurrentLevel = new List <EdgesAddedOrRemoved>();
for (int i = 0; i < treeMatrix[maxLevel - currentLevel].Length; i++)
{
for (int j = 0; j < treeMatrix[maxLevel - currentLevel][i].Length; j++)
{
if (rand.NextDouble() <= (1 / Math.Pow(branchingIndex, currentLevel * mu)))
{
treeMatrix[maxLevel - currentLevel][i][j] = true;
edgesOnCurrentLevel.Add(new EdgesAddedOrRemoved(i, j, true));
}
else
{
treeMatrix[maxLevel - currentLevel][i][j] = false;
}
}
}
GenerationSteps.Add(edgesOnCurrentLevel);
}
private void FillValuesByProbability(double probability, int stepCount)
{
while (stepCount > 0)
{
List <EdgesAddedOrRemoved> step = (GenerationSteps != null) ? new List <EdgesAddedOrRemoved>() : null;
for (int i = 1; i < container.Size; ++i)
{
List <int> neighbours = new List <int>();
List <int> nonNeighbours = new List <int>();
for (int k = 0; k < container.Size && k < i; ++k)
{
if (container.AreConnected(i, k))
{
neighbours.Add(k);
//if (step != null)
// step.Add(new EdgesAddedOrRemoved(i, k, true));
}
else
{
nonNeighbours.Add(k);
//if (step != null)
// step.Add(new EdgesAddedOrRemoved(i, k, false));
}
}
if (nonNeighbours.Count > 0)
{
int size_neighbours = neighbours.Count;
for (int j = 0; j < size_neighbours; ++j)
{
int r = WSStep(probability, nonNeighbours, neighbours[j]);
if (r != neighbours[j])
{
//container.Disconnect(i, neighbours[j]);
//container.AreConnected(i, r);
container.AddConnection(i, r);
container.RemoveConnection(i, neighbours[j]);
if (step != null)
{
step.Add(new EdgesAddedOrRemoved(i, r, true));
step.Add(new EdgesAddedOrRemoved(i, neighbours[j], false));
}
}
}
}
}
GenerationSteps.Add(step);
--stepCount;
}
}
private void GenerateInitialNetwork(int vertexCount, int numberOfEdges)
{
List <EdgesAddedOrRemoved> initialStep = (GenerationSteps != null) ? new List <EdgesAddedOrRemoved>() : null;
for (int i = 0; i < vertexCount; ++i)
{
for (int k = 1; k <= numberOfEdges / 2; ++k)
{
int j = (i + k) < vertexCount ? (i + k) : (i + k) % vertexCount;
container.AddConnection(i, j);
initialStep.Add(new EdgesAddedOrRemoved(i, j, true));
}
}
GenerationSteps.Add(initialStep);
}
private void FillValuesByProbability(double p)
{
int edgesAdded = 0;
int numberOfVertices = container.Size;
List <EdgesAddedOrRemoved> l = new List <EdgesAddedOrRemoved>();
if (GenerationSteps != null)
{
GenerationSteps.Add(null);
}
for (int i = 0; i < container.Size; ++i)
{
for (int j = i + 1; j < container.Size; ++j)
{
if (rand.NextDouble() < p)
{
container.AddConnection(i, j);
if (GenerationSteps != null)
{
l.Add(new EdgesAddedOrRemoved(i, j, true));
if (edgesAdded >= ((numberOfVertices - 1) / p))
{
GenerationSteps.Add(l);
l = new List <EdgesAddedOrRemoved>();
edgesAdded = 0;
}
edgesAdded++;
}
}
}
}
if (GenerationSteps != null)
{
if (l.Count != 0)
{
GenerationSteps.Add(l);
}
}
}
private void GenerateInitialGraph(Double probability)
{
List <EdgesAddedOrRemoved> initialStep = (GenerationSteps != null) ? new List <EdgesAddedOrRemoved>() : null;
for (Int32 i = 0; i < container.Size; ++i)
{
for (Int32 j = i + 1; j < container.Size; ++j)
{
if (rand.NextDouble() < probability)
{
container.AddConnection(i, j);
if (initialStep != null)
{
initialStep.Add(new EdgesAddedOrRemoved(i, j, true));
}
}
}
}
if (GenerationSteps != null)
{
GenerationSteps.Add(initialStep);
}
}
public void RefreshNeighbourships(Boolean[] generatedVector)
{
List <EdgesAddedOrRemoved> currentStep = (GenerationSteps != null) ? new List <EdgesAddedOrRemoved>() : null;
Int32 newVertexDegree = 0;
for (Int32 i = 0; i < generatedVector.Length; ++i)
{
if (generatedVector[i])
{
++newVertexDegree;
container.AddConnection(i, container.Size - 1);
if (currentStep != null)
{
currentStep.Add(new EdgesAddedOrRemoved(i, container.Size - 1, true));
}
}
}
++container.Degrees[newVertexDegree];
if (GenerationSteps != null)
{
GenerationSteps.Add(currentStep);
}
}
/// <summary>
/// Fills values in the two-dimensional array of bits which define the connectedness
/// of clusters between each other.
/// </summary>
/// <param name="treeMatrix">Two-dimensional array of bits which define the connectedness
/// of clusters between each other.</param>
/// <param name="mu">Density parameter.</param>
private void GenerateData(BitArray[][] treeMatrix, Double mu)
{
for (int currentLevel = 0; currentLevel < container.Level; ++currentLevel)
{
if (treeMatrix[currentLevel].Length > 0)
{
List <EdgesAddedOrRemoved> edgesOnCurrentLevel = new List <EdgesAddedOrRemoved>();
int branchSize = container.Branches[currentLevel][0];
int counter = 0, nodeNumber = 0;
for (int i = 0; i < treeMatrix[currentLevel].Length; i++)
{
for (int j = 0; j < treeMatrix[currentLevel][i].Length; j++)
{
if (counter == (branchSize * (branchSize - 1) / 2))
{
++nodeNumber;
counter = 0;
branchSize = container.Branches[currentLevel][nodeNumber];
}
double k = rand.NextDouble();
if (k <= (1 / Math.Pow(container.CountLeaves(currentLevel, nodeNumber), mu)))
{
treeMatrix[currentLevel][i][j] = true;
edgesOnCurrentLevel.Add(new EdgesAddedOrRemoved(i, j, true));
}
else
{
treeMatrix[currentLevel][i][j] = false;
}
++counter;
}
}
GenerationSteps.Add(edgesOnCurrentLevel);
}
}
}
