private static void OrthohonateAt(List<IntSet> sets, IntSet x, int xIndex) { for (int j = 0; j != sets.Count; ++j) { if (j == xIndex) { continue; } var y = sets[j]; if (y.Count == 0) { continue; } IntSet common, xOnly, yOnly; if (x.Rel(y, out xOnly, out common, out yOnly)) { x = sets[xIndex] = xOnly; sets[j] = yOnly; sets.Insert(xIndex + 1, common); ++j; } } }
static void Main(string[] args) { IntSet A = new IntSet(33); IntSet B = new IntSet(33); A.Insert(5); A.Insert(30); A.Insert(23); B.Insert(5); B.Insert(24); B.Insert(9); Console.WriteLine("A集合:{0};{1}", A.GetBitString(), A.GetElements()); Console.WriteLine("B集合:{0};{1}", B.GetBitString(), B.GetElements()); IntSet C; C = A.Union(B); Console.WriteLine("A并B :{0}:{1}", C.GetBitString(), C.GetElements()); C = A.Intersect(B); Console.WriteLine("A交B :{0}:{1}", C.GetBitString(), C.GetElements()); C = A.DiffSet(B); Console.WriteLine("A差B :{0}:{1}", C.GetBitString(), C.GetElements()); C = A.Complement(); Console.WriteLine("A的补:{0}:{1}", C.GetBitString(), C.GetElements()); }
// Verifies the following properties of an IntSet: // 1. The integers are in order. // 2. There are no duplicates. // 3. The overall count is the same as the sum of the range counts. // 4. There are no empty ranges. // 5. No two adjacent ranges can be combined. public void Verify(IntSet intSet) { // iterate by ranges int manualCount = 0; IntSet.Range previousRange = null; foreach (IntSet.Range range in intSet.Ranges) { if (previousRange != null) Assert.True(previousRange.Max + 1 < range.Min); previousRange = range; Assert.True(range.Min <= range.Max); Assert.True(range.Count > 0); Assert.True(range.PreviousItemsCount == manualCount); manualCount += range.Count; } Assert.True(manualCount == intSet.Count); // iterate by integers manualCount = 0; int previousItem = int.MinValue; foreach (int item in intSet) { Assert.True(previousItem < item); previousItem = item; manualCount++; } Assert.True(manualCount == intSet.Count); }
public static void OrthohonalAdd(List<IntSet> sets, IntSet x) { if (x.IsEmpty || sets.IndexOf(x) >= 0) { return; } int i = sets.Count; sets.Add(x); OrthohonateAt(sets, x, i); }
internal static int IndexOfState(this ITdfaData @this, IntSet positionSet) { int count = @this.StateCount; for (int i = 0; i != count; ++i) { if (@this.GetState(i).Positions.Equals(positionSet)) { return i; } } return -1; }
public RegularTree(AstNode root) { this.EoiCharSetNode = CharSetNode.Create(EoiChar); this.AugmentedRoot = new CatNode(new List<AstNode> { root, EoiCharSetNode }); var positionBuilder = new PositionBuilder(); AugmentedRoot.Accept(positionBuilder, null); Positions = positionBuilder.Positions; EoiPosition = Positions.FindIndex(pos => pos.Characters.Contains(EoiChar)); Debug.Assert(EoiPosition >= 0); var firstPosVisitor = new FirstPosGetter(); this.FirstPos = AugmentedRoot.Accept(firstPosVisitor, 0); var followPosBuilder = new FollowPosBuilder(Positions); AugmentedRoot.Accept(followPosBuilder, 0); }
static void Main(string[] args) { IntSet mySet = new IntSet(); HashSet<int> systemSet = new HashSet<int>(); for (int i = 0; i < 10000000; i++) { int a = rand.Next(0, 100); mySet.Add(a); systemSet.Add(a); int b = rand.Next(0, 100); mySet.Remove(b); systemSet.Remove(b); } int[] systemSetArray = systemSet.ToArray(); Array.Sort(systemSetArray); int[] mySetArray = mySet.ToArray(); Console.WriteLine(systemSetArray.SequenceEqual(mySetArray) ? "test passed" : "test failed"); }
public void set_is_optimized(IntSet set) { // TODO: ?? }
protected override IntSet New(IntSet basis, bool inverted, InternalList<IntRange> ranges) { return new PGIntSet(basis.IsCharSet, ranges, inverted, false); }
new public PGIntSet Subtract(IntSet other) { return Intersection(other, true); }
/// <summary> /// Constructor</summary> /// <remarks>As a convenience for client code, preset the supported Unicode characters according /// to the computer's current culture setting. This can be overridden by the /// UnicodeMapper property. /// For 2-character language codes in ISO 639-1: http://www.loc.gov/standards/iso639-2/php/code_list.php . /// For unicode ranges: http://en.wikipedia.org/wiki/Summary_of_Unicode_character_assignments . /// The maximum possible OpenGl display list ID is ushort.MaxValue.</remarks> static OpenGlCore() { s_fontMap = new IntSet(); //add ASCII, Basic Latin, and Latin-1 Supplement s_fontMap.AddRange(0x0000, 0x00FF); //add additional glyphs for some of our client languages string languageCode = CultureInfo.CurrentCulture.TwoLetterISOLanguageName; switch (languageCode) { case "ja"://Japan s_fontMap.AddRange(0x30A0, 0x30FF);//Katakana break; case "nl"://Netherlands (Dutch, Flemis) s_fontMap.AddRange(0x0100, 0x024F);//Latin Extended-A, Latin Extended-B s_fontMap.AddRange(0x1E00, 0x1EFF);//Latin Extended Additional break; default: break; } }
public void when_set_is_empty_popany_is_not_applicable(IntSet set) { Assume.That(set.IsEmpty); MutableIntSet editedSet = set.EditCopy(); int value = editedSet.PopAny(); }
public void set_reports_correct_count(IntSet set) { Assert.AreEqual(set.Count(), set.Count); }
public void set_intersection_returns_correct_result(IntSet x, IntSet y) { var intersection = x.Intersect(y); var hsIntersection = new HashSet<int>(x); hsIntersection.IntersectWith(new HashSet<int>(y)); CollectionAssert.AreEquivalent(hsIntersection, hsIntersection); set_is_optimized(intersection); }
public void set_has_correct_content_after_popany_value(IntSet set) { Assume.That(!set.IsEmpty); MutableIntSet editedSet = set.EditCopy(); int initialCount = editedSet.Count; int value = editedSet.PopAny(); int finalCount = editedSet.Count; Assert.IsFalse(editedSet.Contains(value)); Assert.AreEqual(initialCount, finalCount + 1); }
public void set_has_correct_content_after_adding_set(IntSet set, IntSet other) { MutableIntSet editedSet = set.EditCopy(); editedSet.AddAll(other); Assert.IsTrue(editedSet.IsSupersetOf(other)); Assert.IsTrue(set.Union(other).SetEquals(editedSet)); IntSet result = editedSet.CompleteAndDestroy(); Assert.IsTrue(result.IsSupersetOf(other)); Assert.IsTrue(set.Union(other).SetEquals(result)); }
public void equility_and_hash_to_set_with_different_size_works_according_to_the_content(IntSet x, IntSet yOfSameType) { BitSetType otherSetType = new BitSetType(10); var y = yOfSameType.Intersect(otherSetType.All); bool equals = x.Equals(y); bool setEquals = x.SetEquals(y); bool hsEquals = new HashSet <int>(x).SetEquals(new HashSet <int>(y)); Assert.AreEqual(hsEquals, equals); Assert.AreEqual(hsEquals, setEquals); if (equals) { Assert.AreEqual(x.GetHashCode(), y.GetHashCode()); } else { // Uncomment for hashing failure statistics // Assert.AreNotEqual(x.GetHashCode(), y.GetHashCode()); } }
public void set_has_correct_content_after_adding_value(IntSet set, int value) { MutableIntSet editedSet = set.EditCopy(); Assert.AreEqual(set.Contains(value), editedSet.Contains(value)); editedSet.Add(value); Assert.IsTrue(editedSet.Contains(value)); Assert.IsTrue(editedSet.Contains(value)); Assert.IsTrue(set.Union(IntSet.Of(value)).SetEquals(editedSet)); IntSet result = editedSet.CompleteAndDestroy(); Assert.IsTrue(result.Contains(value)); Assert.IsTrue(set.IsSubsetOf(result)); Assert.IsTrue(set.Union(IntSet.Of(value)).SetEquals(result)); }
public void adding_existing_values_to_set_does_not_change_set(IntSet x, int value) { x = x.Union(IntSet.Of(value)); int countBeforeValueDuplication = x.Count; Assert.IsTrue(x.Contains(value)); x.Union(IntSet.Of(value)); Assert.IsTrue(x.Contains(value)); Assert.AreEqual(countBeforeValueDuplication, x.Count); }
public void set_has_correct_content_after_removing_value(IntSet set, int value) { MutableIntSet editedSet = set.EditCopy(); int initialCount = editedSet.Count; editedSet.Remove(value); int finalCount = editedSet.Count; Assert.IsFalse(editedSet.Contains(value)); Assert.IsTrue(finalCount == initialCount || finalCount + 1 == initialCount); }
public void complement_returns_correct_result(IntSet set) { var got = set.Complement(); foreach (var item in set) { Assert.IsTrue(!got.Contains(item)); } int countToCheck = 1000; foreach (var item in got) { Assert.IsFalse(set.Contains(item)); if (--countToCheck == 0) { break; } } set_is_optimized(got); }
public void complement_with_set_of_different_size_returns_correct_result(IntSet set) { var otherSetType = new BitSetType(10); var y = otherSetType.Of(2, 5, 9); var got = set.Complement(y); foreach (var item in set) { Assert.IsTrue(!got.Contains(item)); } foreach (var item in y) { Assert.IsTrue(got.Contains(item) || set.Contains(item)); } int countToCheck = 1000; foreach (var item in got) { Assert.IsFalse(set.Contains(item)); if (--countToCheck == 0) { break; } } set_is_optimized(got); }
public void set_union_returns_correct_result(IntSet x, IntSet y) { var union = x.Union(y); var hsUnion = new HashSet<int>(x); hsUnion.UnionWith(new HashSet<int>(y)); CollectionAssert.AreEquivalent(hsUnion, union); set_is_optimized(union); }
public void equility_and_hash_to_set_with_different_size_works_according_to_the_content(IntSet x, IntSet yOfSameType) { BitSetType otherSetType = new BitSetType(10); var y = yOfSameType.Intersect(otherSetType.All); bool equals = x.Equals(y); bool setEquals = x.SetEquals(y); bool hsEquals = new HashSet<int>(x).SetEquals(new HashSet<int>(y)); Assert.AreEqual(hsEquals, equals); Assert.AreEqual(hsEquals, setEquals); if (equals) { Assert.AreEqual(x.GetHashCode(), y.GetHashCode()); } else { // Uncomment for hashing failure statistics // Assert.AreNotEqual(x.GetHashCode(), y.GetHashCode()); } }
public void addall_with_set_of_different_size(IntSet set) { var otherSetType = new BitSetType(10); var other = otherSetType.Of(2, 5, 9); MutableIntSet editedSet = set.EditCopy(); editedSet.AddAll(other); Assert.IsTrue(editedSet.IsSupersetOf(other)); Assert.IsTrue(set.Union(other).SetEquals(editedSet)); IntSet result = editedSet.CompleteAndDestroy(); Assert.IsTrue(result.IsSupersetOf(other)); Assert.IsTrue(set.Union(other).SetEquals(result)); }
public void equility_and_hash_works_according_to_the_content(IntSet x, IntSet y) { bool equals = x.Equals(y); bool setEquals = x.SetEquals(y); bool hsEquals = new HashSet<int>(x).SetEquals(new HashSet<int>(y)); Assert.AreEqual(hsEquals, equals); Assert.AreEqual(hsEquals, setEquals); if (equals) { Assert.AreEqual(x.GetHashCode(), y.GetHashCode()); } else { // Uncomment for hashing failure statistics // Assert.AreNotEqual(x.GetHashCode(), y.GetHashCode()); } }
new public PGIntSet Intersection(IntSet other, bool subtract = false, bool subtractThis = false) { return (PGIntSet)base.Intersection(other, subtract, subtractThis); }
public void identical_sets_are_equal() { var sets = new IntSet[] { IntSet.Of(10), IntSet.Of(10), IntSet.Range(10, 10), IntSet.Range(10, 10), IntSet.Ranges( new [] { new IntInterval(10, 10), new IntInterval(10, 10), new IntInterval(10, 10), }), }; for (int i = 0; i != sets.Length; ++i) { var x = sets[i]; for (int j = 0; j != sets.Length; ++j) { var y = sets[j]; Assert.IsTrue(x.Equals(y)); Assert.IsTrue(y.Equals(x)); Assert.IsTrue(x.SetEquals(y)); Assert.IsTrue(y.SetEquals(x)); } } }
public PGIntSet Optimize(IntSet dontcare) { return (PGIntSet)base.Optimize(dontcare); }
public void intersect_with_set_of_different_size(IntSet x) { var otherSetType = new BitSetType(10); var y = otherSetType.Of(2, 5, 9); var intersection = x.Intersect(y); var hsIntersection = new HashSet<int>(x); hsIntersection.IntersectWith(new HashSet<int>(y)); CollectionAssert.AreEquivalent(hsIntersection, hsIntersection); set_is_optimized(intersection); }
public PGIntSet Union(IntSet other) { return (PGIntSet)base.Union(other, true); }
static void Type(IntSet followers) { //Type = "int" | "void" | "bool" | "char" . Accept(FirstType, "Invalid Type"); }