public void TestBagNoItem() { var bag = new TreeBag <string>(); Assert.Throws(typeof(InvalidOperationException), () => bag.Max); Assert.Throws(typeof(InvalidOperationException), () => bag.Min); }
// Given a sequence of strings, return all non-trivial anagram // classes. Should use a *sequenced* equalityComparer on a TreeBag<char>, // obviously: after all, characters can be sorted by ASCII code. On // 347 000 distinct Danish words this takes 70 cpu seconds, 180 MB // memory, and 263 wall-clock seconds (due to swapping). // Using a TreeBag<char> and a sequenced equalityComparer takes 82 cpu seconds // and 180 MB RAM to find the 26,058 anagram classes among 347,000 // distinct words. // Using an unsequenced equalityComparer on TreeBag<char> or HashBag<char> // makes it criminally slow: at least 1200 cpu seconds. This must // be because many bags get the same hash code, so that there are // many collisions. But exactly how the unsequenced equalityComparer works is // not clear ... or is it because unsequenced equality is slow? public static SCG.IEnumerable <SCG.IEnumerable <String> > AnagramClasses(SCG.IEnumerable <String> ss) { bool unseq = true; IDictionary <TreeBag <char>, TreeSet <String> > classes; if (unseq) { SCG.IEqualityComparer <TreeBag <char> > unsequencedTreeBagEqualityComparer = UnsequencedCollectionEqualityComparer <TreeBag <char>, char> .Default; classes = new HashDictionary <TreeBag <char>, TreeSet <String> >(unsequencedTreeBagEqualityComparer); } else { SCG.IEqualityComparer <TreeBag <char> > sequencedTreeBagEqualityComparer = SequencedCollectionEqualityComparer <TreeBag <char>, char> .Default; classes = new HashDictionary <TreeBag <char>, TreeSet <String> >(sequencedTreeBagEqualityComparer); } foreach (String s in ss) { TreeBag <char> anagram = AnagramClass(s); TreeSet <String> anagramClass; if (!classes.Find(ref anagram, out anagramClass)) { classes[anagram] = anagramClass = new TreeSet <String>(); } anagramClass.Add(s); } foreach (TreeSet <String> anagramClass in classes.Values) { if (anagramClass.Count > 1) { yield return(anagramClass); } } }
// From an anagram point of view, a word is just a bag of // characters. So an anagram class is represented as TreeBag<char> // which permits fast equality comparison -- we shall use them as // elements of hash sets or keys in hash maps. public static TreeBag<char> AnagramClass(String s) { TreeBag<char> anagram = new TreeBag<char>(SCG.Comparer<char>.Default, EqualityComparer<char>.Default); foreach (char c in s) anagram.Add(c); return anagram; }
public void TestTreeBagConstructors() { var bag1 = new TreeBag <string>(); Fill(bag1, x => x.ToString(CultureInfo.InvariantCulture)); BagConstructorOperations(bag1); var bag2 = new TreeBag <Order>((x1, x2) => x1.Id - x2.Id); Fill(bag2, x => new Order { Id = x }); BagConstructorOperations(bag2); var bag3 = new TreeBag <string>(bag1); BagConstructorOperations(bag3); var bag4 = new TreeBag <Order>(new OrderComparer()); Fill(bag4, x => new Order { Id = x }); BagConstructorOperations(bag4); var bag5 = new TreeBag <Order>(bag4, new OrderComparer().Compare); BagConstructorOperations(bag5); }
public static void Main() { KeyValuePair <int, int> pair = new KeyValuePair <int, int> (3, 89); KeyValuePairComparer <int, int> comparer = new KeyValuePairComparer <int, int> (); TreeBag <KeyValuePair <int, int> > bag = new TreeBag <KeyValuePair <int, int> > (comparer, pair); bag.Find(); }
public void TestTreeBagCollectionOperations() { var bag = new TreeBag <Order>(new OrderComparer()); bag.Fill(x => new Order { Id = x }); bag.CollectionOperations <Order>(bag.Count); }
// From an anagram point of view, a word is just a bag of // characters. So an anagram class is represented as TreeBag<char> // which permits fast equality comparison -- we shall use them as // elements of hash sets or keys in hash maps. public static TreeBag <char> AnagramClass(String s) { TreeBag <char> anagram = new TreeBag <char>(SCG.Comparer <char> .Default, EqualityComparer <char> .Default); foreach (char c in s) { anagram.Add(c); } return(anagram); }
public static TreeBag <char> TreeBag(String s) { TreeBag <char> anagram = new TreeBag <char>(); foreach (char c in s) { anagram.Add(c); } return(anagram); }
public TreeBag <T> CopyToTreeBag <T>(ICollection <T> lst) { TreeBag <T> lstCopy = new TreeBag <T>(); foreach (var item in lst) { lstCopy.Add((T)item); } return(lstCopy); }
private TreeBag <Widget>[] InstantiateLookups() { C5.TreeBag <Widget>[] instance = new C5.TreeBag <Widget> [Widget.ValueCount]; for (int i = 0; i < instance.Length; ++i) { Widget.Comparer widgetComparer = new Widget.Comparer(i); instance[i] = new TreeBag <Widget>(widgetComparer, widgetComparer); } return(instance); }
// From an anagram point of view, a word is just a bag of // characters. So an anagram class is represented as TreeBag<char> // which permits fast equality comparison -- we shall use them as // elements of hash sets or keys in hash maps. // From an anagram point of view, a word is just a bag of // characters. So an anagram class is represented as HashBag<char> // which permits fast equality comparison -- we shall use them as // elements of hash sets or keys in hash maps. static TreeBag <char> AnagramClass(string s) { var anagram = new TreeBag <char>(); foreach (char c in s) { anagram.Add(c); } return(anagram); }
public void TestTreeMapSpecialOperation() { var bag = new TreeBag <Order>((x1, x2) => x1.Id - x2.Id); for (var i = 0; i < 1000; i++) { bag.Add(new Order { Id = i + 1 }); } Assert.Equal(1, bag.Min.Id); Assert.Equal(1000, bag.Max.Id); }
public static void FindCollisions(SCG.IEnumerable <String> ss) { HashBag <int> occurrences = new HashBag <int>(); foreach (String s in ss) { TreeBag <char> tb = TreeBag(s); // HashBag<char> hb = HashBag(s); occurrences.Add(sequencedTreeBagHasher.GetHashCode(tb)); // unsequencedTreeBagHasher.GetHashCode(tb); // unsequencedHashBagHasher.GetHashCode(hb); } }
// Given a sequence of strings, return only the first member of each // anagram class. public static SCG.IEnumerable <String> FirstAnagramOnly(SCG.IEnumerable <String> ss) { HashSet <TreeBag <char> > anagrams = new HashSet <TreeBag <char> >(); foreach (String s in ss) { TreeBag <char> anagram = AnagramClass(s); if (!anagrams.Contains(anagram)) { anagrams.Add(anagram); yield return(s); } } }
// Given a sequence of strings, return only the first member of each // anagram class. public static SCG.IEnumerable <String> FirstAnagramOnly(SCG.IEnumerable <String> ss) { SCG.IEqualityComparer <TreeBag <char> > tbh = UnsequencedCollectionEqualityComparer <TreeBag <char>, char> .Default; HashSet <TreeBag <char> > anagrams = new HashSet <TreeBag <char> >(tbh); foreach (String s in ss) { TreeBag <char> anagram = AnagramClass(s); if (!anagrams.Contains(anagram)) { anagrams.Add(anagram); yield return(s); } } }
public override void CreateNewInstanceOfInternalC5DataStructure(C5DataStructure dataStructure) { switch (dataStructure) { case C5DataStructure.ArrayList: InternalC5DataStructure = new ArrayList <T>(); break; case C5DataStructure.LinkedList: InternalC5DataStructure = new LinkedList <T>(); break; case C5DataStructure.HashBag: InternalC5DataStructure = new HashBag <T>(); break; case C5DataStructure.TreeBag: InternalC5DataStructure = new TreeBag <T>(); break; case C5DataStructure.HashedArrayList: InternalC5DataStructure = new HashedArrayList <T>(); break; case C5DataStructure.HashedLinkedList: InternalC5DataStructure = new HashedLinkedList <T>(); break; case C5DataStructure.SortedArray: InternalC5DataStructure = new SortedArray <T>(); break; case C5DataStructure.HashSet: InternalC5DataStructure = new HashSet <T>(); break; case C5DataStructure.TreeSet: InternalC5DataStructure = new TreeSet <T>(); break; default: throw new ArgumentException("Unknown C5 Collection name"); } }
AnagramClasses(SCG.IEnumerable <String> ss) { IDictionary <TreeBag <char>, TreeSet <String> > classes; classes = new HashDictionary <TreeBag <char>, TreeSet <String> >(); foreach (String s in ss) { TreeBag <char> anagram = AnagramClass(s); if (!classes.Find(ref anagram, out TreeSet <string> anagramClass)) { classes[anagram] = anagramClass = new TreeSet <String>(); } anagramClass.Add(s); } foreach (TreeSet <String> anagramClass in classes.Values) { if (anagramClass.Count > 1) { yield return(anagramClass); } } }
public static TreeBag<char> TreeBag(String s) { TreeBag<char> anagram = new TreeBag<char>(); foreach (char c in s) anagram.Add(c); return anagram; }
public TreePrimes(int endOfRange) { EndOfRange = endOfRange; Primes = new TreeBag<int>(); Primes.AddAll(Enumerable.Range(2,endOfRange - 1).ToList()); }
public void TestTreeBagOperation() { var bag = new TreeBag <Order>((x1, x2) => x1.Id - x2.Id); TestBagOperation(bag); }
public static void Main(String[] args) { var list = new TreeBag<long>(); // Sequence generated in FindNodeRandomTest list.Add(553284); list.Add(817435); list.Remove(817435); list.Add(155203); list.Add(316201); list.Remove(316201); list.Add(145375); list.Remove(155203); list.Add(155203); list.Add(150788); list.Remove(145375); list.Add(316201); list.Add(263469); list.Add(263469); list.Add(441406); list.Add(553284); list.Remove(553284); list.Add(553284); list.Remove(150788); list.Add(769005); list.Add(263469); list.Remove(316201); list.Add(553284); list.Remove(769005); list.Add(316201); list.Remove(263469); list.Add(817435); list.Add(553284); list.Remove(316201); list.Add(150788); // list.Add(0.553284f); // list.Add(0.8174357f); // list.Remove(0.8174357f); // list.Add(0.1552035f); // list.Add(0.3162012f); // list.Remove(0.3162012f); // list.Add(0.1453752f); // list.Remove(0.1552035f); // list.Add(0.1552035f); // list.Add(0.1507881f); // list.Remove(0.1453752f); // list.Add(0.3162012f); // list.Add(0.2634694f); // list.Add(0.2634694f); // list.Add(0.4414065f); // list.Add(0.553284f); // list.Remove(0.553284f); // list.Add(0.553284f); // list.Remove(0.1507881f); // list.Add(0.7690055f); // list.Add(0.2634694f); // list.Remove(0.3162012f); // list.Add(0.553284f); // list.Remove(0.7690055f); // list.Add(0.3162012f); // list.Remove(0.2634694f); // list.Add(0.8174357f); // list.Add(0.553284f); // list.Remove(0.3162012f); // list.Add(0.1507881f); Console.WriteLine(list); Console.WriteLine(list.Count > 3); Console.WriteLine(list[0]); Console.WriteLine(list[1]); Console.WriteLine(list[2]); // Throws! // Console.WriteLine(list[0,1]); // Console.WriteLine(list[1,1]); // Console.WriteLine(list[2,1]); // Worse: Throws too! }
public static void Main(String[] args) { var list = new TreeBag <long>(); // Sequence generated in FindNodeRandomTest list.Add(553284); list.Add(817435); list.Remove(817435); list.Add(155203); list.Add(316201); list.Remove(316201); list.Add(145375); list.Remove(155203); list.Add(155203); list.Add(150788); list.Remove(145375); list.Add(316201); list.Add(263469); list.Add(263469); list.Add(441406); list.Add(553284); list.Remove(553284); list.Add(553284); list.Remove(150788); list.Add(769005); list.Add(263469); list.Remove(316201); list.Add(553284); list.Remove(769005); list.Add(316201); list.Remove(263469); list.Add(817435); list.Add(553284); list.Remove(316201); list.Add(150788); // list.Add(0.553284f); // list.Add(0.8174357f); // list.Remove(0.8174357f); // list.Add(0.1552035f); // list.Add(0.3162012f); // list.Remove(0.3162012f); // list.Add(0.1453752f); // list.Remove(0.1552035f); // list.Add(0.1552035f); // list.Add(0.1507881f); // list.Remove(0.1453752f); // list.Add(0.3162012f); // list.Add(0.2634694f); // list.Add(0.2634694f); // list.Add(0.4414065f); // list.Add(0.553284f); // list.Remove(0.553284f); // list.Add(0.553284f); // list.Remove(0.1507881f); // list.Add(0.7690055f); // list.Add(0.2634694f); // list.Remove(0.3162012f); // list.Add(0.553284f); // list.Remove(0.7690055f); // list.Add(0.3162012f); // list.Remove(0.2634694f); // list.Add(0.8174357f); // list.Add(0.553284f); // list.Remove(0.3162012f); // list.Add(0.1507881f); Console.WriteLine(list); Console.WriteLine(list.Count > 3); Console.WriteLine(list[0]); Console.WriteLine(list[1]); Console.WriteLine(list[2]); // Throws! // Console.WriteLine(list[0,1]); // Console.WriteLine(list[1,1]); // Console.WriteLine(list[2,1]); // Worse: Throws too! }