public double ClusteringCoefficient(RandomNetwork network)
{
List <UndirectedEdge <int> > neighbors;
double sum = 0;
int count = 0;
foreach (var v in network.MGraph.Vertices)
{
neighbors = network.MGraph.AdjacentEdges(v).ToList();
for (int i = 0; i < neighbors.Count; i++)
{
var s = neighbors.ElementAt(i);
for (int j = i + 1; j < neighbors.Count; j++)
{
var edgesNeighbor = network.MGraph.AdjacentEdges(s.Target).ToList();
if (edgesNeighbor.Count(e => e.Target == neighbors.ElementAt(j).Target) > 0)
{
count++;
}
}
}
if (count != 0)
{
sum += count * 2.0 / (neighbors.Count * (neighbors.Count - 1));
}
count = 0;
}
return(sum / network.MGraph.VertexCount);
}
NetworkRandomizerModel(RandomNetwork pRandomNetwork, bool pDirected)
{
MDirected = pDirected;
MOriginal = pRandomNetwork;
MSeed = DateTime.UtcNow.Millisecond;
MRandom = new Random(MSeed);
}
public static void testBarabasiAlbertModel()
{
//Model specific variabels
int nodes = 500;
int degree = 2;
bool allowReflexive = false;
bool directed = false;
int init = 3;
int edges = ((init) * (init - 1) / 2 + (degree * (nodes - init)));
//Create the model
BarabasiAlbertModel bam;
DegreeDistributionMetric metric = new DegreeDistributionMetric();
for (int i = 100; i < 1000; i += 100)
{
bam = new BarabasiAlbertModel(i, allowReflexive, directed, init, degree);
RandomNetwork random_network = bam.Generate();
var dddegree = metric.Analyze(random_network, directed);
Console.WriteLine(string.Format("{0};{1}", i, dddegree));
}
//for (int j = 4; j <= 10; j += 2)
//{
// bam = new BarabasiAlbertModel(j, allowReflexive, directed, init, degree);
// RandomNetwork random_network = bam.Generate();
// DegreeDistributionMetric metric = new DegreeDistributionMetric();
// AverageDegreeMetric m = new AverageDegreeMetric();
// m.Analyze(random_network, directed);
// double c = metric.Analyze(random_network, directed);
//}
}
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 static void testWattsStrogatzModelClust()
{
int nodes = 100;
double beta = 0.1;
int degree = 4;
bool allowReflexive = false;
bool directed = false;
for (double i = 0.0; i <= 1; i += 0.1)
{
WattsStrogatzModel wsm = new WattsStrogatzModel(nodes, allowReflexive, directed, i, degree);
RandomNetwork random_network = wsm.Generate();
ClusteringCoefficientMetric m = new ClusteringCoefficientMetric();
double d = m.Analyze(random_network, directed);
Console.Write(d + " ");
}
Console.WriteLine();
}
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 override RandomNetwork Generate()
{
RandomNetwork randomNetwork = new RandomNetwork(Directed);
long time = DateTime.UtcNow.Millisecond;
int[] nodes = new int[NumNodes];
int [] degrees = new int[NumNodes];
for (int i = 0; i < NumNodes; i++)
{
nodes[i] = randomNetwork.NodeCreate();
}
NumEdges = 0;
for (int i = 0; i < _initNumNodes; i++)
{
for (int j = (i + 1); j < _initNumNodes; j++)
{
randomNetwork.EdgeCreate(nodes[i], nodes[j], Directed);
degrees[i]++;
degrees[j]++;
NumEdges++;
}
}
for (int i = _initNumNodes; i < NumNodes; i++)
{
int added = 0;
double degreeIgnore = 0;
for (int m = 0; m < _edgesToAdd; m++)
{
double prob = 0;
double randNum = Random.NextDouble();
for (int j = 0; j < i; j++)
{
List <UndirectedEdge <int> > edges = randomNetwork.EdgesConnecting(nodes[i], nodes[j], Directed, false, !Directed);
if (edges.Count == 0)
{
prob += (double)((double)degrees[j])
/ ((double)(2.0d * NumEdges) - degreeIgnore);
}
if (randNum <= prob)
{
randomNetwork.EdgeCreate(nodes[i], nodes[j], Directed);
degreeIgnore += degrees[j];
added++;
degrees[i]++;
degrees[j]++;
break;
}
}
}
NumEdges += added;
}
return(randomNetwork);
}
public List <Matrix> loadFromInputFile(string inputFile, bool sign, bool selfTies)
{
string filename = inputFile;
// List<Dictionary<string, int>> networkSpec = new List<Dictionary<string, int>>();
List <RandomNetwork> networkSpec = new List <RandomNetwork>();
// Unsigned should have 5 cols, while signed 6 cols
var reader = new StreamReader(filename);
var headers = reader.ReadLine().Split(',');
int num_items = headers.Length;
string net_ID;
int nodes;
int edges;
int pos_edges;
int neg_edges;
int min_val;
int max_val;
if (sign == true && num_items == 6)
{
string temp_ID = "";
RandomNetwork tempNetwork = new RandomNetwork();
while (!reader.EndOfStream)
{
// networkSpec.Add(new Dictionary<string, int>());
var items = reader.ReadLine().Split(',');
if (int.TryParse(items[1], out nodes) && int.TryParse(items[2], out pos_edges) && int.TryParse(items[3], out neg_edges) && int.TryParse(items[4], out min_val) && int.TryParse(items[5], out max_val))
{
if ((nodes >= 0) && ((pos_edges >= 0) && (max_val >= 0)) && ((neg_edges >= 0) && (min_val <= 0)) && !(pos_edges > 0 && max_val == 0) && !(neg_edges > 0 && min_val == 0))
{
net_ID = items[0];
if (net_ID != "")
{
temp_ID = net_ID;
tempNetwork.NetworkId = net_ID;
tempNetwork.PosEdg = pos_edges;
tempNetwork.NegEdg = neg_edges;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Nodes = nodes;
networkSpec.Add(tempNetwork);
}
else if (string.Equals(net_ID, temp_ID) && temp_ID != "")
{
throw new Exception("Repetitive nodes!");
}
}
else
{
throw new Exception("Invalid input values!");
}
}
else
{
throw new Exception("Invalid input format!");
}
}
NumNetID = networkSpec.Count;
foreach (RandomNetwork randNet in networkSpec)
{
// Console.WriteLine("Nodes: " + kvp.Value.Nodes.ToString());
if (SelfTies)
{
if ((Math.Ceiling((double)randNet.PosEdg / ((randNet.Max == 0) ? 1 : randNet.Max)) + Math.Ceiling((double)randNet.NegEdg / ((randNet.Min == 0) ? 1 : Math.Abs(randNet.Min)))) > (randNet.Nodes * randNet.Nodes - randNet.Nodes))
{
throw new Exception("Edges of this network is out of range!");
}
}
else
{
if ((Math.Ceiling((double)randNet.PosEdg / ((randNet.Max == 0) ? 1 : randNet.Max)) + Math.Ceiling((double)randNet.NegEdg / ((randNet.Min == 0) ? 1 : Math.Abs(randNet.Min)))) > randNet.Nodes * randNet.Nodes)
{
throw new Exception("Edges of this network is out of range!");
}
}
}
}
else if (sign == false && num_items == 5)
{
string temp_ID = "";
RandomNetwork tempNetwork = new RandomNetwork();
while (!reader.EndOfStream)
{
// networkSpec.Add(new Dictionary<string, int>());
var items = reader.ReadLine().Split(',');
if (int.TryParse(items[1], out nodes) && int.TryParse(items[2], out edges) && int.TryParse(items[3], out min_val) && int.TryParse(items[4], out max_val))
{
if ((nodes >= 0) && ((edges >= 0) && (max_val >= 0)) && (max_val >= min_val && min_val >= 0) && !(edges > 0 && max_val == 0))
{
net_ID = items[0];
if (net_ID != "")
{
temp_ID = net_ID;
tempNetwork.NetworkId = net_ID;
tempNetwork.Edge = edges;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Nodes = nodes;
networkSpec.Add(tempNetwork);
}
else if (string.Equals(net_ID, temp_ID) && temp_ID != "")
{
throw new Exception("Repetitive nodes!");
}
}
else
{
throw new Exception("Invalid input values!");
}
}
else
{
throw new Exception("Invalid input format!");
}
}
NumNetID = networkSpec.Count;
foreach (RandomNetwork randNet in networkSpec)
{
if (SelfTies)
{
if ((Math.Ceiling((double)randNet.Edge / ((randNet.Max == 0) ? 1 : randNet.Max))) > (randNet.Nodes * randNet.Nodes - randNet.Nodes))
{
throw new Exception("Edges of this network is out of range!");
}
}
else
{
if ((Math.Ceiling((double)randNet.Edge / ((randNet.Max == 0) ? 1 : randNet.Max))) > randNet.Nodes * randNet.Nodes)
{
throw new Exception("Edges of this network is out of range!");
}
}
}
}
else
{
throw new IOException("Incorrect input format!");
}
reader.Close();
List <Matrix> networkSpec_data = new List <Matrix>();
int netId = 0;
foreach (RandomNetwork randNet in networkSpec)
{
string netIdStr = randNet.NetworkId;
int cols = sign ? 5 : 4;
Matrix tempMatrix = new Matrix(1, cols);
tempMatrix.NetworkId = netId++;
tempMatrix.NetworkIdStr = netIdStr;
if (sign)
{
string[] colLabels = { "Nodes", "Pos. Edges", "Neg. Edges", "Min", "Max" };
tempMatrix.ColLabels.SetLabels(colLabels);
tempMatrix[0, 0] = randNet.Nodes;
tempMatrix[0, 1] = randNet.PosEdg;
tempMatrix[0, 2] = randNet.NegEdg;
tempMatrix[0, 3] = randNet.Min;
tempMatrix[0, 4] = randNet.Max;
}
else
{
string[] colLabels = { "Nodes", "Edges", "Min", "Max" };
tempMatrix.ColLabels.SetLabels(colLabels);
tempMatrix[0, 0] = randNet.Nodes;
tempMatrix[0, 1] = randNet.Edge;
tempMatrix[0, 2] = randNet.Min;
tempMatrix[0, 3] = randNet.Max;
}
networkSpec_data.Add(tempMatrix);
}
return(networkSpec_data);
}
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);
}
public override RandomNetwork Generate()
{
RandomNetwork randomNetwork = new RandomNetwork(Directed);
NumEdges = 0;
int[] nodes = new int[NumNodes];
for (int i = 0; i < NumNodes; i++)
{
nodes[i] = randomNetwork.NodeCreate();
}
if (Directed && AllowSelfEdge && (2 * _degree > NumNodes))
{
_degree = NumNodes / 2;
}
else if (Directed && (2 * _degree > (NumNodes - 1) / 2))
{
_degree = (NumNodes - 1) / 2;
}
if (!Directed && AllowSelfEdge && (2 * _degree > NumNodes))
{
_degree = NumNodes / 2;
}
else if (!Directed && (2 * _degree > (NumNodes - 1) / 2))
{
_degree = (NumNodes - 1) / 2;
}
for (int i = 0; i < NumNodes; i++)
{
int start = i - _degree;
if (start < 0)
{
start = NumNodes + start;
}
int count = 0;
int stop = 2 * _degree;
while (count < stop)
{
if ((i != start) || (AllowSelfEdge))
{
if (((!Directed) && (nodes[i] <= nodes[start])) || (Directed))
{
randomNetwork.EdgeCreate(nodes[i], nodes[start], Directed);
NumEdges++;
}
if (i != start)
{
count++;
}
}
start = (start + 1) % NumNodes;
}
}
LinkedList <UndirectedEdge <int> > edgeList = new LinkedList <UndirectedEdge <int> >();
var iter = randomNetwork.Edges();
foreach (var edge in iter)
{
edgeList.AddLast(edge);
}
while (edgeList.Count > 0)
{
var nextEdge = edgeList.ElementAt(0);
edgeList.RemoveFirst();
int source = nextEdge.Source;
int target = nextEdge.Target;
double percent = Random.NextDouble();
if (percent <= _beta)
{
int k = 0;
bool candidate = false;
while (!candidate)
{
k = Math.Abs(Random.Next() % NumNodes);
candidate = true;
candidate = candidate && (k != source) || (AllowSelfEdge);
candidate = candidate && (k != target);
int edgeCount = 0;
var edgeIter = randomNetwork.EdgesAdjacent(source, Directed, false, !Directed);
foreach (var edge in edgeIter)
{
int neighbor = edge.Target;
if (neighbor == source)
{
neighbor = edge.Source;
}
candidate = candidate && (neighbor != k);
edgeCount++;
}
if ((edgeCount == NumNodes) && (AllowSelfEdge))
{
candidate = false;
break;
}
else if ((edgeCount == (NumNodes - 1)) && (!AllowSelfEdge))
{
candidate = false;
break;
}
}
if (candidate)
{
randomNetwork.EdgeRemove(nextEdge);
randomNetwork.EdgeCreate(source, k, Directed);
}
}
}
return(randomNetwork);
}
public List <Matrix> loadFromInputFile(string inputFile, bool sign, bool selfTies)
{
string filename = inputFile;
Dictionary <string, List <RandomNetwork> > networkSpec = new Dictionary <string, List <RandomNetwork> >();
List <string> orderedNetIds = new List <string>();
// Unsigned should have 5 cols, while signed 6 cols
var reader = new StreamReader(filename);
var headers = reader.ReadLine().Split(',');
int num_items = headers.Length;
string net_ID;
// int net_count = 0;
// int node_index;
string node_label;
int[] nodes = null;
int degree;
int pos_degree;
int neg_degree;
int min_val;
int max_val;
int i = 0;
if (sign == true && num_items == 6)
{
string tempNetID = "";
RandomNetwork tempNetwork = new RandomNetwork();
while (!reader.EndOfStream)
{
var items = reader.ReadLine().Split(',');
if (int.TryParse(items[2], out pos_degree) && int.TryParse(items[3], out neg_degree) && int.TryParse(items[4], out min_val) && int.TryParse(items[5], out max_val))
{
//if ((net_ID > 0) && (((pos_degree > 0) && (max_val > 0)) || ((pos_degree == 0) && (max_val == 0))) && (((neg_degree > 0) && (min_val < 0)) || ((neg_degree == 0) && (min_val == 0))))
if (((pos_degree >= 0) && (max_val >= 0)) && ((neg_degree >= 0) && (min_val <= 0)) && !(pos_degree > 0 && max_val == 0) && !(neg_degree > 0 && min_val == 0))
{
net_ID = items[0];
node_label = items[1];
// Identify a new network ID and add it to the list
if (!string.Equals(net_ID, tempNetID))
{
tempNetID = net_ID;
networkSpec.Add(net_ID, new List <RandomNetwork>());
orderedNetIds.Add(net_ID);
tempNetwork.NetworkId = net_ID;
tempNetwork.PosDeg = pos_degree;
tempNetwork.NegDeg = neg_degree;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Node = node_label;
networkSpec[net_ID].Add(tempNetwork);
//networkSpec[net_ID].Add("Pos. Degree", new List<int>() { pos_degree });
//networkSpec[net_ID].Add("Neg. Degree", new List<int>() { neg_degree });
//networkSpec[net_ID].Add("Min", new List<int>() { min_val });
//networkSpec[net_ID].Add("Max", new List<int>() { max_val });
}
else if (string.Equals(net_ID, tempNetID))
{
if (!networkSpec[net_ID].Exists(x => string.Equals(x.Node, node_label)))
{
tempNetwork.NetworkId = net_ID;
tempNetwork.PosDeg = pos_degree;
tempNetwork.NegDeg = neg_degree;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Node = node_label;
networkSpec[net_ID].Add(tempNetwork);
}
else
{
throw new Exception("Repetitive nodes!");
}
}
}
else
{
throw new Exception("Invalid input values!");
}
}
else
{
throw new Exception("Invalid input format!");
}
}
NumNetID = networkSpec.Count;
nodes = new int[NumNetID];
int counter = 0;
foreach (string netId in orderedNetIds)
{
int temp_node = 0;
// int edges = 0;
nodes[counter] = networkSpec[netId].Count;
temp_node = nodes[counter++];
// Constraints on degrees: Each node cannot have a degree larger than the total number of nodes
// degree (pos_degree + neg_degree) [i] < Sum(degree [i])
if (selfTies)
{
for (i = 0; i < temp_node; i++)
{
if (Math.Ceiling((double)networkSpec[netId][i].PosDeg / (networkSpec[netId][i].Max == 0 ? 1 : networkSpec[netId][i].Max)) + Math.Ceiling((double)networkSpec[netId][i].NegDeg / (networkSpec[netId][i].Min == 0 ? 1 : Math.Abs(networkSpec[netId][i].Min))) > temp_node)
{
throw new Exception("Degree of the node in Network is out of range!");
}
//else
//{
// edges += networkSpec[netId]["Pos. Degree"][i] + networkSpec[netId]["Neg. Degree"][i];
//}
}
}
// For unselftied case, the total degree can only be as many as (nodes[i] - 1).
else
{
for (i = 0; i < temp_node; i++)
{
if (Math.Ceiling((double)networkSpec[netId][i].PosDeg / (networkSpec[netId][i].Max == 0 ? 1 : networkSpec[netId][i].Max)) + Math.Ceiling((double)networkSpec[netId][i].NegDeg / (networkSpec[netId][i].Min == 0 ? 1 : Math.Abs(networkSpec[netId][i].Min))) > (temp_node - 1))
{
throw new Exception("Degree of the node in Network is out of range!");
}
//else
//{
// edges += networkSpec[netId]["Pos. Degree"][i] + networkSpec[netId]["Neg. Degree"][i];
//}
}
}
//// Constraint the total number of edges according to the given type of networks
//if (!(((selfTies == false) && (edges <= (temp_node * temp_node - temp_node))) ^ ((selfTies == true) && (edges <= temp_node * temp_node))))
//{
// throw new Exception("The number of edges is out of range!");
//}
}
}
else if (sign == false && num_items == 5)
{
string tempNetID = "";
RandomNetwork tempNetwork = new RandomNetwork();
while (!reader.EndOfStream)
{
var items = reader.ReadLine().Split(',');
if (int.TryParse(items[2], out degree) && int.TryParse(items[3], out min_val) && int.TryParse(items[4], out max_val))
{
//if ((net_ID > 0) && (((degree > 0) && (max_val > 0)) || ((degree == 0) && (max_val == 0))))
if ((degree >= 0) && (min_val >= 0) && (max_val >= min_val) && !(degree > 0 && max_val == 0))
{
// Console.WriteLine("net_ID: " + net_ID.ToString() + " " + "node_index: " + node_index.ToString());
// Identify a new network ID and add it to the list
net_ID = items[0];
node_label = items[1];
if (!String.Equals(net_ID, tempNetID))
{
tempNetID = net_ID;
networkSpec.Add(net_ID, new List <RandomNetwork>());
orderedNetIds.Add(net_ID);
tempNetwork.NetworkId = net_ID;
tempNetwork.Degree = degree;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Node = node_label;
networkSpec[net_ID].Add(tempNetwork);
//networkSpec[net_ID].Add("Degree", new List<int>() { degree });
//networkSpec[net_ID].Add("Min", new List<int>() { min_val });
//networkSpec[net_ID].Add("Max", new List<int>() { max_val });
}
else if (String.Equals(net_ID, tempNetID))
{
//networkSpec[tempNetID]["Degree"].Add(degree);
//networkSpec[tempNetID]["Min"].Add(min_val);
//networkSpec[tempNetID]["Max"].Add(max_val);
//tempNode = node_index;
if (!networkSpec[net_ID].Exists(x => string.Equals(x.Node, node_label)))
{
tempNetwork.NetworkId = net_ID;
tempNetwork.Degree = degree;
tempNetwork.Min = min_val;
tempNetwork.Max = max_val;
tempNetwork.Node = node_label;
networkSpec[net_ID].Add(tempNetwork);
}
else
{
throw new Exception("Repetitive nodes!");
}
}
}
else
{
throw new Exception("Invalid input values!");
}
}
else
{
throw new Exception("Invalid input format!");
}
}
NumNetID = networkSpec.Count;
nodes = new int[NumNetID];
int counter = 0;
foreach (string netId in orderedNetIds)
{
int temp_node = 0;
nodes[counter] = networkSpec[netId].Count;
temp_node = nodes[counter++];
// Constraints on degrees: Each node cannot have a degree larger than the total number of nodes
// degree (pos_degree + neg_degree) [i] < Sum(degree [i])
if (selfTies)
{
for (i = 0; i < temp_node; i++)
{
if (networkSpec[netId][i].Degree > (networkSpec[netId][i].Max * temp_node))
{
throw new Exception("Degree of the node in Network is out of range!");
}
}
}
else
{
for (i = 0; i < temp_node; i++)
{
if (networkSpec[netId][i].Degree > (networkSpec[netId][i].Max * (temp_node - 1)))
{
throw new Exception("Degree of the node in Network is out of range!");
}
}
}
}
}
else
{
throw new IOException("Incorrect input format!");
}
reader.Close();
// Create a Matrix T to store the input data
List <Matrix> networkSpec_data = new List <Matrix>();
i = 0;
foreach (string netId in orderedNetIds)
{
List <RandomNetwork> tempList = networkSpec[netId];
int cols = sign?4:3;
Matrix m = new Matrix(nodes[i], cols, netId);
//m.NetworkIdStr = netId;
if (sign)
{
string[] rowLabels = new string[nodes[i]];
string[] colLabels = { "Pos. Degree", "Neg. Degree", "Min", "Max" };
m.ColLabels.SetLabels(colLabels);
for (int j = 0; j < nodes[i]; j++)
{
rowLabels[j] = tempList[j].Node;
m[j, 0] = tempList[j].PosDeg;
m[j, 1] = tempList[j].NegDeg;
m[j, 2] = tempList[j].Min;
m[j, 3] = tempList[j].Max;
}
m.RowLabels.SetLabels(rowLabels);
i++;
}
else
{
string[] rowLabels = new string[nodes[i]];
string[] colLabels = { "Degree", "Min", "Max" };
m.ColLabels.SetLabels(colLabels);
for (int j = 0; j < nodes[i]; j++)
{
rowLabels[j] = tempList[j].Node;
m[j, 0] = tempList[j].Degree;
m[j, 1] = tempList[j].Min;
m[j, 2] = tempList[j].Max;
}
m.RowLabels.SetLabels(rowLabels);
i++;
}
networkSpec_data.Add(m);
// Console.WriteLine("Network ID: " + networkSpec_data[s].Name + " Row: " + networkSpec_data[s].RowLabels);
}
return(networkSpec_data);
}