public double Analyze(RandomNetwork pNetwork, bool pDirected)
{
double averageDegree = 0;
double N = pNetwork.Nodes().Count;
double E = pNetwork.Edges().Count;
E *= 2.0d;
averageDegree = E / N;
return(averageDegree);
}
public double Analyze(RandomNetwork network, bool directed)
{
int N = network.GetNumNodes();
int[] degree = new int[N];
foreach (var node in network.Nodes())
{
var edges = network.EdgesAdjacent(node, directed, directed, !directed);
int nodeDegree = edges.Count;
degree[nodeDegree]++;
}
return(LeastSquares(degree)[0]);
}
public Dictionary <int, int> Analyze(RandomNetwork network)
{
var distribuitionDegree = new Dictionary <int, int>();
int max_degree = 0;
foreach (var vertice in network.Nodes())
{
int degree = network.MGraph.AdjacentDegree(vertice);
Console.WriteLine(degree);
max_degree += degree;
if (distribuitionDegree.ContainsKey(degree))
{
distribuitionDegree[degree] += 1;
}
else
{
distribuitionDegree.Add(degree, 1);
}
}
return(distribuitionDegree);
}
public double Analyze(RandomNetwork pNetwork, bool pDirected)
{
double averageShortestPath = 0;
int N = pNetwork.Nodes().Count;
int invalidPaths = 0;
for (int i = 0; i < N; i++)
{
int [] distance = new int[N];
bool[] used = new bool[N];
for (int j = 0; j < N; j++)
{
distance[j] = Int32.MaxValue;
}
var edgeIterator = pNetwork.EdgesAdjacent(i, pDirected, false, !pDirected);
foreach (var edge in edgeIterator)
{
int neighborIndex = edge.Source;
if (neighborIndex == i)
{
neighborIndex = edge.Target;
}
distance[neighborIndex] = 1;
}
for (int allowed = 1; allowed < N; allowed++)
{
//Find the closest node
int min = Int32.MaxValue;
int index = 0;
for (int j = 0; j < N; j++)
{
if ((min > distance[j]) && (!used[j]))
{
min = distance[j];
index = j;
}
}
//Mark the closest node as used
used[index] = true;
var adjIterator = pNetwork.EdgesAdjacent(index, pDirected, false, !pDirected);
foreach (var adj in adjIterator)
{
int k = adj.Source;
if (k == index)
{
k = adj.Target;
}
if (!used[k])
{
int sum = distance[index] + 1;
if (sum < distance[k])
{
distance[k] = sum;
}
}
}
}
for (int j = 0; j < N; j++)
{
if (i != j)
{
if ((distance[j] < Int32.MaxValue) && (distance[j] > 0))
{
averageShortestPath += distance[j];
}
else
{
invalidPaths++;
}
}
}
}
return(averageShortestPath / ((double)(N * (N - 1.0d) - invalidPaths)));
}
public double Analyze(RandomNetwork pNetwork, bool pDirected)
{
double averageClusteringCoefficient = 0;
List <int> nodeIterator = pNetwork.Nodes();
int N = nodeIterator.Count;
List <int> [] nodeInRep = new List <int> [N];
List <int>[] nodeOutRep = new List <int> [N];
int nodeCount = 0;
foreach (var node in nodeIterator)
{
nodeOutRep[node] = new List <int>();
if (pDirected)
{
nodeInRep[node] = new List <int>();
}
var edgeIterator = pNetwork.EdgesAdjacent(node, pDirected, false, !pDirected);
foreach (var edge in edgeIterator)
{
int neighborIndex = edge.Target;
nodeOutRep[node].Add(neighborIndex);
}
if (pDirected)
{
edgeIterator = pNetwork.EdgesAdjacent(node, false, true, false);
foreach (var edge in edgeIterator)
{
int neighborIndex = edge.Target;
nodeInRep[node].Add(neighborIndex);
}
}
}
for (int i = 0; i < N; i++)
{
double edgeCount = 0;
List <int> neighborhood = nodeOutRep[i].ToList();
if (pDirected)
{
foreach (var node in nodeInRep[i])
{
if (!neighborhood.Contains(node))
{
neighborhood.Add(node);
}
}
}
if (neighborhood.Count < 2)
{
continue;
}
double size = neighborhood.Count * (neighborhood.Count - 1);
while (neighborhood.Count > 0)
{
int neighbor1 = neighborhood.ElementAt(0);
neighborhood.RemoveAt(0);
foreach (var neighbor2 in neighborhood)
{
if (nodeOutRep[neighbor1].Contains(neighbor2))
{
edgeCount++;
}
if ((pDirected) && (nodeOutRep[neighbor2].Contains(neighbor1)))
{
edgeCount++;
}
}
}
if (!pDirected)
{
edgeCount *= 2.0;
}
averageClusteringCoefficient += edgeCount / size;
}
return(averageClusteringCoefficient / N);
}