public bool IsSubset(PowerSet <T> set2)
{
// возвращает true, если set2 есть
// подмножество текущего множества,
// иначе false
if (this.count == 0)
{
return(false);
}
int count = set2.count;
for (int i = 0; i < set2.count; i++)
{
if (Get(set2.slots[i]))
{
count--;
}
}
if (count == 0)
{
return(true);
}
else
{
return(false);
}
}
public bool IsSubset(PowerSet <T> set2)
{
if (Size() >= set2.Size())
{
if (set2.Size() == 0)
{
return(true);
}
for (int i = 0; i < size; i++)
{
if (set2.slots[i] != null && !set2.slots[i].Equals(default(T)))
{
if (!Get(set2.slots[i]))
{
break;
}
}
if (i == size - 1)
{
return(true);
}
}
}
return(false);
}
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> 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> 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);
}
static void TestFunc(PowerSet <int> set1, PowerSet <int> set2, Func <PowerSet <int>, PowerSet <int>, PowerSet <int> > testFunc)
{
if (set1.Size() == 0)
{
Console.Write("set1 is empty");
}
else
{
Console.WriteLine("set1");
for (int i = 0; i < set1._values.Length; i++)
{
if (set1._slotsStatus[i] == PowerSet <int> .SlotStatus.Fill)
{
Console.Write(set1._values[i] + " ");
}
}
}
Console.WriteLine();
if (set2.Size() == 0)
{
Console.Write("set2 is empty");
}
else
{
Console.WriteLine("set2");
for (int i = 0; i < set2._values.Length; i++)
{
if (set2._slotsStatus[i] == PowerSet <int> .SlotStatus.Fill)
{
Console.Write(set2._values[i] + " ");
}
}
}
Console.WriteLine();
PowerSet <int> resultSet = testFunc(set1, set2);
if (resultSet.Size() == 0)
{
Console.Write("result set is empty");
}
else
{
Console.WriteLine("result set");
for (int i = 0; i < resultSet._values.Length; i++)
{
if (resultSet._slotsStatus[i] == PowerSet <int> .SlotStatus.Fill)
{
Console.Write(resultSet._values[i] + " ");
}
}
}
Console.WriteLine();
Console.WriteLine(new string('=', 50));
}
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 bool IsSubset(PowerSet <T> set2) // возвращает true, если set2 есть подмножество текущего множества, иначе false
{
if (Size() >= set2.Size())
{
if (set2.Size() == 0)
{
return(true);
}
for (int i = 0; i < size; i++)
{
if (set2.slots[i] != null && !set2.slots[i].Equals(default(T)))
{
if (!Get(set2.slots[i]))
{
break;
}
}
if (i == size - 1)
{
return(true);
}
}
}
return(false);
}
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 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 bool IsSubset(PowerSet <T> set2)
{
// возвращает true, если set2 есть
// подмножество текущего множества,
// иначе false
int size = this.Size();
var union = this.Union(set2);
return(union.Size() == size);
}
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);
}
/// <summary>
/// определяет проверку того, что множество, передаваемое в параметре, является подмножеством текущего множества
/// </summary>
/// <param name="set2">множество элементов типа T</param>
/// <returns>возвращает true если set2 есть подмножество текущего элемента, иначе false</returns>
public bool IsSubset(PowerSet <T> set2)
{
foreach (T item in set2.items)
{
// провекра, что все элементы второго множества присутствуют в первом
if (!Get(item))
{
return(false);
}
}
return(true);
}
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 bool IsSubset(PowerSet <T> set2)
{
foreach (var slot in set2.slots)
{
foreach (var item in slot)
{
if (!Get(item))
{
return(false);
}
}
}
return(true);
}
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> 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
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> 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);
}
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);
}
/// <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 bool IsSubset(PowerSet <T> set2)
{
int k = 0;
foreach (T a in set2.dict.Values)
{
if (dict.ContainsValue(a))
{
k++;
}
}
return(k == set2.dict.Count);
// возвращает true, если set2 есть
// подмножество текущего множества,
// иначе false
}
public bool IsSubset(PowerSet <T> set2)
{
// возвращает true, если set2 есть
// подмножество текущего множества,
// иначе false
var currValues = WhereIsNotNull(slots);
var set2Values = WhereIsNotNull(set2.slots);
foreach (var set2Value in set2Values)
{
if (!currValues.Contains(set2Value))
{
return(false);
}
}
return(true);
}
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);
}
/// <summary>
/// вычисляет и возвращает новое множество - разницу текущего множества и множества set2
/// </summary>
/// <param name="set2">множество PowerSet<T> значений типа T</param>
/// <returns>множество PowerSet<T> разница текущего множества и множества set2</returns>
public PowerSet <T> Difference(PowerSet <T> set2)
{
PowerSet <T> difSet = new PowerSet <T>();
foreach (T item in items)
{
// добавляем все элементы первого множества
difSet.Put(item);
}
foreach (T item in set2.items)
{
// удаляем все элементы второго множества, которые присутствуют в первом
difSet.Remove(item);
}
return(difSet);
}