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); }