public void Test(IAtomContainer mol, int expected)
{
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
PermutationGroup group = refiner.GetAutomorphismGroup(mol);
Assert.AreEqual(expected, group.Order());
}
/// <summary>
/// Change the base of the group to the new base <paramref name="newBase"/>.
/// </summary>
/// <param name="newBase">the new base for the group</param>
public void ChangeBase(Permutation newBase)
{
var h = new PermutationGroup(newBase);
int firstDiffIndex = basePermutation.FirstIndexOfDifference(newBase);
for (int j = firstDiffIndex; j < size; j++)
{
for (int a = 0; a < size; a++)
{
Permutation g = permutations[j][a];
if (g != null)
{
h.Enter(g);
}
}
}
for (int j = 0; j < firstDiffIndex; j++)
{
for (int a = 0; a < size; a++)
{
Permutation g = permutations[j][a];
if (g != null)
{
int hj = h.basePermutation[j];
int x = g[hj];
h.permutations[j][x] = new Permutation(g);
}
}
}
this.basePermutation = new Permutation(h.basePermutation);
this.permutations = (Permutation[][])h.permutations.Clone();
}
public void GetSizeTest()
{
int size = 4;
PermutationGroup group = new PermutationGroup(size);
Assert.AreEqual(size, group.Count);
}
void Main()
{
IAtomContainer someMolecule = null;
{
#region 1
IAtomContainer ac = someMolecule; // get an atom container somehow
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
PermutationGroup autG = refiner.GetAutomorphismGroup(ac);
foreach (var automorphism in autG.GenerateAll())
{
// do something with the permutation
}
#endregion
}
{
#region 2
IAtomContainer ac = someMolecule; // get an atom container somehow
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
if (refiner.IsCanonical(ac))
{
// do something with the atom container
}
#endregion
}
{
IAtomContainer ac = someMolecule;
#region 3
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
refiner.Refine(ac);
bool isCanon = refiner.IsCanonical();
PermutationGroup autG = refiner.GetAutomorphismGroup();
#endregion
}
}
public void GetTest()
{
int size = 6;
// group that could represent a hexagon (numbered clockwise from top)
// p1 = a flip across the vertical, p2 = flip across the horizontal
Permutation p1 = new Permutation(0, 5, 4, 3, 2, 1);
Permutation p2 = new Permutation(3, 2, 1, 0, 5, 4);
var generators = new List <Permutation>
{
p1,
p2
};
PermutationGroup group = new PermutationGroup(size, generators);
// the permutations in U0 all have 0 in the orbit of i
// but fixing 0 cannot fix 1, so there is no such perm
int uIndex = 0;
int uSubIndex = 1;
Permutation u01 = group[uIndex, uSubIndex];
Assert.IsNull(u01);
// however, 0 and 3 are in the same orbit by both flips
uSubIndex = 3;
Permutation u03 = group[uIndex, uSubIndex];
var orbit = u03.GetOrbit(0);
Assert.IsTrue(orbit.Contains(uSubIndex));
}
public void OrderTest()
{
int size = 5;
PermutationGroup sym = PermutationGroup.MakeSymN(size);
Assert.AreEqual(Factorial(size), sym.Order());
}
public void GetLeftTransversalTest()
{
PermutationGroup group = GetCubeGroup();
var transversal = group.GetLeftTransversal(1);
Assert.AreEqual(3, transversal.Count);
}
public void TestTransversal()
{
int size = 4;
// Sym(n) : make the total symmetry group
PermutationGroup group = PermutationGroup.MakeSymN(size);
// Aut(G) : make the automorphism group for a graph
Permutation p1 = new Permutation(2, 1, 0, 3);
Permutation p2 = new Permutation(0, 3, 2, 1);
var generators = new List <Permutation>
{
p1,
p2
};
PermutationGroup subgroup = new PermutationGroup(size, generators);
// generate the traversal
var transversal = group.Transversal(subgroup);
int subgroupOrder = (int)subgroup.Order();
int groupOrder = (int)group.Order();
int transversalSize = transversal.Count;
// check that |Aut(G)| / |Sym(N)| = |Transversal|
Assert.AreEqual(Factorial(size), groupOrder);
Assert.AreEqual(groupOrder / subgroupOrder, transversalSize);
}
public void SizeConstructor()
{
int size = 4;
PermutationGroup group = new PermutationGroup(size);
Assert.AreEqual(size, group.Count);
}
public TransversalBacktracker(PermutationGroup parent, PermutationGroup subgroup, long m, IList <Permutation> results)
{
this.parent = parent;
this.subgroup = subgroup;
this.m = m;
this.results = results;
}
/// <summary>
/// Setup the group and refiner; it is important to call this method before
/// calling <see cref="Refine(Partition)"/> otherwise the refinement process will fail.
/// </summary>
/// <param name="group">a group (possibly empty) of automorphisms</param>
/// <param name="refiner">the equitable refiner</param>
public void Setup(PermutationGroup group, EquitablePartitionRefiner refiner)
{
this.bestExist = false;
this.best = null;
this.group = group;
this.equitableRefiner = refiner;
}
public void BaseConstructor()
{
int size = 4;
Permutation base_ = new Permutation(size);
PermutationGroup group = new PermutationGroup(base_);
Assert.AreEqual(size, group.Count);
}
public void AllTest()
{
int size = 4;
PermutationGroup group = PermutationGroup.MakeSymN(size);
var all = group.GenerateAll();
Assert.AreEqual(Factorial(size), all.Count);
}
public void EnterTest()
{
int size = 4;
PermutationGroup group = new PermutationGroup(size);
group.Enter(new Permutation(1, 0, 3, 2));
Assert.AreEqual(2, group.Order());
}
public void ApplyTest()
{
var all = new List <Permutation>();
int size = 4;
PermutationGroup group = PermutationGroup.MakeSymN(size);
group.Apply(new NBacktracker(all));
Assert.AreEqual(Factorial(size), all.Count);
}
public void Test_SuccessTest()
{
PermutationGroup group = GetCubeGroup();
Permutation p = new Permutation(6, 7, 4, 5, 2, 3, 0, 1);
int position = group.Test(p);
// this means p is a member of G
Assert.IsTrue(position == group.Count);
}
public void Test_FailureTest()
{
PermutationGroup group = GetCubeGroup();
Permutation p = new Permutation(1, 2, 3, 4, 0, 6, 7, 5);
int position = group.Test(p);
// this means p is not in G
Assert.IsTrue(position < group.Count);
}
/// <summary>
/// Generate a transversal of a subgroup in this group.
/// </summary>
/// <param name="subgroup">the subgroup to use for the transversal</param>
/// <returns>a list of permutations</returns>
public IReadOnlyCollection <Permutation> Transversal(PermutationGroup subgroup)
{
long m = this.Order() / subgroup.Order();
var results = new List <Permutation>();
var transversalBacktracker = new TransversalBacktracker(this, subgroup, m, results);
this.Apply(transversalBacktracker);
return(results);
}
public void Apply_FinishEarlyTest()
{
List <Permutation> all = new List <Permutation>();
int max = 5; // stop after this many seen
int size = 4;
PermutationGroup group = PermutationGroup.MakeSymN(size);
group.Apply(new FinishEarlyBacktracker(all, max));
Assert.AreEqual(max, all.Count);
}
public void GetAutomorphismGroup_StartingPartitionTest()
{
Partition partition = Partition.FromString("0,1|2,3");
string acpString = "C0C1C2C3 0:1(1),0:3(1),1:2(1),2:3(1)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
PermutationGroup autG = refiner.GetAutomorphismGroup(ac, partition);
Assert.AreEqual(2, autG.Order());
}
public void SetupTest()
{
int n = 5;
PermutationGroup group = new PermutationGroup(n);
Graph g = new Graph(n);
MockRefiner refiner = new MockRefiner(g);
Setup(refiner, group, g);
Assert.AreEqual(group, refiner.GetAutomorphismGroup());
}
public void GetAutomorphismGroupTest()
{
string acpString = "C0C1C2O3 0:1(2),0:2(1),1:3(1),2:3(1)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
PermutationGroup autG = refiner.GetAutomorphismGroup(ac);
Assert.IsNotNull(autG);
Assert.AreEqual(1, autG.Order());
}
public void RefineTest()
{
string acpString = "C0C1O2O3 0:1(1),0:3(1),1:2(1),2:3(1)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
refiner.Refine(ac);
PermutationGroup autG = refiner.GetAutomorphismGroup();
Assert.AreEqual(2, autG.Order());
}
public void GetAutomorphismGroup_StartingGroupTest()
{
string acpString = "C0C1C2C3 0:1(1),0:2(1),1:3(1),2:3(1)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
Permutation flip = new Permutation(1, 0, 3, 2);
PermutationGroup autG = new PermutationGroup(4, new[] { flip });
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
refiner.GetAutomorphismGroup(ac, autG);
Assert.IsNotNull(autG);
Assert.AreEqual(8, autG.Order());
}
public void Refine_IgnoreBondOrderTest()
{
string acpString = "C0C1C2C3 0:1(2),0:3(1),1:2(1),2:3(2)";
IAtomContainer ac = AtomContainerPrinter.FromString(acpString, builder);
bool ignoreBondOrder = true;
BondDiscretePartitionRefiner refiner = new BondDiscretePartitionRefiner(ignoreBondOrder);
refiner.Refine(ac);
PermutationGroup autG = refiner.GetAutomorphismGroup();
Assert.AreEqual(8, autG.Order());
}
public void GetGroupTest()
{
int n = 3;
Graph g = new Graph(n)
{
connectionTable = new int[][] { new[] { 0, 1, 0 }, new[] { 1, 0, 1 }, new[] { 0, 1, 0 } }
};
PermutationGroup group = new PermutationGroup(n);
MockRefiner refiner = new MockRefiner(g);
Setup(refiner, group, g);
Assert.IsNotNull(refiner.GetAutomorphismGroup());
}
public void RefineTest()
{
int n = 3;
Graph g = new Graph(n)
{
connectionTable = new int[][] { new[] { 0, 1, 1 }, new[] { 1, 0, 0 }, new[] { 1, 0, 0 } }
};
PermutationGroup group = new PermutationGroup(n);
MockRefiner refiner = new MockRefiner(g);
Setup(refiner, group, g);
refiner.Refine(Partition.Unit(n));
Assert.IsNotNull(refiner);
}
public void GeneratorConstructor()
{
int size = 4;
Permutation p1 = new Permutation(1, 0, 2, 3);
Permutation p2 = new Permutation(1, 2, 3, 0);
var generators = new List <Permutation>
{
p1,
p2
};
PermutationGroup group = new PermutationGroup(size, generators);
Assert.AreEqual(size, group.Count);
Assert.AreEqual(Factorial(size), group.Order());
}
public void GetFirstHalfMatrixStringTest()
{
int n = 3;
Graph g = new Graph(n)
{
connectionTable = new int[][] { new[] { 0, 0, 1 }, new[] { 0, 0, 1 }, new[] { 1, 1, 0 } }
};
PermutationGroup group = new PermutationGroup(n);
MockRefiner refiner = new MockRefiner(g);
Setup(refiner, group, g);
refiner.Refine(Partition.Unit(n));
string hms = refiner.GetFirstHalfMatrixString();
string expected = "110";
Assert.AreEqual(expected, hms);
}
public void GetFirstTest()
{
int n = 3;
Graph g = new Graph(n)
{
connectionTable = new int[][] { new[] { 0, 1, 0 }, new[] { 1, 0, 1 }, new[] { 0, 1, 0 } }
};
PermutationGroup group = new PermutationGroup(n);
MockRefiner refiner = new MockRefiner(g);
Setup(refiner, group, g);
refiner.Refine(Partition.Unit(n));
Permutation first = refiner.GetFirst();
Permutation expected = new Permutation(1, 0, 2);
Assert.AreEqual(expected, first);
}
