/// <summary>
/// This method returns all possible subset of the current set
/// </summary>
public SetClass <SetClass <T> > Powerset()
{
//Any implementation that can enumerate all possible subsets, here is an example
//there is another one that uses Math.Pow method
int n = 1 << Data.Count; //this is one way to get 2 to the power of n using left shift operation
SetClass <SetClass <T> > result =
new SetClass <SetClass <T> >(new Vector <SetClass <T> >());
//loops on the number of possible subsets, and try to construct the corresponding subset
for (int i = 0; i < n; i++)
{
SetClass <T> subset = new SetClass <T>(new Vector <T>());
//subsetIndex is the index of the subset in the list of possible subsets - 0,1,2,..
// elementIndex is the index of the current set elements to add to the subset
for (int subsetIndex = i, elementIndex = 0; subsetIndex != 0; subsetIndex /= 2, elementIndex++)
{
//if the corresponding bit is equal to 1,
//it means that this set element should be added to the curret subset,
//based on its index
if ((subsetIndex & 1) != 0)
{
subset.Data.Add(Data[elementIndex]);
}
}
result.Data.Add(subset);
}
return(result);
}
/// <summary>
/// This method returns all elements in the current set as well as the input set B without duplicates
/// </summary>
/// <returns> a SetClass object that contains all elements in both A and B</returns></returns>
/// <param name="B">the other set to find union with</param>
public SetClass <T> UnionWith(SetClass <T> B)
{
//Any implementation that get all elements in A and B - no duplicates
SetClass <T> result = new SetClass <T>(new Vector <T>());
//Add all elements in current set
var count = Data.Count;
for (int i = 0; i < count; i++)
{
result.Data.Add(Data[i]);
}
//Add new elements from set B
count = B.Data.Count;
for (int i = 0; i < count; i++)
{
if (result.Data.Contains(B.Data[i]) == false)
{
result.Data.Add(B.Data[i]);
}
}
return(result);
}
public SetClass <SetClass <T> > Powerset()
{
//to get the number of elements to later apply to the (2^n) formula
int x = Data.Count;
//bit shifting
int setCount = 1 << x;
//creating a object of setclass
SetClass <SetClass <T> > resultSetClass = new SetClass <SetClass <T> >();
//a loop to run x times
for (int j = 0; j < setCount; j++)
{
//creating an object of T
SetClass <T> tempSet = new SetClass <T>();
for (int i = 0; i < x; i++)
{
//checking whether the elements are not null set
if ((j & (1 << i)) > 0)
{
//the values in the tempset is then added to the vector result
tempSet.result.Add(Data[i]);
//Console.Write(Data[i]);
}
//Console.WriteLine();
}
resultSetClass.powersetResult.Add(tempSet);
}
// addresults(resultSetClass);
return(resultSetClass);
;
}
//a method to add values to the "result"
public void addresults(SetClass <SetClass <T> > resultSetClass)
{
for (int y = 0; y < resultSetClass.result.Count; y++)
{
Console.Write(resultSetClass.result[y].result.ToString());
Console.WriteLine();
}
}
public SetClass <SetClass <T> > Powerset()
{
SetClass <SetClass <T> > power = new SetClass <SetClass <T> >(new Vector <SetClass <T> >());
if (this.Data.Count == 0)
{
power.Add(this);
}
else
{
// Assume that s is a subset that contains all elements of data exept Data[0]
// Step 1: Your are to create such a set s
// Hint: just simply add all elements from Data[1] to Data[Count-1] to s
SetClass <T> s = new SetClass <T>(new Vector <T>());
for (int j = 1; j < this.Data.Count; j++)
{
s.Data.Add(this.Data[j]);
}
// Step 2: Let powerS be the power set of s.
// powerS can be obtained recursively, e.g.
SetClass <SetClass <T> > powerS = s.Powerset();
// Step 3: You need to add all elements of powerS to power.
// This is because s is a subset created from Data[1] to Data[Count-1] and thus
// powerS is a subset of power. In particular, you should
// add powerS.Data[0] to power
// add powerS.Data[1] to power
// ...
// add powerS.Data[powerS.Data.Count-1] to power
for (int j = 0; j < powerS.Data.Count; j++)
{
power.Add(powerS.Data[j]);
}
// Step 4:
// For each set p of powerS, you create another set, called augP (i.e. augmented p) such that
// (i) augP is a copy of p. Note that you should not simply assign as augP = p.
// (ii) augP is then augmented with Data[0], i.e. augP.Add(this.Data[0]);
// then add augP to power
// End for
for (int j = 0; j < powerS.Data.Count; j++)
{
SetClass <T> p = powerS.Data[j];
SetClass <T> augP = new SetClass <T>(new Vector <T>());
for (int k = 0; k < p.Data.Count; k++)
{
augP.Add(p.Data[k]);
}
augP.Add(this.Data[0]);
power.Add(augP);
}
}
return(power);
}
public SetClass <T> Complement(SetClass <T> U)
{
SetClass <T> tempComplementSet = new SetClass <T>();
Vector <T> difference = Difference(U).result;
for (int i = 0; i < U.Data.Count; i++)
{
tempComplementSet.result.Add(difference[i]);
}
return(tempComplementSet);
}
public bool IsSupersetOf(SetClass <T> B)
{
for (int i = 0; i < Data.Count; i++)
{
if (Data.Contains(B.Data[i]) == false)
{
return(false);
}
}
return(true);
}
public SetClass <T> IntersectionWith(SetClass <T> B)
{
for (int i = 0; i < B.Data.Count; i++)
{
if (Data.Contains(B.Data[i]) == true)
{
result.Add(B.Data[i]);
}
}
return(null);
}
public SetClass <T> Difference(SetClass <T> B)
{
SetClass <T> diff = new SetClass <T>(new Vector <T>());
for (int i = 0; i < this.Data.Count; i++)
{
if (!B.Membership(this.Data[i]))
{
diff.Add(this.Data[i]);
}
}
return(diff);
}
public SetClass <T> IntersectionWith(SetClass <T> B)
{
SetClass <T> inter = new SetClass <T>(new Vector <T>());
for (int i = 0; i < this.Data.Count; i++)
{
if (B.Membership(this.Data[i]))
{
inter.Add(this.Data[i]);
}
}
return(inter);
}
public SetClass <Tuple <T, T2> > CartesianProduct <T2>(SetClass <T2> B)
{
SetClass <Tuple <T, T2> > product = new SetClass <Tuple <T, T2> >(new Vector <Tuple <T, T2> >());
for (int i = 0; i < this.Data.Count; i++)
{
for (int j = 0; j < B.Data.Count; j++)
{
product.Add(new Tuple <T, T2>(this.Data[i], B.Data[j]));
}
}
return(product);
}
public SetClass <T> UnionWith(SetClass <T> B)
{
SetClass <T> union = new SetClass <T>(new Vector <T>());
for (int i = 0; i < this.Data.Count; i++)
{
union.Add(this.Data[i]);
}
for (int i = 0; i < B.Data.Count; i++)
{
union.Add(B.Data[i]);
}
return(union);
}
/// <summary>
/// This method checks if the current set contains all elements in an input set B
/// </summary>
/// <returns><c>true</c>,if this set is a superset of input set B, <c>false</c> otherwise.</returns>
/// <param name="B">B.</param>
public bool IsSupersetOf(SetClass <T> B)
{
//any implementation that checks if every single element in B exists in A
var count = B.Data.Count;
for (int i = 0; i < count; i++)
{
if (Data.Contains(B.Data[i]) == false)
{
return(false);
}
}
return(true);
}
public SetClass <T> Difference(SetClass <T> B)
{
SetClass <T> tempDifferenceSet = new SetClass <T>();
//same logic as union set. Checks whether the set A contains the same element in B and if not it is added to the result
for (int i = 0; i < B.Data.Count; i++)
{
if (!Data.Contains(B.Data[i]))
{
tempDifferenceSet.result.Add(B.Data[i]);
}
}
return(tempDifferenceSet);
}
/// <summary>
/// This method returns the elements in current set but not in set B
/// </summary>
/// <returns> a SetClass object that contains all elements in current set, but not in B</returns></returns>
/// <param name="B">the other set to find difference with</param>
public SetClass <T> Difference(SetClass <T> B)
{
SetClass <T> result = new SetClass <T>(new Vector <T>());
var count = Data.Count;
for (int i = 0; i < count; i++)
{
if (B.Data.Contains(B.Data[i]) == false)
{
result.Data.Add(Data[i]);
}
}
return(result);
}
/// <summary>
/// This method finds the intersection between current set and input set B
/// </summary>
/// <returns>a SetClass object that contains all common elements between this set and set B</returns>
/// <param name="B">the other set to find intersection with</param>
public SetClass <T> IntersectionWith(SetClass <T> B)
{
//Any implementation that gets common elements between this set and set B
SetClass <T> result = new SetClass <T>(new Vector <T>());
var count = Data.Count;
for (int i = 0; i < count; i++)
{
if (B.Data.Contains(Data[i]) == true)
{
result.Data.Add(Data[i]);
}
}
return(result);
}
/// <summary>
/// This method returns the cartesian product of current set (set A) and input set (set B)
/// </summary>
/// <returns>A SetClass object that contains pairs (a, b) of elements from A, and B respectively</returns>
/// <param name="B">B.</param>
/// <typeparam name="T2">the other set to find the cartesian product</typeparam>
public SetClass <Tuple <T, T2> > CartesianProduct <T2>(SetClass <T2> B)
{
SetClass <Tuple <T, T2> > result =
new SetClass <Tuple <T, T2> >(new Vector <Tuple <T, T2> >());
var aCount = Data.Count;
var bCount = B.Data.Count;
for (int i = 0; i < aCount; i++)
{
for (int j = 0; j < bCount; j++)
{
result.Data.Add(new Tuple <T, T2>(Data[i], B.Data[j]));
}
}
return(result);
}
public SetClass <T> SymmetricDifference(SetClass <T> B)
{
//symmetric difference is the union of the two sets excluding the intersection set
//a set class for symmmetric difference
SetClass <T> tempSymDif = new SetClass <T>();
//an object of vector called union which will get the result of the union
Vector <T> union = UnionWith(B).result;
//an object of vector called intersection to get the result of intersection
Vector <T> intersection = IntersectionWith(B).result;
for (int i = 0; i < Data.Count; i++)
{
if (!(union[i].Equals(intersection[i])))
{
tempSymDif.result.Add(union[i]);
}
}
return(tempSymDif);
}
public SetClass <Tuple <T, T2> > CartesianProduct <T2>(SetClass <T2> B)
{
//creating a vector object of type tuple
Vector <Tuple <T, T2> > tupleVector = new Vector <Tuple <T, T2> >();
//the first loop is to run the elements of the first set
for (int i = 0; i < Data.Count; i++)
{
//a nested loop is implemented so that the same element of first set will be multiplied with all the elements in the set B
for (int j = 0; j < B.Data.Count; j++)
{
//new tuple is made to get the products of elements from both the sets and then added to the tuple vector
Tuple <T, T2> tempTupleSet = new Tuple <T, T2>(Data[i], B.Data[j]);
tupleVector.Add(tempTupleSet);
}
}
//then the tuple vector is added to a set class
SetClass <Tuple <T, T2> > tupleSetClass = new SetClass <Tuple <T, T2> >(tupleVector);
return(tupleSetClass);
}
public SetClass <T> UnionWith(SetClass <T> B)
{
//first an object of a set class called union is created to add the values
SetClass <T> tempUnionSet = new SetClass <T>();
for (int i = 0; i < Data.Count; i++)
{
//check whether the results in the temp union set contains the values already, if not then the elements of set A are added into the tempunion set result
if (!(tempUnionSet.result.Contains(Data[i])))
{
tempUnionSet.result.Add(Data[i]);
}
}
//same as above but for set B
for (int i = 0; i < B.Data.Count; i++)
{
if (!(tempUnionSet.result.Contains(B.Data[i])))
{
tempUnionSet.result.Add(B.Data[i]);
}
}
return(tempUnionSet);
}
public bool IsSupersetOf(SetClass <T> B)
{
return(B.IsSubsetOf(this));
}
/// <summary>
/// This method find elements in current set (set A), but not in input set B AND
/// elements in input set B, but not in current set.
/// </summary>
/// <returns>a SetClass object that contains elements in A but not in B, and elements in B but not in A</returns>
/// <param name="B">B.</param>
public SetClass <T> SymmetricDifference(SetClass <T> B)
{
//Any implementation that gets (A - B) union (B - A)
return(this.Difference(B).UnionWith(B.Difference(this)));
}
/// <summary>
/// This method finds elements in U (universal set - superset that has all elements in A and more) but not in A
/// </summary>
/// <returns>a SetClass object that contains elements in U but not in A</returns>
/// <param name="U">The universal set</param>
public SetClass <T> Complement(SetClass <T> U)
{
return(U.Difference(this));
}
public bool IsEqual(SetClass <T> B)
{
return(this.IsSubsetOf(B) && B.IsSubsetOf(this));
}
