static void Main(string[] args)
{
var SetX = new FiniteSet <element>();
SetX.Add(element.One);
SetX.Add(element.Five);
var SetY = new FiniteSet <element>();
SetY.Add(element.Two);
SetY.Add(element.Four);
SetY.Add(element.Five);
var SetZ = new FiniteSet <element>()
{
(element)1, (element)2, (element)3, (element)4, (element)5
};
Console.WriteLine("Hello World!");
//Console.WriteLine(SetY.PowerSet().Contains(SetY));
//Console.WriteLine(SetY.PowerSet().Contains(SetX));
//5.OpenSetsListOutMethod();
6.OpenSetsListOutMethod();
//8.OpenSetsListOutMethod();
Console.ReadLine();
}
internal static Set UniteFiniteSetAndSet(FiniteSet finite, Set set)
{
if (set is FiniteSet another)
{
return(FiniteSet.Unite(finite, another));
}
var sb = new FiniteSetBuilder();
if (set is Interval(var left, var leftClosed, var right, var rightClosed) inter)
{
var newLeftClosed = leftClosed;
var newRightClosed = rightClosed;
foreach (var el in finite)
{
if (!set.TryContains(el, out var contains) || !contains)
{
if (el == left)
{
newLeftClosed = true;
}
else if (el == right)
{
newRightClosed = true;
}
else
{
sb.Add(el);
}
}
}
set = inter.New(left, newLeftClosed, right, newRightClosed);
}
public void AutoTest(string inequality, string setToCheck = "{ -5, -3, 0, 3, 5 }")
{
FiniteSet checkpoints = (FiniteSet)setToCheck.Simplify();
var roots = (Set)inequality.Solve("x").Substitute("a", -10).Substitute("b", 10).Simplify();
foreach (var cp in checkpoints)
{
Assert.True(roots.Contains(cp) == inequality.Substitute("x", cp).Substitute("a", -10).Substitute("b", 10).EvalBoolean(),
$"{roots} doesn't contain {cp}");
}
}
static void Main(string[] args)
{
var sets = new FiniteSet <FiniteSet <int> >();
var universe = new FiniteSet <int>();
universe.AddRange(3);
universe.AddRange(2);
universe.AddRange(7);
var some = new FiniteSet <int>();
some.AddRange(2);
var someOther = new FiniteSet <int>();
someOther.AddRange(7);
var s7 = new FiniteSet <int>();
s7.AddRange(7);
s7.AddRange(2);
s7.AddRange(3);
var s8 = new FiniteSet <int>();
s8.AddRange(7, 2);
var s9 = new FiniteSet <int>();
s9.AddRange(7, 3);
var s19 = new FiniteSet <int>();
s19.AddRange(2, 3);
sets.AddRange(universe);
sets.AddRange(new FiniteSet <int>());
sets.AddRange(some);
//sets.AddRange(universe.ExceptToNew(some));
//sets.AddRange(someOther);
sets.AddRange(s9);
System.Diagnostics.Debug.WriteLine(Check(sets, universe));
}
static void Stuff()
{
var mySet = new FiniteSet <int>(0, 1, 2, 3, 4, 5);
var myOtherSet = new FiniteSet <string>("asdf", "123", "b", "z", "94", "0");
var myOtherSetList = myOtherSet.ToList();
var p = Permutation <int> .FromMappings(mySet, new Dictionary <int, int> {
{ 0, 4 }, { 1, 2 }, { 2, 0 }, { 3, 5 }, { 4, 1 }, { 5, 3 }
});
var permutations = Permutation <int> .SetPermutations(mySet).ToArray();
var evenPermutations = (from a in permutations where a.Sign == 1 select a).ToArray();
var onePermutations = (from a in permutations where a.Count == 1 select a).ToArray();
var p2 = Permutation <string> .FromPermutation(myOtherSet, p, i => myOtherSetList[i]);
var myGroup = new Group <int>(mySet, (a, b) => (a + b) % 6, null);
var mySubgroup = myGroup.Subgroup(new FiniteSet <int>(0, 3));
Func <int, Permutation <int> > outerIsomorphism;
var myGroupP = myGroup.ToPermutationGroup(out outerIsomorphism);
var mySubgroupP = Group <Permutation <int> > .FromGroup(mySubgroup, outerIsomorphism);
var s3 = Group.SymmetricGroup(3);
var s4 = Group.SymmetricGroup(4);
var s6 = Group.SymmetricGroup(6);
var graphEdgeList = new List <UnorderedPair <int> >();
for (int i = 1; i <= 4; i++)
{
for (int j = i + 1; j <= 4; j++)
{
graphEdgeList.Add(new UnorderedPair <int>(i, j));
}
}
var graphEdges = new FiniteSet <UnorderedPair <int> >(graphEdgeList);
Func <Permutation <int>, UnorderedPair <int>, UnorderedPair <int> > graphEdgeAction = (g, e) => new UnorderedPair <int>(g[e.First], g[e.Second]);
var actionGroup = s4.ActionGroup(graphEdgeAction, graphEdges);
var cycleIndex = Group.CycleIndex(actionGroup);
Func <int, Polynomial <Rational, RationalField> > xFunction = k => Polynomial <Rational, RationalField> .X.Pow(k) + (Rational)1;
var cycleIndexAnswer = cycleIndex.Evaluate(xFunction);
SomeExample2();
SomeExample();
TestMatrix();
}
internal static IEnumerable <Entity> ApplyX2(FiniteSet oneSet, FiniteSet secondSet, Func <Entity, Entity, Entity> op)
{
var els = new List <Entity>();
var secondSetEls = secondSet.Elements.ToArray(); // we do it to avoid reallocation every iteration
foreach (var elA in oneSet)
{
foreach (var elB in secondSetEls)
{
els.Add(op(elA, elB));
}
}
return(els);
}
static public bool Check <T>(FiniteSet <FiniteSet <T> > sets, FiniteSet <T> universe)
{
//System.Diagnostics.Debug.Write(
// sets.SetEquals(
// new FiniteSet<FiniteSet<T>>(
// (a, b) => a.SetEquals(b)
// )
// )
// );
// public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value);
//where TSource=FinisteSet<int>
return
///the given set is in the sets.
(sets.Contains(universe)
&&
/// all are the subset of given set.
sets.All(
x => x.IsSubsetOf(universe)
)
&&
///the compliment set of each element is in the sets.
sets.All(
x => sets.Contains(new FiniteSet <T>(universe.Except(x)))
)
&&
///the union of each subsets of sets is in the given set.
///
PowerSetX.ToHashSets(sets).All(
x => sets.Contains(x.Aggregate(new FiniteSet <T>(), (a, c) => new FiniteSet <T>(a.Union(c))))
));
}
internal static Set SetSubtractSetAndFiniteSet(Set set, FiniteSet finite)
{
if (set is FiniteSet another)
{
return(FiniteSet.Subtract(another, finite));
}
var fsb = new FiniteSetBuilder(finite);
foreach (var el in finite)
{
if (set.TryContains(el, out var contains) && !contains)
{
fsb.Remove(el);
}
}
return(fsb.IsEmpty ? set : set.SetSubtract(fsb.ToFiniteSet()));
}
/// <summary>
/// Evaluates the node, using the variables provided in the <paramref name="Variables"/> collection.
/// </summary>
/// <param name="Variables">Variables collection.</param>
/// <returns>Result.</returns>
public override IElement Evaluate(Variables Variables)
{
IElement L = this.left.Evaluate(Variables);
if (!(L is ISet S1))
{
S1 = new FiniteSet(new IElement[] { L });
}
IElement R = this.right.Evaluate(Variables);
if (!(R is ISet S2))
{
S2 = new FiniteSet(new IElement[] { R });
}
return(new UnionSet(S1, S2));
}
/// <summary>
/// Evaluates the node, using the variables provided in the <paramref name="Variables"/> collection.
/// </summary>
/// <param name="Variables">Variables collection.</param>
/// <returns>Result.</returns>
public override IElement Evaluate(Variables Variables)
{
IElement L = this.left.Evaluate(Variables);
ISet S1 = L as ISet;
if (S1 is null)
{
S1 = new FiniteSet(new IElement[] { L });
}
IElement R = this.right.Evaluate(Variables);
ISet S2 = R as ISet;
if (S2 is null)
{
S2 = new FiniteSet(new IElement[] { R });
}
return(new IntersectionSet(S1, S2));
}
/// <summary>
/// Converts (if necessary) the element <paramref name="E"/> into a set.
/// </summary>
/// <param name="E">Element</param>
/// <returns>Set, or null if not possible to convert.</returns>
public static ISet ToSet(IElement E)
{
ISet Result = E as ISet;
if (Result is null)
{
if (E is IVector Vector)
{
Result = new FiniteSet(Vector.ChildElements);
}
else
{
object Obj = E.AssociatedObjectValue;
Result = Obj as ISet;
if (Result is null)
{
if (Obj is IEnumerable <IElement> Elements)
{
Result = new FiniteSet(Elements);
}
else if (Obj is IEnumerable <object> Objects)
{
LinkedList <IElement> List = new LinkedList <IElement>();
foreach (object x in Objects)
{
List.AddLast(Expression.Encapsulate(x));
}
Result = new FiniteSet(List);
}
else
{
return(null);
}
}
}
}
return(Result);
}
static void SomeExample()
{
var s6 = Group.SymmetricGroup(6);
var setX = new FiniteSet <int>(1, 2, 3, 4, 5, 6);
var perm = Permutation <int> .FromDisjointCycles(setX, new Cycle <int>[] { new Cycle <int>(new int[] { 1, 2, 4, 6 }), new Cycle <int>(new int[] { 3, 5 }) });
Func <Permutation <int>, int, int> action = (p, k) => p[k];
var s6subgroup = s6.GeneratedSubgroup(perm);
var s3 = Group.SymmetricGroup(3);
var s3subgroup = s3.GeneratedSubgroup(Permutation <int> .FromCycle(s3.Identity.Set, new Cycle <int>(new int[] { 1, 2 })));
Func <Permutation <int>, Group <Permutation <int> >, Group <Permutation <int> > > conjugationAction =
(p, h) => s3.Subgroup(Group <Permutation <int> > .RightProduct(s3, Group <Permutation <int> > .LeftProduct(s3, p, h.Set), s3.Inverse(p)));
var orders2 = Group.CyclicGroup(15).Set.Select(x => Group.CyclicGroup(15).OrderOf(x)).ToArray();
var orders1 = Group.DihedralGroup(15).Set.Select(x => Group.DihedralGroup(15).OrderOf(x)).ToArray();
var group = Group.DirectProduct(Group.CyclicGroup(3), Group.DihedralGroup(5));
var orders = group.Set.Select(x => group.OrderOf(x)).ToArray();
var group3 = Group.DirectProduct(Group.CyclicGroup(5), Group.DihedralGroup(3));
var orders3 = group3.Set.Select(x => group3.OrderOf(x)).ToArray();
var d14 = Group.DihedralGroup(14);
var d7z2 = Group.DirectProduct(Group.DihedralGroup(7), Group.CyclicGroup(2));
Func <Pair <Pair <int, bool>, int>, Pair <int, bool> > isomorphism =
g => g.Second == 1 ? new Pair <int, bool>((g.First.First * 2 + 7) % 14, g.First.Second) : new Pair <int, bool>(g.First.First * 2, g.First.Second);
var s6subgroup2 = s6.StabilizerSubgroup(action, 6);
var group222 = Group.DirectProduct(Group.DirectProduct(Group.CyclicGroup(2), Group.CyclicGroup(2)), Group.DihedralGroup(4)).ToPermutationGroup();
var group222orders = group222.Set.Select(x => group222.OrderOf(x)).ToArray();
var ring = new Ring <int>(Group.CyclicGroup(10), (x, y) => (x * y) % 10);
Func <int, int> cyclicH = k => (4 * k) % 8;
}
internal static Set IntersectFiniteSetAndSet(FiniteSet finite, Set set)
{
if (set is FiniteSet another)
{
return(FiniteSet.Intersect(finite, another));
}
var fsb = new FiniteSetBuilder();
var amb = new FiniteSetBuilder();
foreach (var elem in finite)
{
if (!set.TryContains(elem, out var contains))
{
amb.Add(elem);
}
else if (contains)
{
fsb.Add(elem);
}
}
return(amb.IsEmpty ? fsb.ToFiniteSet() : amb.ToFiniteSet().Unite(fsb.ToFiniteSet()));
}
static void AssertRootCount(FiniteSet roots, int target)
{
Assert.NotEqual(-1, target);
Assert.Equal(target, roots.Count);
}
Inf(var var1, FiniteSet finite) when finite.Count == 1 => var1.Equalizes(finite.First()),
