public void TestInitialize()
{
// dynamic PowerSet
testPowerSet = new PowerSet <int>();
// zero PowerSet
testPowerSet0 = new PowerSet <int>();
// 5 items PowerSet {8 10 12 14 16}
testPowerSet1 = new PowerSet <int>();
testPowerSet1.Put(8);
testPowerSet1.Put(10);
testPowerSet1.Put(12);
testPowerSet1.Put(14);
testPowerSet1.Put(16);
Assert.AreEqual(5, testPowerSet1.capacity);
// 5 items PowerSet {14 16 162 0 5}
testPowerSet2 = new PowerSet <int>();
testPowerSet2.Put(14);
testPowerSet2.Put(16);
testPowerSet2.Put(162);
testPowerSet2.Put(0);
testPowerSet2.Put(5);
Assert.AreEqual(5, testPowerSet2.capacity);
}
public static void PowerSetTest()
{
PowerSet <int> ps1 = new PowerSet <int>();
PowerSet <int> ps2 = new PowerSet <int>();
ps1.Put(1);
ps1.Put(3);
ps1.Put(5);
ps2.Put(2);
ps2.Put(3);
ps2.Put(4);
var ps3 = ps1.Difference(ps2);
//Console.WriteLine(ps3);
foreach (var item in ps3.items.Keys)
{
Console.WriteLine(item);
}
//Console.WriteLine($"Size: {ps3.Size()}");
}
public PowerSet <T> Difference(PowerSet <T> set2)
{
// разница текущего множества и set2
PowerSet <T> differenced = new PowerSet <T>();
if (set2.count == 0)
///return this;
{
foreach (T item in slots)
{
differenced.Put(item);
}
}
foreach (T item in this.slots)
{
if (!set2.Get(item))
{
differenced.Put(item);
}
}
if (differenced.count > 0)
{
return(differenced);
}
else
{
return(differenced);
}
}
public PowerSet <T> Union(PowerSet <T> set2)
{
if (set2 == null)
{
return(null);
}
PowerSet <T> resultSet = new PowerSet <T>();
for (int i = 0; i < _values.Length; i++)
{
if (_slotsStatus[i] == SlotStatus.Fill)
{
resultSet.Put(_values[i]);
}
}
for (int i = 0; i < set2._values.Length; i++)
{
if (set2._slotsStatus[i] == SlotStatus.Fill)
{
resultSet.Put(set2._values[i]);
}
}
return(resultSet);
}
public void Intersection()
{
// Intersection with empty set
Assert.AreEqual(0, testPowerSet1.Intersection(testPowerSet0).capacity);
// Intersection with PowerSet2 contains 5 items (expected 2 items)
testPowerSet = testPowerSet1.Intersection(testPowerSet2);
Assert.AreEqual(2, testPowerSet.capacity);
Assert.AreEqual(true, testPowerSet.Get(14));
Assert.AreEqual(true, testPowerSet.Get(16));
Assert.AreEqual(false, testPowerSet.Get(100));
// Putting 5 items to empty set
testPowerSet0.Put(101);
testPowerSet0.Put(102);
testPowerSet0.Put(103);
testPowerSet0.Put(104);
testPowerSet0.Put(105);
Assert.AreEqual(5, testPowerSet0.capacity);
// Intersection with PowerSet0 contains 5 different items (expected empty set)
testPowerSet = testPowerSet1.Intersection(testPowerSet0);
Assert.AreEqual(0, testPowerSet.capacity);
Assert.AreEqual(false, testPowerSet.Get(101));
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
PowerSet <T> union_set = new PowerSet <T>();
foreach (var item in ps)
{
union_set.Put(item);
}
foreach (var item in set2.ps)
{
union_set.Put(item);
}
return(union_set);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
var union = new PowerSet <T>();
foreach (var item in items.Keys)
{
union.Put(item);
}
foreach (var item in set2.items.Keys)
{
union.Put(item);
}
return(union);
}
public PowerSet <T> Intersection(PowerSet <T> set2) // пересечение текущего множества и set2
{
PowerSet <T> setIntersection = new PowerSet <T>();
if (set2 != null)
{
for (int i = 0; i < size; i++)
{
if (slots[i] == null)
{
continue;
}
else if (slots[i].Equals(default(T)))
{
continue;
}
if (set2.Get(slots[i]))
{
setIntersection.Put(slots[i]);
}
}
return(setIntersection);
}
return(setIntersection);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
PowerSet <T> interset = new PowerSet <T>();
if (set2 != null)
{
for (int i = 0; i < size; i++)
{
if (slots[i] == null)
{
continue;
}
else if (slots[i].Equals(default(T)))
{
continue;
}
if (set2.Get(slots[i]))
{
interset.Put(slots[i]);
}
}
return(interset);
}
return(null);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
PowerSet <T> temp = new PowerSet <T>();
foreach (T a in dict.Values)
{
temp.Put(a);
}
foreach (T a in set2.dict.Values)
{
if (!temp.dict.ContainsValue(a))
{
temp.Put(a);
}
}
return(temp);
// объединение текущего множества и set2
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
var currValues = WhereIsNotNull(slots);
var set2Values = WhereIsNotNull(set2.slots);
var result = new PowerSet <T>();
foreach (var currValue in currValues)
{
var obj = (T)Convert.ChangeType(currValue, typeof(T));
result.Put(obj);
}
foreach (var value in set2Values)
{
var obj = (T)Convert.ChangeType(value, typeof(T));
result.Put(obj);
}
return(result);
}
static PowerSet <int> CreatePowerSet(int startValue, int finishValue)
{
PowerSet <int> resultSet = new PowerSet <int>();
for (int i = startValue; i <= finishValue; i++)
{
resultSet.Put(i);
}
return(resultSet);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
PowerSet <T> result = new PowerSet <T>();
foreach (var slot in slots)
{
foreach (var item in slot)
{
result.Put(item);
}
}
foreach (var slot in set2.slots)
{
foreach (var item in slot)
{
result.Put(item);
}
}
return(result);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
PowerSet <T> unity = new PowerSet <T>();
if (set2 != null)
{
for (int i = 0; i < size; i++)
{
if (slots[i] != null)
{
unity.Put(slots[i]);
}
if (set2.slots[i] != null)
{
unity.Put(set2.slots[i]);
}
}
return(unity);
}
return(null);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
PowerSet <T> United = new PowerSet <T>();
if (capacity > 0)
{
foreach (var item in slots)
{
United.Put(item);
}
}
if (set2.capacity > 0)
{
foreach (var item in set2.slots)
{
United.Put(item);
}
}
return(United);
}
public PowerSet <T> Union(PowerSet <T> set2) // объединение текущего множества и set2
{
PowerSet <T> setUnion = new PowerSet <T>();
if (set2 != null)
{
for (int i = 0; i < size; i++)
{
if (slots[i] != null)
{
setUnion.Put(slots[i]);
}
if (set2.slots[i] != null)
{
setUnion.Put(set2.slots[i]);
}
}
return(setUnion);
}
return(setUnion);
}
/// <summary>
/// вычисляет и возвращает новое множество-объединение текущего множества со множеством set2
/// </summary>
/// <param name="set2">множество типа значений типа T</param>
/// <returns>множество-объединение PowerSet<T> текущего множества со множеством set2</returns>
public PowerSet <T> Union(PowerSet <T> set2)
{
PowerSet <T> unionSet = new PowerSet <T>();
foreach (T item in items)
{
// добавление всех элементов первого множества
unionSet.Put(item);
}
foreach (T item in set2.items)
{
// добавление всех элементов второго множества, которые отсутствуют в первом
if (!Get(item))
{
unionSet.Put(item);
}
}
return(unionSet);
}
public PowerSet <T> Difference(PowerSet <T> set2)
{
// разница текущего множества и set2
PowerSet <T> temp = new PowerSet <T>();
for (int i = 0; i < pool.Count; i++)
{
if (set2.Get(pool[i]) == false)
{
temp.Put(pool[i]);
}
}
return(temp);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
PowerSet <T> temp = new PowerSet <T>();
temp = Intersection(set2);
for (int i = 0; i < pool.Count; i++)
{
if (temp.Get(pool[i]) == false)
{
temp.Put(pool[i]);
}
}
for (int i = 0; i < set2.pool.Count; i++)
{
if (temp.Get(set2.pool[i]) == false)
{
temp.Put(set2.pool[i]);
}
}
return(temp);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
// пересечение текущего множества и set2
PowerSet <T> temp = new PowerSet <T>();
for (int i = 0; i < pool.Count; i++)
{
if (set2.Get(pool[i]) == true)
{
temp.Put(pool[i]);
}
}
return(temp);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
// пересечение текущего множества и set2
PowerSet <T> intersect = new PowerSet <T>();
foreach (var item in ps)
{
if (set2.Get(item))
{
intersect.Put(item);
}
}
return(intersect);
}
public PowerSet <T> Union(PowerSet <T> set2)
{
// объединение текущего множества и set2
PowerSet <T> United = new PowerSet <T>();
///////United = this;/////
foreach (T item in slots)
{
United.Put(item);
}
for (int i = 0; i < set2.count; i++)
{
United.Put(set2.slots[i]);
}
if (United.count > 0)
{
return(United);
}
else
{
return(United);
}
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
PowerSet <T> result = new PowerSet <T>();
foreach (T a in dict.Values)
{
if (set2.dict.ContainsValue(a))
{
result.Put(a);
}
}
foreach (T a in set2.dict.Values)
{
if (dict.ContainsValue(a) && !result.dict.ContainsValue(a))
{
result.Put(a);
}
}
return(result);
// пересечение текущего множества и set2
}
public PowerSet <T> Difference(PowerSet <T> set2)
{
// разница текущего множества и set2
var diff = new PowerSet <T>();
foreach (var item in items.Keys)
{
if (!set2.Get(item))
{
diff.Put(item);
}
}
return(diff);
}
public PowerSet <T> Difference(PowerSet <T> set2)
{
// разница текущего множества и set2
// пересечение текущего множества и set2
PowerSet <T> difset = new PowerSet <T>();
foreach (var item in ps)
{
if (!set2.Get(item))
{
difset.Put(item);
}
}
return(difset);
}
/// <summary>
/// вычисляет и возвращает новое множество-перечение текущего множества с множеством set2
/// </summary>
/// <param name="set2">множество типа значений типа T</param>
/// <returns>множество-пересечение PowerSet<T> текущего множества и множества set2</returns>
public PowerSet <T> Intersection(PowerSet <T> set2)
{
PowerSet <T> interSet = new PowerSet <T>();
foreach (T item in items)
{
// добавление всех элементов первого множества, которые присутствуют и во втором множестве
if (set2.items.Contains(item))
{
interSet.Put(item);
}
}
return(interSet);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
PowerSet <T> result = new PowerSet <T>();
foreach (var slot in slots)
{
foreach (var item in slot)
{
if (set2.Get(item))
{
result.Put(item);
}
}
}
return(result);
}
public PowerSet <T> Difference(PowerSet <T> set2)
{
// разница текущего множества и set2
var currValues = WhereIsNotNull(slots);
var set2Values = WhereIsNotNull(set2.slots);
var result = new PowerSet <T>();
foreach (var currValue in currValues)
{
if (!set2Values.Contains(currValue))
{
result.Put(currValue);
}
}
return(result);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
// пересечение текущего множества и set2
var currValues = WhereIsNotNull(slots);
var set2Values = WhereIsNotNull(set2.slots);
var result = new PowerSet <T>();
foreach (var currValue in currValues)
{
if (set2Values.Contains(currValue))
{
result.Put(currValue);
}
}
return(result);
}
public PowerSet <T> Intersection(PowerSet <T> set2)
{
// пересечение текущего множества и set2
PowerSet <T> Intersected = new PowerSet <T>();
if (capacity > 0 && set2.capacity > 0)
{
foreach (T item in slots)
{
if (set2.Get(item))
{
Intersected.Put(item);
}
}
}
return(Intersected);
}