TemporalNetworksTest.ExampleData.GetTestNetwork2 C# (CSharp) Method

        public static TemporalNetwork GetTestNetwork2()
        {
            TemporalNetwork temporal_net = new TemporalNetwork();

            temporal_net.AddTemporalEdge(1, "a", "b");
            temporal_net.AddTemporalEdge(2, "b", "c");
            temporal_net.AddTemporalEdge(2, "d", "c");
            temporal_net.AddTemporalEdge(3, "c", "a");
            temporal_net.AddTemporalEdge(3, "c", "b");
            temporal_net.AddTemporalEdge(3, "c", "d");

            return temporal_net;
        }

        public void ReduceToTwoPathsTest()
        {
            TemporalNetwork test = ExampleData.GetTestNetwork();

            test.ReduceToTwoPaths();

            // There should be 12 two paths
            Assert.AreEqual(test.TwoPathCount, 12);

            // And 21 edges
            Assert.AreEqual(test.EdgeCount, 21);

            // The stripped network should contain 20 time steps
            Assert.AreEqual(test.Length, 20);

            Assert.AreEqual(test.MaxGranularity, 1);

            Assert.AreEqual(test.MinGranularity, 2);

            // The aggregate network should contain 8 weighted edges with a cumulative weight that matches 2 * twoPathCount
            Assert.AreEqual(test.AggregateNetwork.EdgeCount, 8);
            Assert.AreEqual(test.AggregateNetwork.CumulativeWeight, 22);

            // The second-order aggregate network should countain edges representing 6 different two-paths ...
            Assert.AreEqual(test.SecondOrderAggregateNetwork.EdgeCount, 6);
            // ... with a total weight of 11
            Assert.AreEqual(test.SecondOrderAggregateNetwork.CumulativeWeight, 11);

            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(c;e)", "(e;f)")], 5.5d);
            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(g;e)", "(e;f)")], 0.5d);
            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(e;f)", "(f;e)")], 1d);
            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(f;e)", "(e;b)")], 1d);
            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(a;e)", "(e;g)")], 2d);
            Assert.AreEqual(test.SecondOrderAggregateNetwork[new Tuple <string, string>("(b;e)", "(e;g)")], 1d);

            // Check whether all the weights are correctly computed ...
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("e", "f")], 7, "The weight of egde (e,f) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("e", "b")], 1, "The weight of egde (e,b) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("b", "e")], 1, "The weight of egde (b,e) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("g", "e")], 1d / 2d, "The weight of egde (g,e) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("e", "g")], 3, "The weight of egde (e,g) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("f", "e")], 2, "The weight of egde (f,e) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("a", "e")], 2, "The weight of egde (a,e) in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("c", "e")], 5 + 1d / 2d, "The weight of egde (c,e) in the aggregate network is wrong!");

            Assert.AreEqual(test.AggregateNetwork.MaxWeight, 7, "The maximum weight in the aggregate network is wrong!");
            Assert.AreEqual(test.AggregateNetwork.MinWeight, 0.5d, "The minimum weight in the aggregate network is wrong!");

            test = ExampleData.GetTestNetwork2();
            test.ReduceToTwoPaths();

            Assert.AreEqual(test.TwoPathCount, 7);

            Assert.AreEqual(test.Length, 3);

            Assert.AreEqual(test.MaxGranularity, 1);

            Assert.AreEqual(test.MinGranularity, 3);

            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("a", "b")], 1);
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("b", "c")], 1d + 1d / 6d + 1d / 6d + 1d / 6d);
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("d", "c")], 1d / 2d);
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("c", "d")], 1d / 3d);
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("c", "b")], 1d / 3d);
            Assert.AreEqual(test.AggregateNetwork[new Tuple <string, string>("c", "a")], 1d / 3d);
        }