示例#1
0
        public void CouldAddTwoSeriesWithSameKeys(double expected, SortedMap <int, double> sm1,
                                                  SortedMap <int, double> sm2)
        {
            var count = sm1.Count;

            var c1 = sm1.GetEnumerator();
            var c2 = sm2.GetEnumerator();

            //var ds1 = new Deedle.Series<int, double>(sm1.Keys.ToArray(), sm1.Values.ToArray());
            //var ds2 = new Deedle.Series<int, double>(sm2.Keys.ToArray(), sm2.Values.ToArray());

            Assert.NotNull(c1.Comparer);
            Assert.NotNull(c2.Comparer);

            var    zipSum    = (sm1 + sm2);
            double actual    = 0;
            var    zipCursor = //zipSum.GetAsyncEnumerator();
                               new Zip <int, double, double, SortedMapCursor <int, double>,
                                        SortedMapCursor <int, double> >(
                c1, c2);         //.Map((k, v) => v.Item1 + v.Item2)

            var op2 = new Op2 <int, double, AddOp <double>, Zip <int, double, double, SortedMapCursor <int, double>,
                                                                 SortedMapCursor <int, double> > >(zipCursor).Source;

            var zipCursorOp2 = op2.GetEnumerator();

            using (Benchmark.Run("Zip", count * 2))
            {
                while (zipCursorOp2.MoveNext())
                {
                    actual += zipCursorOp2.CurrentValue;
                }
            }
            Assert.AreEqual(expected, actual);

            //var zipped = sm1.Zip(sm2, (k, l, r) => l + r); // sm1.Zip(sm2).Map((k, v) => v.Item1 + v.Item2); //
            //actual = 0;
            //using (Benchmark.Run("Zip MN Extension", count * 2))
            //{
            //    foreach (var keyValuePair in zipped)
            //    {
            //        actual += keyValuePair.Value;
            //    }
            //}
            //Assert.AreEqual(expected, actual);

            //var zipN = new[] { sm1, sm2 }.Zip((k, varr) => varr[0] + varr[1], true).GetCursor();
            //actual = 0;
            //using (Benchmark.Run("ZipN", count * 2))
            //{
            //    while (zipN.MoveNextAsync())
            //    {
            //        actual += zipN.CurrentValue;
            //    }
            //}
            //Assert.AreEqual(expected, actual);

            //var zipNOld = new[] { sm1, sm2 }.ZipOld((k, varr) => varr[0] + varr[1]).GetCursor();
            //actual = 0;
            //using (Benchmark.Run("ZipN (old)", count * 2))
            //{
            //    while (zipNOld.MoveNextAsync())
            //    {
            //        actual += zipNOld.CurrentValue;
            //    }
            //}
            //Assert.AreEqual(expected, actual);

            //zipCursor.Reset();
            //actual = 0;
            //using (Benchmark.Run("Zip MP", count * 2))
            //{
            //    while (zipCursor.MovePrevious())
            //    {
            //        actual += zipCursor.CurrentValue;
            //    }
            //}
            //Assert.AreEqual(expected, actual);

            //actual = 0;
            //using (Benchmark.Run("LINQ", count * 2))
            //{
            //    var linq = sm1.Zip(sm2, (l, r) => l.Value + r.Value);
            //    foreach (var d in linq)
            //    {
            //        actual += d;
            //    }
            //}
            //Assert.AreEqual(expected, actual);

            //actual = 0;
            //using (Benchmark.Run("Deedle", count * 2))
            //{
            //    var sum = ds1 + ds2;
            //    foreach (var v in sum.Values) // ds1.ZipInner(ds2).Values)
            //    {
            //        actual += v; //.Item1 + v.Item2;
            //    }
            //}
            //Assert.AreEqual(expected, actual);
        }