コード例 #1
0
        static void Main()
        {
            var musicians = new RankedSet <string> (StringComparer.InvariantCultureIgnoreCase);

            foreach (var m1 in new string[] { "Falco", "k.d. lang", "Madonna", "Tom Petty",
                                              "Joni Mitchell", "Grimes", "Warren Zevon" })
            {
                musicians.Add(m1);
            }

            Console.WriteLine("Candidates:");
            foreach (var item in musicians)
            {
                Console.WriteLine($"  {item}");
            }

            musicians.Remove("Falco");
            musicians.RemoveWhere(IsPolynymous);
            musicians.RemoveRange(1, musicians.Count - 1);

            Console.WriteLine("\nFavorite:");
            foreach (var item in musicians)
            {
                Console.WriteLine($"  {item}");
            }
        }
コード例 #2
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 4
            };

            Console.WriteLine("Empty tree is a single leaf:");
            WriteInfo(true);

            Console.WriteLine("Create sequentially loaded tree of order 4:");
            for (int i = 2; i <= 24; i += 2)
            {
                set.Add(i);
            }
            WriteInfo(true);

            Console.WriteLine("Cascade split by adding 17:");
            set.Add(17);
            WriteInfo();

            Console.WriteLine("Split a leaf by adding 3:");
            set.Add(3);
            WriteInfo();

            Console.WriteLine("Create non-rightmost branch with 2 children by adding 9:");
            set.Add(9);
            WriteInfo();

            Console.WriteLine("Cascade coalesce by removing 2:");
            set.Remove(2);
            WriteInfo();
        }
コード例 #3
0
ファイル: RxBench02.cs プロジェクト: kaosborn/KaosCollections
        static void Main()
        {
            // Here is an example of why 'private protected' is better than 'internal'.
            // Kaos.Collections v4.1 and earlier it was internal and would have compiled for RxBench02.
            // After v4.1, as private protected it is not accessible.

            // Commented out assignment no longer compiles for single-assembly projects:
            var rs = new RankedSet <int>();
            // var kc = rs.maxKeyCount;

            // Here is a curiosity where the BCL allows creation of an enumerator without a target class.
            // This default constructor is not emulated by Kaos.Collections.
            var strangeEnumerator = new SortedSet <int> .Enumerator();

            // Another curiosity: BCL enumerators remain active after disposing.
            // The KaosCollections library emulates this seemingly wrong behavior.

            var ss = new SortedSet <int> {
                3, 4, 5
            };

            SortedSet <int> .Enumerator ssEtor = ss.GetEnumerator();
            bool ssNext1 = ssEtor.MoveNext();

            ssEtor.Dispose();
            bool ssNext2 = ssEtor.MoveNext();

            Console.WriteLine("Dispose() then MoveNext() = " + ssNext2);
            Console.WriteLine("Dispose() then Current = " + ssEtor.Current);
        }
コード例 #4
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 5
            };

            Console.WriteLine("Create sequentially loaded tree of order 5:");
            for (int i = 2; i <= 10; i += 2)
            {
                set.Add(i);
            }
            WriteInfo(true);

            Console.WriteLine("Add 12-40:");
            for (int i = 12; i <= 40; i += 2)
            {
                set.Add(i);
            }
            WriteInfo(true);

            Console.WriteLine("Add 42:");
            set.Add(42);
            WriteInfo(true);
        }
コード例 #5
0
        public void UnitRsc_SetEquals2()
        {
#if TEST_BCL
            var cp = SortedSet <User> .CreateSetComparer();

            var user1 = new SortedSet <User>(new UserComparer());
            var user2 = new SortedSet <User>(new UserComparer());
#else
            var cp = RankedSet <User> .CreateSetComparer();

            var user1 = new RankedSet <User>(new UserComparer());
            var user2 = new RankedSet <User>(new UserComparer());
#endif
            bool eq0 = cp.Equals(user1, user2);
            Assert.IsTrue(eq0);

            user1.Add(new User("admin"));
            user2.Add(new User("tester"));
            bool eq1 = cp.Equals(user1, user2);
            Assert.IsFalse(eq1);

            user1.Add(new User("tester"));
            user2.Add(new User("admin"));
            bool eq2 = cp.Equals(user1, user2);
            Assert.IsTrue(eq2);
        }
コード例 #6
0
        static void Main()
        {
            var set1 = new RankedSet <int> {
                3, 5, 7
            };
            var set2 = new RankedSet <int> {
                5, 7
            };
            var set3 = new RankedSet <int> {
                1, 9
            };
            var set4 = new RankedSet <int> {
                5, 9
            };
            var arg5 = new int[] { 5, 9, 9 };

            bool isSub1  = set2.IsSubsetOf(set1);
            bool isSub2  = set2.IsSubsetOf(set2);
            bool isSub3  = set4.IsSubsetOf(set2);
            bool isSup1  = set1.IsSupersetOf(set2);
            bool isSup2  = set2.IsSupersetOf(set2);
            bool isSup3  = set2.IsSupersetOf(set4);
            bool isPSub1 = set2.IsProperSubsetOf(set1);
            bool isPSub2 = set2.IsProperSubsetOf(set2);
            bool isPSup1 = set1.IsProperSupersetOf(set2);
            bool isPSup2 = set2.IsProperSupersetOf(set2);
            bool isOlap1 = set1.Overlaps(set4);
            bool isOlap2 = set1.Overlaps(set3);
            bool isEq1   = set4.SetEquals(set4);
            bool isEq2   = set4.SetEquals(set3);
            bool isEq3   = set4.SetEquals(arg5);

            Console.WriteLine($"{Text(set2)} IsSubsetOf {Text(set1)} = {isSub1}");
            Console.WriteLine($"{Text(set2)} IsSubsetOf {Text(set2)} = {isSub2}");
            Console.WriteLine($"{Text(set4)} IsSubsetOf {Text(set2)} = {isSub3}");
            Console.WriteLine();

            Console.WriteLine($"{Text(set1)} IsSupersetOf {Text(set2)} = {isSup1}");
            Console.WriteLine($"{Text(set2)} IsSupersetOf {Text(set2)} = {isSup2}");
            Console.WriteLine($"{Text(set2)} IsSupersetOf {Text(set4)} = {isSup3}");
            Console.WriteLine();

            Console.WriteLine($"{Text(set2)} IsProperSubsetOf {Text(set1)} = {isPSub1}");
            Console.WriteLine($"{Text(set2)} IsProperSubsetOf {Text(set2)} = {isPSub2}");
            Console.WriteLine();

            Console.WriteLine($"{Text(set1)} IsProperSupersetOf {Text(set2)} = {isPSup1}");
            Console.WriteLine($"{Text(set2)} IsProperSupersetOf {Text(set2)} = {isPSup2}");
            Console.WriteLine();

            Console.WriteLine($"{Text(set1)} Overlaps {Text(set4)} = {isOlap1}");
            Console.WriteLine($"{Text(set1)} Overlaps {Text(set3)} = {isOlap2}");
            Console.WriteLine();

            Console.WriteLine($"{Text(set4)} SetEquals {Text(set4)} = {isEq1}");
            Console.WriteLine($"{Text(set4)} SetEquals {Text(set3)} = {isEq2}");
            Console.WriteLine($"{Text(set4)} SetEquals {Text(arg5)} = {isEq3}");
            Console.WriteLine();
        }
コード例 #7
0
 public OrderBook()
 {
     // Always want a single limit so we can have less checks in the Ask and Bid methods.
     Limits = new RankedSet <Limit>(new LimitPriceComparer())
     {
         new Limit {
             Price = 1 * ScaleFactor
         }
     };
     Subscriptions = new Dictionary <long, Subscription>();
     Orders        = new Dictionary <long, Order>();
 }
コード例 #8
0
ファイル: RsBench01.cs プロジェクト: kaosborn/KaosCollections
        static void Main()
        {
            int  maxN    = 500000;
            var  watch   = new Stopwatch();
            bool isPass1 = true;

            Console.WriteLine("Removals in Thousands,Set Size in Thousands,RankedSet,SortedSet");

            for (int n = maxN / 10; n <= maxN;)
            {
                var c1 = new RankedSet <int>();
                for (int i = 0; i < n; ++i)
                {
                    c1.Add(i);
                }
                watch.Reset(); watch.Start();
                c1.RemoveWhere(IsCull);
                var c1Time  = watch.ElapsedMilliseconds;
                int c1Count = c1.Count; c1.Clear();

                var c2 = new SortedSet <int>();
                for (int i = 0; i < n; ++i)
                {
                    c2.Add(i);
                }
                watch.Reset(); watch.Start();
                c2.RemoveWhere(IsCull);
                var c2Time  = watch.ElapsedMilliseconds;
                int c2Count = c2.Count; c2.Clear();

                int removes = n * division / divisionCount;
                if (c1Count != n - removes || c2Count != n - removes)
                {
                    Console.WriteLine($"*** ERROR *** {c1Count}, {c2Count}");
                }

                if (isPass1)
                {
                    isPass1 = false;
                }
                else
                {
                    Console.WriteLine($"{removes/1000},{n/1000},{c1Time},{c2Time}");
                    n += maxN / 10;
                }
            }
        }
コード例 #9
0
        static void Main()
        {
            var rs = new RankedSet <int> {
                3, 5, 7
            };

            Console.WriteLine("Set items must be distinct:");
            foreach (var item in rs)
            {
                Console.WriteLine(item);
            }

            var rd = new RankedDictionary <int, int> {
                { 3, 0 }, { 1, 11 }, { 5, 0 }, { 9, 99 }
            };

            Console.WriteLine("\nDictionary keys must be distinct:");
            foreach (var kv in rd)
            {
                Console.WriteLine(kv);
            }
            Console.WriteLine("Just the keys: { " + String.Join(",", rd.Keys) + " }");
            Console.WriteLine("Just the values: { " + String.Join(",", rd.Values) + " }");

            var rb = new RankedBag <int> {
                1, 2, 2, 3
            };

            Console.WriteLine("\nBag items may repeat:");
            foreach (var bx in rb)
            {
                Console.WriteLine(bx);
            }

            var rm = new RankedMap <int, int> {
                { 2, 0 }, { 4, 0 }, { 4, 44 }, { 6, 66 }
            };

            Console.WriteLine("\nMap keys may repeat:");
            foreach (var kv in rm)
            {
                Console.WriteLine(kv);
            }
            Console.WriteLine("Just the keys: { " + String.Join(",", rm.Keys) + " }");
            Console.WriteLine("Just the values: { " + String.Join(",", rm.Values) + " }");
        }
コード例 #10
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 6
            };

            Console.WriteLine("Create sequentially loaded tree of order 6:");
            for (int i = 2; i <= 60; i += 2)
            {
                set.Add(i);
            }
            WriteInfo(true);

            Console.WriteLine("Create rightmost nodes with 1 key by appending 62:");
            set.Add(62);
            WriteInfo();

            Console.WriteLine("Split leaf by adding 5:");
            set.Add(5);
            WriteInfo();

            Console.WriteLine("Split leaf, cascade split branches by adding 25:");
            set.Add(25);
            WriteInfo();

            Console.WriteLine("Balance leaves, replace 2 pivots by removing 6:");
            set.Remove(6);
            WriteInfo();

            Console.WriteLine("Prune leaf by removing 62:");
            set.Remove(62);
            WriteInfo();

            Console.WriteLine("Remove 54-60:");
            set.Remove(54);
            set.Remove(56);
            set.Remove(58);
            set.Remove(60);
            WriteInfo();

            Console.WriteLine("Prune leaf and branch by removing 52:");
            set.Remove(52);
            WriteInfo();
        }
コード例 #11
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 5
            };

            Console.WriteLine("Create sequentially loaded tree of order 5:");
            for (int i = 2; i <= 66; i += 2)
            {
                set.Add(i);
            }
            WriteInfo();

            Console.WriteLine("Thin the tree by removing several keys:");
            foreach (int i in new int[] { 4, 6, 14, 16, 18, 20, 22, 24, 26, 30, 36, 38, 46 })
            {
                set.Remove(i);
            }
            WriteInfo();

            Console.WriteLine("Coalesce leaves, balance branches by removing 12:");
            set.Remove(12);
            WriteInfo();

            Console.WriteLine("Change a branch by removing 10:");
            set.Remove(10);
            WriteInfo();

            Console.WriteLine("Change the root by removing 50:");
            set.Remove(50);
            WriteInfo();

            Console.WriteLine("Coalesce leaves by removing 40:");
            set.Remove(40);
            WriteInfo();

            Console.WriteLine("Prune rightmost leaf by removing 66:");
            set.Remove(66);
            WriteInfo();

            Console.WriteLine("Coalesce leaves and branches, prune root by removing 8:");
            set.Remove(8);
            WriteInfo();
        }
コード例 #12
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 4
            };

            Console.WriteLine("Create tree of order 4:");
            for (int i = 2; i <= 50; i += 2)
            {
                set.Add(i);
            }

            for (int i = 3; i <= 50; i += 6)
            {
                set.Add(i);
            }
            WriteInfo();

            Console.WriteLine("Add 29,35:");
            set.Add(29);
            set.Add(35);
            WriteInfo();

            Console.WriteLine("Remove 27:");
            set.Remove(27);
            WriteInfo();

            Console.WriteLine("Remove 21:");
            set.Remove(21);
            WriteInfo();

            Console.WriteLine("Remove 22:");
            set.Remove(22);
            WriteInfo();

            Console.WriteLine("Remove 24:");
            set.Remove(24);
            WriteInfo();
        }
コード例 #13
0
        static void Main()
        {
            for (int width = 1; ; ++width)
            {
                Console.Write(width + " ");
                for (int count = 0; count <= width; ++count)
                {
                    for (int index = 0; index <= width - count; ++index)
                    {
                        for (int order = 4; order <= 7; ++order)
                        {
                            set = new RankedSet <int> {
                                Capacity = order
                            };
                            for (int ii = 0; ii < width; ++ii)
                            {
                                set.Add(ii);
                            }

                            try
                            {
                                set.RemoveRange(index, count);

                                Debug.Assert(set.Count == width - count);
                                Debug.Assert(set.Count == set.Count());
                                Debug.Assert(set.Count == set.Reverse().Count());
#if DEBUG
                                set.SanityCheck();
#endif
                            }
                            catch (Exception)
                            {
                                Console.WriteLine($"\nwidth={width}, index={index}, count={count}, order={order}");
                                throw;
                            }
                        }
                    }
                }
            }
        }
コード例 #14
0
        static void Main()
        {
            var set = new RankedSet <int> {
                3, 5, 7
            };
            var arg = new int[] { 5, 7, 9 };

            var ew = new RankedSet <int> (set);
            var iw = new RankedSet <int> (set);
            var se = new RankedSet <int> (set);
            var uw = new RankedSet <int> (set);

            ew.ExceptWith(arg);
            iw.IntersectWith(arg);
            se.SymmetricExceptWith(arg);
            uw.UnionWith(arg);

            Console.WriteLine($"{Text(set)} ExceptWith {Text(arg)} = {Text(ew)}");
            Console.WriteLine($"{Text(set)} IntersectWith {Text(arg)} = {Text(iw)}");
            Console.WriteLine($"{Text(set)} SymmetricExceptWith {Text(arg)} = {Text(se)}");
            Console.WriteLine($"{Text(set)} UnionWith {Text(arg)} = {Text(uw)}");
        }
コード例 #15
0
        static void Main()
        {
            for (int i = 1; i <= 12; i += 1)
            {
                var set = new RankedSet <int>()
                {
                    Capacity = 4
                };

                foreach (int kk in new int[] { 3, 5, 6, 7, 9, 10, 11 })
                {
                    set.Add(kk);
                }
                set.Remove(6); set.Remove(10);
                WriteInfo(set);

                set.SymmetricExceptWith(new int[] { i });
                Console.WriteLine("SymmetricExceptWith " + i + ":");
                WriteInfo(set);
                Console.WriteLine("----");
            }
        }
コード例 #16
0
        public void UnitRsc_Equals()
        {
#if TEST_BCL
            var setComparer2 = SortedSet <string> .CreateSetComparer();

            var setComparer3 = SortedSet <int> .CreateSetComparer();
#else
            var setComparer2 = RankedSet <string> .CreateSetComparer();

            var setComparer3 = RankedSet <int> .CreateSetComparer();
#endif
            bool eq0 = setComparer.Equals(null);
            Assert.IsFalse(eq0);

            bool eq1 = setComparer.Equals(setComparer);
            Assert.IsTrue(eq1);

            bool eq2 = setComparer.Equals(setComparer2);
            Assert.IsTrue(eq2);

            bool eq3 = setComparer.Equals(setComparer3);
            Assert.IsFalse(eq3);
        }
コード例 #17
0
        static void Main()
        {
            var set1 = new RankedSet <Person> (new PersonComparer());

            set1.Add(new Person("Hugh", "Mann"));
            set1.Add(new Person("Hammond", "Egger"));

            string     fileName  = "Persons.bin";
            IFormatter formatter = new BinaryFormatter();

            SerializePersons(fileName, set1, formatter);
            Console.WriteLine($"Wrote {set1.Count} items to file '{fileName}'.");
            Console.WriteLine();

            RankedSet <Person> set2 = DeserializePersons(fileName, formatter);

            Console.WriteLine($"Read back {set2.Count} items:");

            foreach (var p2 in set2)
            {
                Console.WriteLine(p2);
            }
        }
コード例 #18
0
 public static void SerializePersons(string fn, RankedSet <Person> set, IFormatter formatter)
 {
     using (var fs = new FileStream(fn, FileMode.Create))
     { formatter.Serialize(fs, set); }
 }
コード例 #19
0
        static void Main()
        {
            var names1 = new string[] { "Falco", "Nico", "David Bowie", "Tom Petty", "Joni Mitchell", "Warren Zevon" };
            var names2 = new string[] { "Michelangelo", "Rembrandt", "Joni Mitchell", "David Bowie" };

            var musicians = new RankedSet <string> (names1);

            // Remove mononymous items.
            Console.WriteLine("Remove single names from the set...");
            Console.WriteLine($"  Count before: {musicians.Count}");
            musicians.RemoveWhere(IsMononymous);
            Console.WriteLine($"  Count after: {musicians.Count}\n");

            // List names starting with 'J'.
            Console.WriteLine("Musicians J-T");
            foreach (var name in musicians.ElementsBetween("J", "U"))
            {
                Console.WriteLine($"  {name}");
            }

            // Create another RankedSet.
            var painters = new RankedSet <string> (names2);

            // Remove elements in musicians that are also in painters.
            Console.WriteLine("\nRemove duplicates (of painters) from the musicians...");
            Console.WriteLine($"  Count before: {musicians.Count}");
            musicians.ExceptWith(painters);
            Console.WriteLine($"  Count after: {musicians.Count}\n");

            Console.WriteLine("List of musicians that are not painters:");
            foreach (string name in musicians)
            {
                Console.WriteLine($"  {name}");
            }

            var comp = RankedSet <string> .CreateSetComparer();

            HashSet <RankedSet <string> > setOfSets = new HashSet <RankedSet <string> > (comp);

            setOfSets.Add(musicians);
            setOfSets.Add(painters);

            Console.WriteLine("\nAll sets in hash set:");
            foreach (var set in setOfSets)
            {
                Console.WriteLine($"  {set.Count} items:");
                foreach (var item in set)
                {
                    Console.WriteLine($"    {item}");
                }
            }

            // Create a 3rd RankedSet.
            var people = new RankedSet <string> {
                "Tom Petty", "Warren Zevon"
            };

            // Create a set equality comparer.
            var comparer = RankedSet <string> .CreateSetComparer();

            Console.WriteLine($"\nSet comparison 1: {comparer.Equals (musicians, people)}");
            Console.WriteLine($"Set comparison 2: {comparer.Equals (painters, people)}");
        }
コード例 #20
0
        static void Main()
        {
            set = new RankedSet <int>()
            {
                Capacity = 4
            };

            Console.WriteLine("Create sequentially loaded tree of order 4:");
            for (int i = 2; i <= 44; i += 2)
            {
                set.Add(i);
            }
            WriteInfo();

            Console.WriteLine("Add 1,21:");
            set.Add(1);
            set.Add(21);
            WriteInfo();

            Console.WriteLine("Add 9:");
            set.Add(9);
            WriteInfo();

            Console.WriteLine("Add 27:");
            set.Add(27);
            WriteInfo();

            Console.WriteLine("Remove 44:");
            set.Remove(44);
            WriteInfo();

            Console.WriteLine("Remove 40,42:");
            set.Remove(40);
            set.Remove(42);
            WriteInfo();

            Console.WriteLine("Remove 38:");
            set.Remove(38);
            WriteInfo();

            Console.WriteLine("Remove 34,36:");
            set.Remove(34);
            set.Remove(36);
            WriteInfo();

            Console.WriteLine("Remove 32:");
            set.Remove(32);
            WriteInfo();

            Console.WriteLine("Remove 28:");
            set.Remove(28);
            WriteInfo();

            Console.WriteLine("Seek 30:");
            var isOk = set.Contains(30);

            Console.WriteLine();
            Console.WriteLine("Result = " + isOk);
            Console.WriteLine();

            Console.WriteLine("Remove 30:");
            set.Remove(30);
            WriteInfo();
        }
コード例 #21
0
        static void Main()
        {
            Console.WriteLine("RankedBag: ");

            #region RbSkip

            var bag = new RankedSet <int>()
            {
                295
            };
            for (var i = 2; i < 500; i += 2)
            {
                bag.Add(i);
            }

            foreach (int x in bag.Skip(100).SkipWhile(i => i % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: 494 496 498

            #endregion

            Console.WriteLine("\nRankedSet: ");

            #region RsSkip

            var set = new RankedSet <int>()
            {
                295
            };
            for (int i = 2; i < 500; i += 2)
            {
                set.Add(i);
            }

            foreach (var x in set.Skip(100).SkipWhile(i => i % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: 494 496 498

            #endregion

            Console.WriteLine("\nRankedDictionary: ");

            #region RdSkip

            var dary = new RankedDictionary <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                dary.Add(i, -i);
            }

            foreach (var x in dary.Skip(100).SkipWhile(kv => kv.Key % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: [494, -494] [496, -496] [498, -498]

            #endregion


            Console.WriteLine("\nRankedDictionary.Keys: ");

            #region RdkSkip

            var daryk = new RankedMap <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                daryk.Add(i, -i);
            }

            foreach (var x in daryk.Keys.Skip(100).SkipWhile(k => k % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: 494 496 498

            #endregion

            Console.WriteLine("\nRankedDictionary.Values: ");

            #region RdvSkip

            var daryv = new RankedMap <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                daryv.Add(i, -i);
            }

            foreach (var x in daryv.Values.Skip(100).SkipWhile(k => k % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: -494 -496 -498

            #endregion

            Console.WriteLine("\nRankedMap: ");

            #region RmSkip

            var map = new RankedMap <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                map.Add(i, -i);
            }

            foreach (var x in map.Skip(100).SkipWhile(kv => kv.Key % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: [494, -494] [496, -496] [498, -498]

            #endregion

            Console.WriteLine("\nRankedMap.Keys: ");

            #region RmkSkip

            var mapk = new RankedMap <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                mapk.Add(i, -i);
            }

            foreach (var x in mapk.Keys.Skip(100).SkipWhile(k => k % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: 494 496 498

            #endregion

            Console.WriteLine("\nRankedMap.Values: ");

            #region RmvSkip

            var mapv = new RankedMap <int, int>()
            {
                { 295, -295 }
            };
            for (int i = 2; i < 500; i += 2)
            {
                mapv.Add(i, -i);
            }

            foreach (var x in mapv.Values.Skip(100).SkipWhile(k => k % 2 == 0).Skip(100))
            {
                Console.Write($"{x} ");
            }

            // Output: -494 -496 -498

            #endregion

            Console.WriteLine();
        }