public void CountAndClear()
{
HashedSet <string> set1 = new HashedSet <string>(
StringComparer.InvariantCultureIgnoreCase);
Assert.AreEqual(0, set1.Count);
set1.Add("hello"); Assert.AreEqual(1, set1.Count);
set1.Add("foo"); Assert.AreEqual(2, set1.Count);
set1.Add(""); Assert.AreEqual(3, set1.Count);
set1.Add("HELLO"); Assert.AreEqual(3, set1.Count);
set1.Add("foo"); Assert.AreEqual(3, set1.Count);
set1.Add("Hello"); Assert.AreEqual(3, set1.Count);
set1.Add("Eric"); Assert.AreEqual(4, set1.Count);
set1.Clear();
Assert.AreEqual(0, set1.Count);
bool found = false;
foreach (string s in set1)
{
found = true;
}
Assert.IsFalse(found);
}
static void Main()
{
var set = new HashedSet<int>();
set.Add(5);
set.Add(3);
set.Add(-4);
set.Add(12);
set.Add(0);
set.Add(-50);
set.Add(10);
Console.WriteLine("Set contains 12 -> {0}", set.Find(12));
Console.WriteLine("Set contains 13 -> {0}", set.Find(13));
set.Remove(10);
Console.WriteLine("Removed 10\nSet contains 10 -> {0}", set.Find(10));
Console.WriteLine("Set contains {0} items", set.Count);
Console.WriteLine("Set 1: {0}", set);
var anotherSet = new HashedSet<int>();
anotherSet.Add(-4);
anotherSet.Add(15);
anotherSet.Add(0);
anotherSet.Add(-122);
anotherSet.Add(35);
Console.WriteLine("Set 2: {0}", anotherSet);
set.Union(anotherSet);
Console.WriteLine("Set after union: {0}", set);
set.Intersect(anotherSet);
Console.WriteLine("Set after intersect: {0}", set);
set.Clear();
Console.WriteLine("Set contains {0} items after clear", set.Count);
}
public static void Main()
{
HashedSet<float> firstSet = new HashedSet<float>();
firstSet.Add(1f);
firstSet.Add(1.4f);
firstSet.Add(1.7f);
firstSet.Add(2f);
firstSet.Add(2.2f);
firstSet.Remove(1.7f);
Console.WriteLine(firstSet.Find(1f));
Console.WriteLine(firstSet.Count);
HashedSet<float> secondSet = new HashedSet<float>();
secondSet.Add(1f);
secondSet.Add(2f);
secondSet.Add(3f);
secondSet.Add(5f);
HashedSet<float> thirdSet = new HashedSet<float>();
thirdSet.Add(1f);
thirdSet.Add(2f);
thirdSet.Add(3f);
thirdSet.Add(5f);
secondSet.Union(firstSet);
thirdSet.Intersect(firstSet);
firstSet.Clear();
}
public virtual IList GetObjectsInRange(float x, float y, float r,
Type cls)
{
float halfCell = this.cellSize / 2;
float size = 2 * r * this.cellSize;
float[] rect = { (x - r) * this.cellSize + halfCell,
(y - r) * this.cellSize + halfCell,size, size };
cacheSet.Clear();
lock (this.actorQuery)
{
this.actorQuery.Init(cls, (Actor)null);
IntersectingObjects(rect, this.actorQuery, cacheSet);
}
lock (this.inRangeQuery)
{
this.inRangeQuery.Init(x * this.cellSize + halfCell, y
* this.cellSize + halfCell, r * this.cellSize);
IList rangeResult = new List <Actor>();
IEnumerator it = cacheSet.GetEnumerator();
for (; it.MoveNext();)
{
Actor a = (Actor)it.Current;
if (this.inRangeQuery.CheckCollision(a))
{
rangeResult.Add(a);
}
}
return(rangeResult);
}
}
public void TestClearShouldProperlyWork()
{
var table = new HashedSet<string>();
table.Add("Pesho");
table.Clear();
Assert.AreEqual(0, table.Count);
Assert.AreEqual(16, table.Capacity);
}
public void test_clear()
{
// Test for method void java.util.HashSet.clear()
ISet orgSet = new HashedSet();
for (int i1 = 0; i1 < objArray.Length; i1++)
{
hs.Add(objArray[i1]);
}
hs.Clear();
IEnumerator i = orgSet.GetEnumerator();
Assertion.AssertEquals("Returned non-zero size after clear", 0, hs.Count);
while (i.MoveNext())
{
Assertion.Assert("Failed to clear set", !hs.Contains(i.Current));
}
}
public void ClearShouldResultInKeysCountOfZeroAndCountOfZero()
{
var set = new HashedSet<int>();
int value = 5;
set.Add(value);
set.Clear();
bool expected = true;
Assert.AreEqual(expected, set.Count == 0);
}
public void ClearShouldEmptyCollection()
{
testSet = new HashedSet <string>();
testSet.Add("Pesho");
testSet.Add("Gosho");
testSet.Clear();
int countAfterClearing = testSet.Count;
Assert.AreEqual(0, countAfterClearing);
}
public void TestClearMethodToClearAllElements()
{
HashedSet <string> first = new HashedSet <string>();
first.Add("TestIntro");
first.Add("PHP");
first.Add("Java");
first.Clear();
Assert.AreEqual(0, first.Count);
}
public void ShouldEmtyTheSet()
{
var hashedSet = new HashedSet<string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
hashedSet.Clear();
Assert.AreEqual(0, hashedSet.Count);
}
public void ShouldEmtyTheSet()
{
var hashedSet = new HashedSet <string>();
for (int i = 0; i < 10; i++)
{
hashedSet.Add("test" + i);
}
hashedSet.Clear();
Assert.AreEqual(0, hashedSet.Count);
}
public void addClause(Clause c, ISet<Clause> sos, ISet<Clause> usable)
{
// Perform forward subsumption elimination
bool addToSOS = true;
for (int i = this.minNoLiterals; i < c.GetNumberLiterals(); i++)
{
var fs = this.clausesGroupedBySize[i];
if (null != fs)
{
addToSOS = fs.All(s => !s.Subsumes(c));
}
if (!addToSOS)
{
break;
}
}
if (addToSOS)
{
sos.Add(c);
lightestClauseHeuristic.AddedClauseToSOS(c);
this.IndexClause(c);
// Have added clause, therefore
// perform backward subsumption elimination
ISet<Clause> subsumed = new HashedSet<Clause>();
for (var i = c.GetNumberLiterals() + 1; i <= this.maxNoLiterals; i++)
{
subsumed.Clear();
var bs = this.clausesGroupedBySize[i];
if (null == bs)
{
continue;
}
foreach (var s in bs.Where(c.Subsumes))
{
subsumed.Add(s);
if (sos.Contains(s))
{
sos.Remove(s);
this.lightestClauseHeuristic.RemovedClauseFromSOS(s);
}
usable.Remove(s);
}
bs.ExceptWith(subsumed);
}
}
}
private List <Vector2f> Calc(Field2D field, Vector2f start,
Vector2f goal, bool flag)
{
if (start.Equals(goal))
{
List <Vector2f> v = new List <Vector2f>();
v.Add(start);
return(v);
}
this.goal = goal;
if (visitedCache == null)
{
visitedCache = new HashedSet();
}
else
{
visitedCache.Clear();
}
if (pathes == null)
{
pathes = new List <ScoredPath>();
}
else
{
pathes.Clear();
}
visitedCache.Add(start);
if (path == null)
{
path = new List <Vector2f>();
}
else
{
path.Clear();
}
path.Add(start);
if (spath == null)
{
spath = new ScoredPath(0, path);
}
else
{
spath.score = 0;
spath.path = path;
}
pathes.Add(spath);
return(Astar(field, flag));
}
public void ClearShouldWorkCorrectly()
{
var set = new HashedSet <string>();
for (int i = 0; i < 20; i++)
{
set.Add(string.Format("pesho #{0}", i % 5));
}
set.Clear();
Assert.AreEqual(0, set.Count);
for (int i = 0; i < 4; i++)
{
Assert.IsFalse(set.Contains(string.Format("pesho #{0}", i)));
}
}
public void ClearShouldWorkCorrectly()
{
var set = new HashedSet<string>();
for (int i = 0; i < 20; i++)
{
set.Add(string.Format("pesho #{0}", i % 5));
}
set.Clear();
Assert.AreEqual(0, set.Count);
for (int i = 0; i < 4; i++)
{
Assert.IsFalse(set.Contains(string.Format("pesho #{0}", i)));
}
}
public static void Main()
{
HashedSet <string> names = new HashedSet <string>();
names.Add("Pesho");
names.Add("Pesho");
names.Add("Gosho");
names.Add("Doncho");
names.Add("Niki");
Console.WriteLine(names.Count);
names.Remove("Pesho");
names.Remove("Pesho");
Console.WriteLine(names.Count);
Console.WriteLine(names.Find("Pesho"));
names.Clear();
Console.WriteLine(names.Count);
}
public static void Main()
{
HashedSet <string> hashedSet = new HashedSet <string>();
hashedSet.Add("Pesho");
hashedSet.Add("Gosho");
hashedSet.Add("Misho");
string foundString = hashedSet.Find("Pesho");
System.Console.WriteLine(foundString);
hashedSet.Remove("Pesho");
System.Console.WriteLine(hashedSet.Count);
hashedSet.Clear();
System.Console.WriteLine(hashedSet.Count);
}
static void Main()
{
HashedSet <int> hSet = new HashedSet <int>();
hSet.Add(5);
hSet.Add(15);
hSet.Add(5);
Console.WriteLine(hSet.Find(45));
Console.WriteLine(hSet.Find(15));
hSet.Remove(5);
Console.WriteLine(hSet.Find(5));
hSet.Clear();
Console.WriteLine(hSet.Count);
hSet.Add(5);
hSet.Add(15);
hSet.Add(25);
hSet.Add(35);
HashedSet <int> hSetTwo = new HashedSet <int>();
hSetTwo.Add(4);
hSetTwo.Add(24);
hSetTwo.Add(25);
hSetTwo.Add(35);
var newIntersectedSet = hSet.Intersect(hSetTwo);
foreach (var item in newIntersectedSet.Keys)
{
Console.WriteLine(item);
}
var newUnitedSet = hSet.Union(hSetTwo);
foreach (var item in newUnitedSet.Keys)
{
Console.WriteLine(item);
}
}
public void TestHashedSetOperations()
{
var orders = new Order[1000];
for (var i = 0; i < orders.Length; i++)
{
orders[i] = new Order()
{
Id = i, Name = Guid.NewGuid().ToString()
};
}
var orderSet = new HashedSet <Order>(1000, (x1, x2) => x1.Id == x2.Id);
Assert.Equal(0, orderSet.Count);
for (var i = 0; i < orders.Length; i++)
{
orderSet.Add(orders[i]);
}
Assert.Equal(orders.Length, orderSet.Count);
foreach (var key in orderSet)
{
Assert.True(orders.Contains(key, new OrderEqualityComparer()));
}
for (var i = 0; i < 150; i++)
{
Assert.True(orderSet.Contains(orders[200 + i]));
}
foreach (var item in orderSet)
{
Assert.Contains(item, orders, new OrderEqualityComparer());
}
orderSet.Clear();
Assert.Equal(0, orderSet.Count);
Assert.Empty(orderSet);
foreach (var item in orderSet)
{
Assert.Equal(0, 1);
}
}
protected internal virtual void CheckColumnDuplication()
{
HashedSet <string> cols = new HashedSet <string>();
if (IdentifierMapper == null)
{
//an identifier mapper => Key will be included in the NonDuplicatedPropertyIterator
//and checked later, so it needs to be excluded
CheckColumnDuplication(cols, Key.ColumnIterator);
}
CheckColumnDuplication(cols, DiscriminatorColumnIterator);
CheckPropertyColumnDuplication(cols, NonDuplicatedPropertyIterator);
foreach (Join join in JoinIterator)
{
cols.Clear();
CheckColumnDuplication(cols, join.Key.ColumnIterator);
CheckPropertyColumnDuplication(cols, join.PropertyIterator);
}
}
internal static void Main()
{
HashedSet<int> test = new HashedSet<int>();
HashedSet<int> other = new HashedSet<int>();
test.Add(1);
test.Add(2);
test.Add(3);
test.Add(4);
test.Add(5);
test.Add(6);
other.Add(4);
other.Add(5);
other.Add(6);
other.Add(7);
other.Add(8);
Console.WriteLine("Initial hash set:");
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("After removal of 3:");
test.Remove(3);
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Is 1 found? {0}", test.Find(1));
Console.WriteLine("Is 3 found? {0}", test.Find(3));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("First hash set:");
Console.WriteLine(string.Join(", ", test));
Console.WriteLine("Member count: {0}", test.Count);
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Second hash set:");
Console.WriteLine(string.Join(", ", other));
Console.WriteLine("Member count: {0}", other.Count);
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Intersect of the first and second:");
Console.WriteLine(string.Join(", ", test.Intersect(other)));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Union of the first and second:");
Console.WriteLine(string.Join(", ", test.Union(other)));
Console.WriteLine("--------------------------------------------------------------");
test.Clear();
Console.WriteLine("First hash set after clear:");
Console.WriteLine(string.Join(", ", test));
}
static void Main()
{
HashedSet<int> hashSet1 = new HashedSet<int>();
for (int i = 0; i < 10; i++)
{
hashSet1.Add(i);
}
Console.WriteLine("Find element with key = 4");
Console.WriteLine(hashSet1.Find(4));
Console.WriteLine("Find element with key = 2 and write the count of elements");
hashSet1.Remove(2);
Console.WriteLine(hashSet1.Count);
HashedSet<int> hashSet2 = new HashedSet<int>();
hashSet2.Add(5);
hashSet2.Add(9);
hashSet2.Add(33);
Console.WriteLine("Union: ");
hashSet1.UnionWith(hashSet2);
for (int i = 0; i < hashSet1.Container.Count; i++)
{
Console.WriteLine(hashSet1.Container.Keys[i]);
}
Console.WriteLine();
Console.WriteLine("Intersect: ");
hashSet1.IntersectWith(hashSet2);
for (int i = 0; i < hashSet1.Container.Count; i++)
{
Console.WriteLine(hashSet1.Container.Keys[i]);
}
Console.WriteLine();
Console.WriteLine("count after clear");
hashSet2.Clear();
Console.WriteLine(hashSet2.Container.Count);
}
static void Main()
{
HashedSet<int> hSet = new HashedSet<int>();
hSet.Add(5);
hSet.Add(15);
hSet.Add(5);
Console.WriteLine(hSet.Find(45));
Console.WriteLine(hSet.Find(15));
hSet.Remove(5);
Console.WriteLine(hSet.Find(5));
hSet.Clear();
Console.WriteLine(hSet.Count);
hSet.Add(5);
hSet.Add(15);
hSet.Add(25);
hSet.Add(35);
HashedSet<int> hSetTwo = new HashedSet<int>();
hSetTwo.Add(4);
hSetTwo.Add(24);
hSetTwo.Add(25);
hSetTwo.Add(35);
var newIntersectedSet = hSet.Intersect(hSetTwo);
foreach (var item in newIntersectedSet.Keys)
{
Console.WriteLine(item);
}
var newUnitedSet = hSet.Union(hSetTwo);
foreach (var item in newUnitedSet.Keys)
{
Console.WriteLine(item);
}
}
public void Remove()
{
HashedSet <string> set1 = new HashedSet <string>(
StringComparer.InvariantCultureIgnoreCase);
bool b;
b = set1.Remove("Eric"); Assert.IsFalse(b);
b = set1.Add("hello"); Assert.IsTrue(b);
b = set1.Add("foo"); Assert.IsTrue(b);
b = set1.Add(""); Assert.IsTrue(b);
b = set1.Remove("HELLO"); Assert.IsTrue(b);
b = set1.Remove("hello"); Assert.IsFalse(b);
b = set1.Add("Hello"); Assert.IsTrue(b);
b = set1.Add("Eric"); Assert.IsTrue(b);
b = set1.Add("Eric"); Assert.IsFalse(b);
b = set1.Remove("eRic"); Assert.IsTrue(b);
b = set1.Remove("eRic"); Assert.IsFalse(b);
set1.Clear();
b = set1.Remove(""); Assert.IsFalse(b);
}
/* Task 5:
* Implement the data structure "set" in a class HashedSet<T> using your class HashTable<K,T>
* to hold the elements. Implement all standard set operations like Add(T), Find(T), Remove(T),
* Count, Clear(), union and intersect.
*/
static void Main(string[] args)
{
var setOne = new HashedSet<int>();
for (int i = 0; i < 50; i++)
{
setOne.Add(i);
}
Console.WriteLine(setOne.Count());
for (int i = 25; i < 50; i++)
{
setOne.Remove(i);
}
Console.WriteLine(setOne.Count());
var setTwo = new HashedSet<int>();
setTwo.Add(100);
setTwo.Add(101);
setTwo.Add(102);
setTwo.Add(103);
setTwo.Add(104);
setTwo.Add(105);
//Saving all results from Union
setOne = setOne.Union(setTwo);
Console.WriteLine(setOne.Count());
setTwo.Clear();
for (int i = 10; i < 25; i++)
{
setTwo.Add(i);
}
//Saving only the intersect Results
setOne = setOne.Intersect(setTwo);
Console.WriteLine(setOne.Count());
}
public static void Main()
{
// Input array that contains three duplicate strings.
string[] arrayWithDuplicatedValues = { "cat", "dog", "cat", "leopard", "tiger", "cat" };
// Display the array.
Console.WriteLine("---------- Array with duplicated items ----------");
Console.WriteLine(string.Join(",", arrayWithDuplicatedValues));
// Use HashSet constructor to ensure unique strings.
var hashedSet = new HashedSet<string>();
for (int i = 0; i < arrayWithDuplicatedValues.Length; i++)
{
hashedSet.Add(arrayWithDuplicatedValues[i]);
}
// Display the resulting array.
Console.WriteLine("\n---------- HashedSet without duplicated items ----------");
foreach (var item in hashedSet)
{
Console.WriteLine(item);
}
Console.WriteLine("\n---------- Test Find(cat) ----------");
Console.WriteLine(hashedSet.Find("cat"));
Console.WriteLine("\n---------- Test Remove(cat) and print all elements again ----------");
hashedSet.Remove("cat");
foreach (var item in hashedSet)
{
Console.WriteLine(item);
}
Console.WriteLine("\n---------- Test Count() ----------");
Console.WriteLine(hashedSet.Count());
Console.WriteLine("\n---------- Test Clear() and print count ----------");
hashedSet.Clear();
Console.WriteLine(hashedSet.Count());
}
static void Main(string[] args)
{
var set = new HashedSet<int>(new[] { 1, 2, 3, 4, 5 });
Console.WriteLine("Set: {0}", set);
// Add
set.Add(6);
Console.WriteLine("Add '6' -> {0}", set);
// Add existing
set.Add(6);
Console.WriteLine("Add '6' -> {0}", set);
// Find
Console.WriteLine("Find '0': {0}", set.Find(0));
Console.WriteLine("Find '6': {0}", set.Find(6));
// Remove
set.Remove(3);
Console.WriteLine("Remove '3' -> {0}", set);
// Count
Console.WriteLine("Number of elements: {0}", set.Count);
// Union
var collection = new[] { 3, 7 };
set.Union(collection);
Console.WriteLine("Union with [{0}] -> {1}", string.Join(", ", collection), set);
// Intersection
collection = new[] { 5, 6, 7, 8, 9 };
set.Intersect(collection);
Console.WriteLine("Intersection with [{0}] -> {1}", string.Join(", ", collection), set);
// Clear
set.Clear();
Console.WriteLine("Clear set...");
Console.WriteLine("Number of elements: {0}", set.Count);
}
protected void UpdateBoundarySuffixes(HashedSet <int> newBoundarySuffix)
{
boundarySuffix.Clear();
boundarySuffix.AddAll(newBoundarySuffix);
}
/// <summary>
/// Add an element to the bintree.
/// </summary>
/// <param name="Element">A element of type T.</param>
public void Add(T Element)
{
if (this.Contains(Element))
{
#region Check subtrees...
if (Subtree1 != null && Subtree1.Contains(Element))
{
Subtree1.Add(Element);
}
else if (Subtree2 != null && Subtree2.Contains(Element))
{
Subtree2.Add(Element);
}
#endregion
#region ...or the embedded data.
else if (EmbeddedData.Count < MaxNumberOfEmbeddedElements)
{
EmbeddedData.Add(Element);
}
#endregion
#region If necessary create subtrees...
else
{
#region Create Subtrees
if (Subtree1 == null)
{
Subtree1 = new Bintree <T>(Left,
Math.Add(Left, Math.Div2(Length)),
MaxNumberOfEmbeddedElements);
Subtree1.OnTreeSplit += OnTreeSplit;
}
if (Subtree2 == null)
{
Subtree2 = new Bintree <T>(Math.Add(Left, Math.Div2(Length)),
Right,
MaxNumberOfEmbeddedElements);
Subtree2.OnTreeSplit += OnTreeSplit;
}
#endregion
#region Fire BintreeSplit event
if (OnTreeSplit != null)
{
OnTreeSplit(this, Element);
}
#endregion
#region Move all embedded data into the subtrees
EmbeddedData.Add(Element);
foreach (var _Element in EmbeddedData)
{
if (Subtree1.Contains(_Element))
{
Subtree1.Add(_Element);
}
else if (Subtree2.Contains(_Element))
{
Subtree2.Add(_Element);
}
else
{
throw new Exception("Mist!");
}
}
EmbeddedData.Clear();
#endregion
}
#endregion
}
else
{
throw new BT_OutOfBoundsException <T>(this, Element);
}
}
public void TestClearMethod()
{
var hashedSet = new HashedSet<int>();
Assert.IsTrue(hashedSet.Add(1));
Assert.IsTrue(hashedSet.Add(2));
Assert.IsTrue(hashedSet.Add(3));
Assert.IsTrue(hashedSet.Add(4));
Assert.AreEqual(4, hashedSet.Count);
hashedSet.Clear();
Assert.AreEqual(0, hashedSet.Count);
Assert.IsFalse(hashedSet.Contains(1));
Assert.IsFalse(hashedSet.Contains(2));
Assert.IsTrue(hashedSet.Add(3));
Assert.IsTrue(hashedSet.Add(4));
}
/// <summary>
/// Add a pixel to the quadtree.
/// </summary>
/// <param name="IPixel">A pixel of type T.</param>
public void Add(IPixel <T> IPixel)
{
if (this.Contains(IPixel))
{
#region Check subtrees...
if (Subtree1 != null && Subtree1.Contains(IPixel))
{
Subtree1.Add(IPixel);
}
else if (Subtree2 != null && Subtree2.Contains(IPixel))
{
Subtree2.Add(IPixel);
}
else if (Subtree3 != null && Subtree3.Contains(IPixel))
{
Subtree3.Add(IPixel);
}
else if (Subtree4 != null && Subtree4.Contains(IPixel))
{
Subtree4.Add(IPixel);
}
#endregion
#region ...or the embedded data.
else if (EmbeddedPixels.Count < MaxNumberOfEmbeddedPixels)
{
EmbeddedPixels.Add(IPixel);
}
#endregion
#region If necessary create subtrees...
else
{
#region Create Subtrees
if (Subtree1 == null)
{
Subtree1 = new Quadtree <T>(Left,
Top,
Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
MaxNumberOfEmbeddedPixels);
Subtree1.OnTreeSplit += OnTreeSplit;
}
if (Subtree2 == null)
{
Subtree2 = new Quadtree <T>(Math.Add(Left, Math.Div2(Width)),
Top,
Right,
Math.Add(Top, Math.Div2(Height)),
MaxNumberOfEmbeddedPixels);
Subtree2.OnTreeSplit += OnTreeSplit;
}
if (Subtree3 == null)
{
Subtree3 = new Quadtree <T>(Left,
Math.Add(Top, Math.Div2(Height)),
Math.Add(Left, Math.Div2(Width)),
Bottom,
MaxNumberOfEmbeddedPixels);
Subtree3.OnTreeSplit += OnTreeSplit;
}
if (Subtree4 == null)
{
Subtree4 = new Quadtree <T>(Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
Right,
Bottom,
MaxNumberOfEmbeddedPixels);
Subtree4.OnTreeSplit += OnTreeSplit;
}
#endregion
#region Fire QuadtreeSplit event
if (OnTreeSplit != null)
{
OnTreeSplit(this, IPixel);
}
#endregion
#region Move all embedded data into the subtrees
EmbeddedPixels.Add(IPixel);
foreach (var _Pixel in EmbeddedPixels)
{
if (Subtree1.Contains(_Pixel))
{
Subtree1.Add(_Pixel);
}
else if (Subtree2.Contains(_Pixel))
{
Subtree2.Add(_Pixel);
}
else if (Subtree3.Contains(_Pixel))
{
Subtree3.Add(_Pixel);
}
else if (Subtree4.Contains(_Pixel))
{
Subtree4.Add(_Pixel);
}
else
{
throw new Exception("Mist!");
}
}
EmbeddedPixels.Clear();
#endregion
}
#endregion
}
else
{
throw new QT_OutOfBoundsException <T>(this, IPixel);
}
}
public void Remove()
{
HashedSet<string> set1 = new HashedSet<string>(
StringComparer.InvariantCultureIgnoreCase);
bool b;
b = set1.Remove("Eric"); Assert.IsFalse(b);
b = set1.Add("hello"); Assert.IsTrue(b);
b = set1.Add("foo"); Assert.IsTrue(b);
b = set1.Add(""); Assert.IsTrue(b);
b = set1.Remove("HELLO"); Assert.IsTrue(b);
b = set1.Remove("hello"); Assert.IsFalse(b);
b = set1.Add("Hello"); Assert.IsTrue(b);
b = set1.Add("Eric"); Assert.IsTrue(b);
b = set1.Add("Eric"); Assert.IsFalse(b);
b = set1.Remove("eRic"); Assert.IsTrue(b);
b = set1.Remove("eRic"); Assert.IsFalse(b);
set1.Clear();
b = set1.Remove(""); Assert.IsFalse(b);
}
public void CountAndClear()
{
HashedSet<string> set1 = new HashedSet<string>(
StringComparer.InvariantCultureIgnoreCase);
Assert.AreEqual(0, set1.Count);
set1.Add("hello"); Assert.AreEqual(1, set1.Count);
set1.Add("foo"); Assert.AreEqual(2, set1.Count);
set1.Add(""); Assert.AreEqual(3, set1.Count);
set1.Add("HELLO"); Assert.AreEqual(3, set1.Count);
set1.Add("foo"); Assert.AreEqual(3, set1.Count);
set1.Add("Hello"); Assert.AreEqual(3, set1.Count);
set1.Add("Eric"); Assert.AreEqual(4, set1.Count);
set1.Clear();
Assert.AreEqual(0, set1.Count);
bool found = false;
foreach (string s in set1)
found = true;
Assert.IsFalse(found);
}
/// <summary>
/// Add a voxel to the octree.
/// </summary>
/// <param name="Voxel">A voxel of type T.</param>
public void Add(IVoxel <T> Voxel)
{
if (this.Contains(Voxel))
{
#region Check subtrees...
if (Subtree1 != null && Subtree1.Contains(Voxel))
{
Subtree1.Add(Voxel);
}
else if (Subtree2 != null && Subtree2.Contains(Voxel))
{
Subtree2.Add(Voxel);
}
else if (Subtree3 != null && Subtree3.Contains(Voxel))
{
Subtree3.Add(Voxel);
}
else if (Subtree4 != null && Subtree4.Contains(Voxel))
{
Subtree4.Add(Voxel);
}
else if (Subtree5 != null && Subtree5.Contains(Voxel))
{
Subtree5.Add(Voxel);
}
else if (Subtree6 != null && Subtree6.Contains(Voxel))
{
Subtree6.Add(Voxel);
}
else if (Subtree7 != null && Subtree7.Contains(Voxel))
{
Subtree7.Add(Voxel);
}
else if (Subtree8 != null && Subtree8.Contains(Voxel))
{
Subtree8.Add(Voxel);
}
#endregion
#region ...or the embedded data.
else if (EmbeddedVoxels.Count < MaxNumberOfEmbeddedVoxels)
{
EmbeddedVoxels.Add(Voxel);
}
#endregion
#region If necessary create subtrees...
else
{
#region Create Subtrees
if (Subtree1 == null)
{
Subtree1 = new Octree <T>(Left,
Top,
Front,
Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
Math.Add(Front, Math.Div2(Depth)),
MaxNumberOfEmbeddedVoxels);
Subtree1.OnTreeSplit += OnTreeSplit;
}
if (Subtree2 == null)
{
Subtree2 = new Octree <T>(Math.Add(Left, Math.Div2(Width)),
Top,
Front,
Right,
Math.Add(Top, Math.Div2(Height)),
Math.Add(Front, Math.Div2(Depth)),
MaxNumberOfEmbeddedVoxels);
Subtree2.OnTreeSplit += OnTreeSplit;
}
if (Subtree3 == null)
{
Subtree3 = new Octree <T>(Left,
Math.Add(Top, Math.Div2(Height)),
Front,
Math.Add(Left, Math.Div2(Width)),
Bottom,
Math.Add(Front, Math.Div2(Depth)),
MaxNumberOfEmbeddedVoxels);
Subtree3.OnTreeSplit += OnTreeSplit;
}
if (Subtree4 == null)
{
Subtree4 = new Octree <T>(Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
Front,
Right,
Bottom,
Math.Add(Front, Math.Div2(Depth)),
MaxNumberOfEmbeddedVoxels);
Subtree4.OnTreeSplit += OnTreeSplit;
}
if (Subtree5 == null)
{
Subtree5 = new Octree <T>(Left,
Top,
Math.Add(Front, Math.Div2(Depth)),
Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
Behind,
MaxNumberOfEmbeddedVoxels);
Subtree5.OnTreeSplit += OnTreeSplit;
}
if (Subtree6 == null)
{
Subtree6 = new Octree <T>(Math.Add(Left, Math.Div2(Width)),
Top,
Math.Add(Front, Math.Div2(Depth)),
Right,
Math.Add(Top, Math.Div2(Height)),
Behind,
MaxNumberOfEmbeddedVoxels);
Subtree6.OnTreeSplit += OnTreeSplit;
}
if (Subtree7 == null)
{
Subtree7 = new Octree <T>(Left,
Math.Add(Top, Math.Div2(Height)),
Math.Add(Front, Math.Div2(Depth)),
Math.Add(Left, Math.Div2(Width)),
Bottom,
Behind,
MaxNumberOfEmbeddedVoxels);
Subtree7.OnTreeSplit += OnTreeSplit;
}
if (Subtree8 == null)
{
Subtree8 = new Octree <T>(Math.Add(Left, Math.Div2(Width)),
Math.Add(Top, Math.Div2(Height)),
Math.Add(Front, Math.Div2(Depth)),
Right,
Bottom,
Behind,
MaxNumberOfEmbeddedVoxels);
Subtree8.OnTreeSplit += OnTreeSplit;
}
#endregion
#region Fire OctreeSplit event
if (OnTreeSplit != null)
{
OnTreeSplit(this, Voxel);
}
#endregion
#region Move all embedded data into the subtrees
EmbeddedVoxels.Add(Voxel);
foreach (var _Voxel in EmbeddedVoxels)
{
if (Subtree1.Contains(_Voxel))
{
Subtree1.Add(_Voxel);
}
else if (Subtree2.Contains(_Voxel))
{
Subtree2.Add(_Voxel);
}
else if (Subtree3.Contains(_Voxel))
{
Subtree3.Add(_Voxel);
}
else if (Subtree4.Contains(_Voxel))
{
Subtree4.Add(_Voxel);
}
else if (Subtree5.Contains(_Voxel))
{
Subtree5.Add(_Voxel);
}
else if (Subtree6.Contains(_Voxel))
{
Subtree6.Add(_Voxel);
}
else if (Subtree7.Contains(_Voxel))
{
Subtree7.Add(_Voxel);
}
else if (Subtree8.Contains(_Voxel))
{
Subtree8.Add(_Voxel);
}
else
{
throw new Exception("Mist!");
}
}
EmbeddedVoxels.Clear();
#endregion
}
#endregion
}
else
{
throw new OT_OutOfBoundsException <T>(this, Voxel);
}
}
public IInferenceResult Ask(FOLKnowledgeBase kb, ISentence alpha)
{
// clauses <- the set of clauses in CNF representation of KB ^ ~alpha
ISet <Clause> clauses = new HashedSet <Clause>();
foreach (Clause c in kb.GetAllClauses())
{
var standardizedC = kb.StandardizeApart(c);
standardizedC.SetStandardizedApartCheckNotRequired();
clauses.UnionWith(standardizedC.GetFactors());
}
ISentence notAlpha = new NotSentence(alpha);
// Want to use an answer literal to pull
// query variables where necessary
Literal answerLiteral = kb.CreateAnswerLiteral(notAlpha);
ISet <Variable> answerLiteralVariables = kb
.CollectAllVariables(answerLiteral.AtomicSentence);
Clause answerClause = new Clause();
if (answerLiteralVariables.Count > 0)
{
ISentence notAlphaWithAnswer = new ConnectedSentence(Connectors.Or,
notAlpha, answerLiteral.AtomicSentence);
foreach (Clause c in kb.ConvertToClauses(notAlphaWithAnswer))
{
var standardizedC = kb.StandardizeApart(c);
standardizedC.SetProofStep(new ProofStepGoal(standardizedC));
standardizedC.SetStandardizedApartCheckNotRequired();
clauses.UnionWith(standardizedC.GetFactors());
}
answerClause.AddLiteral(answerLiteral);
}
else
{
foreach (Clause c in kb.ConvertToClauses(notAlpha))
{
var standardizedC = kb.StandardizeApart(c);
standardizedC.SetProofStep(new ProofStepGoal(standardizedC));
standardizedC.SetStandardizedApartCheckNotRequired();
clauses.UnionWith(standardizedC.GetFactors());
}
}
var ansHandler = new TFMAnswerHandler(answerLiteral,
answerLiteralVariables, answerClause, this.MaxQueryTime);
// new <- {}
ISet <Clause> newClauses = new HashedSet <Clause>();
ISet <Clause> toAdd = new HashedSet <Clause>();
// loop do
int noOfPrevClauses = clauses.Count;
do
{
if (Tracer != null)
{
Tracer.StepStartWhile(clauses, clauses.Count, newClauses
.Count);
}
newClauses.Clear();
// for each Ci, Cj in clauses do
Clause[] clausesA = new Clause[clauses.Count];
clausesA = clauses.ToArray();
// Basically, using the simple T)wo F)inger M)ethod here.
for (int i = 0; i < clausesA.Length; i++)
{
Clause cI = clausesA[i];
if (null != Tracer)
{
Tracer.StepOuterFor(cI);
}
for (int j = i; j < clausesA.Length; j++)
{
Clause cJ = clausesA[j];
if (null != Tracer)
{
Tracer.StepInnerFor(cI, cJ);
}
// resolvent <- FOL-RESOLVE(Ci, Cj)
ISet <Clause> resolvents = cI.BinaryResolvents(cJ);
if (resolvents.Count > 0)
{
toAdd.Clear();
// new <- new <UNION> resolvent
foreach (Clause rc in resolvents)
{
toAdd.UnionWith(rc.GetFactors());
}
if (null != Tracer)
{
Tracer.StepResolved(cI, cJ, toAdd);
}
ansHandler.CheckForPossibleAnswers(toAdd);
if (ansHandler.IsComplete())
{
break;
}
newClauses.UnionWith(toAdd);
}
if (ansHandler.IsComplete())
{
break;
}
}
if (ansHandler.IsComplete())
{
break;
}
}
noOfPrevClauses = clauses.Count;
// clauses <- clauses <UNION> new
clauses.UnionWith(newClauses);
if (ansHandler.IsComplete())
{
break;
}
// if new is a <SUBSET> of clauses then finished
// searching for an answer
// (i.e. when they were added the # clauses
// did not increase).
} while (noOfPrevClauses < clauses.Count);
if (null != Tracer)
{
Tracer.StepFinished(clauses, ansHandler);
}
return(ansHandler);
}
