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!
}
