public void EquatorPermutationCoordTest() //Tests GetEquatorPermutationCoord, SetEquatorPermutationCoord
{
Random random = new Random(7777777);
int length = 50;
int repetitions = 50;
//if solved permutation corresponds to the coordinate 0
//SetEquatorPermutationCoord()
CubieCube expected = CubieCube.CreateSolved();
CubieCube result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEquatorOrder(result, 0);
CubingAssert.HaveEqualEquatorEdgePermutation(expected, result);
expected = CubieCube.FromAlg(Alg.FromString("R2 L2"));
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEquatorOrder(result, Coordinates.NumEquatorOrders - 1);
//GetEquatorPermutationCoord()
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetEquatorOrder(result));
result.ApplyAlg(Alg.FromString("F' R' B' D' L2"));
Assert.AreEqual(0, Coordinates.GetEquatorOrder(result));
//apply B1
int expectedCoord = 17;
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.B1);
int resultCoord = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedCoord, resultCoord);
//apply B2
expectedCoord = 6;
cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.B2);
resultCoord = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedCoord, resultCoord);
//if applying GetEquatorPermutationCoord() and SetEquatorPermutationCoord() results in the same array as at the beginning
for (int repetition = 0; repetition < repetitions; repetition++)
{
expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
result = CubieCube.CreateSolved();
int coord = Coordinates.GetEquatorOrder(expected);
Coordinates.SetEquatorOrder(result, coord);
CubingAssert.HaveEqualEquatorEdgePermutation(expected, result);
}
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetEquatorOrder(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetEquatorOrder(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEquatorOrder(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEquatorOrder(CubieCube.CreateSolved(), Coordinates.NumEquatorOrders));
}
public void CpCoordTest() //Tests GetCpCoord, SetCpCoord
{
Random random = new Random(7777777);
int length = 50;
//if applying GetCpCoord and SetCpCoord results in the same array as at the beginning
CubieCube expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
CubieCube result = CubieCube.CreateSolved();
int coord = Coordinates.GetCornerPermutation(expected);
Coordinates.SetCornerPermutation(result, coord);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
//apply R2 to a solved cube
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.R2);
int expectedCoord = 36177;
int resultCoord = Coordinates.GetCornerPermutation(cube);
Assert.AreEqual(expectedCoord, resultCoord);
expected = CubieCube.CreateSolved();
expected.ApplyMove(Move.R2);
result = CubieCube.CreateSolved();
Coordinates.SetCornerPermutation(result, expectedCoord);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
//if solved permutation corresponds to the coordinate 0
expected = CubieCube.CreateSolved();
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetCornerPermutation(result, 0);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetCornerPermutation(result));
//example from http://kociemba.org/math/coordlevel
Corner[] cp = new Corner[] { Corner.DFR, Corner.UFL, Corner.ULB, Corner.URF, Corner.DRB, Corner.DLF, Corner.DBL, Corner.UBR };
cube = CubieCube.Create(cp, CubieCube.SolvedCO, CubieCube.SolvedEP, CubieCube.SolvedEO, CubieCube.SolvedCenters);
resultCoord = Coordinates.GetCornerPermutation(cube);
expectedCoord = 21021;
Assert.AreEqual(expectedCoord, resultCoord);
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetCornerPermutation(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetCornerPermutation(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetCornerPermutation(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetCornerPermutation(CubieCube.CreateSolved(), Coordinates.NumCornerPermutations));
}
public void EpCoordTest() //Tests GetCpCoord, SetCpCoord
{
Random random = new Random(7777777);
int length = 50;
//if applying GetEpCoord and SetEpCoord results in the same array as at the beginning
CubieCube expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
CubieCube result = CubieCube.CreateSolved();
int coord = Coordinates.GetEdgePermutation(expected);
Coordinates.SetEdgePermutation(result, coord);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
//apply R2 to a solved cube
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.R2);
int expectedCoord = 123763104;
int resultCoord = Coordinates.GetEdgePermutation(cube);
Assert.AreEqual(expectedCoord, resultCoord);
expected = CubieCube.CreateSolved();
expected.ApplyMove(Move.R2);
result = CubieCube.CreateSolved();
Coordinates.SetEdgePermutation(result, expectedCoord);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
//if solved permutation corresponds to the coordinate 0
expected = CubieCube.CreateSolved();
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEdgePermutation(result, 0);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetEdgePermutation(result));
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetEdgePermutation(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetEdgePermutation(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEdgePermutation(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEdgePermutation(CubieCube.CreateSolved(), Coordinates.NumEdgePermutations));
}
public void StaticTest(string algString)
{
Alg scramble = Alg.FromString(algString);
CubieCube cube = CubieCube.FromAlg(scramble);
TimeSpan timeout = TimeSpan.FromSeconds(1);
float returnValue = 4000;
float requiredValue = 5000;
float[] weights =
{
169.658122242946f,
253.796705882179f,
211.084512473536f,
206.193406852305f,
299.809258427086f,
155.496912851115f,
158.690899467791f,
281.70422762001f,
346.448146439892f,
274.885031555195f,
311.019164835258f,
258.486161100002f,
196.885474673572f,
275.657440421246f,
214.624405800259f,
322.649818802591f,
354.012863621357f,
321.02200029978f
};
float[] weightedPhase2PruningTable = WeightedPruningTables.CreateWeightedPhase2CornerEquatorTable(weights);
Alg solution = WeightedTwoPhaseSolver.FindSolution(cube, timeout, returnValue, requiredValue, weights, weightedPhase2PruningTable);
Console.WriteLine("Scramble: " + scramble + "\nSolution: " + solution + "\nLength: " + solution.Length);
Assert.IsTrue(solution.Select(move => weights[(int)move]).Sum() <= requiredValue);
CubieCube expected = CubieCube.CreateSolved();
CubieCube result = CubieCube.CreateSolved();
result.ApplyAlg(scramble);
result.ApplyAlg(solution);
Assert.AreEqual(expected, result);
}
public void UEdgeCoordTest()
{
Random random = new Random(7777777);
int length = 50;
int repetitions = 50;
CubieCube expected;
CubieCube result;
int expectedCoord;
int resultCoord;
double[] phase2probabilities =
{
0d, 1d, 0d, 1d, 1d, 1d, 0d, 1d, 0d,
0d, 1d, 0d, 1d, 1d, 1d, 0d, 1d, 0d
};
//solved tests
Assert.AreEqual(0, Coordinates.GetUEdgeDistribution(CubieCube.CreateSolved()));
//scrambled tests
for (int i = 0; i < repetitions; i++)
{
result = CubieCube.CreateSolved();
expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
expectedCoord = Coordinates.GetUEdgePermutation(expected);
Coordinates.SetUEdgePermutation(result, expectedCoord);
resultCoord = Coordinates.GetUEdgePermutation(result);
int expectedDistribution = expectedCoord / Coordinates.NumUEdgePermutations;
int expectedPermutation = expectedCoord % Coordinates.NumUEdgePermutations;
int resultDistribution = resultCoord / Coordinates.NumUEdgePermutations;
int resultPermutation = resultCoord % Coordinates.NumUEdgePermutations;
Assert.AreEqual(expectedDistribution, resultDistribution);
Assert.AreEqual(expectedPermutation, resultPermutation);
}
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetUEdgePermutation(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetUEdgePermutation(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetUEdgePermutation(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetUEdgePermutation(CubieCube.CreateSolved(), Coordinates.NumUEdgePermutations));
}
public void CostTooHighTest() //There used to be an error when solving this scramble
{
string algString = "B2 D B F' D L U B U' F' R' F2 B' L' F' R B2 R' U R' L2 D R2 F2 L B2";
Alg scramble = Alg.FromString(algString);
CubieCube cube = CubieCube.FromAlg(scramble);
TimeSpan timeout = TimeSpan.FromSeconds(0);
float requiredValue = 4700f;
float[] weights =
{
169.658122242946f, // R
253.796705882179f, // R2
211.084512473536f, // R'
206.193406852305f, // U
299.809258427086f, // U2
155.496912851115f, // U'
158.690899467791f, // F
281.70422762001f, // F2
346.448146439892f, // F'
274.885031555195f, // L
311.019164835258f, // L2
258.486161100002f, // L'
196.885474673572f, // D
275.657440421246f, // D2
214.624405800259f, // D'
322.649818802591f, // B
354.012863621357f, // B2
321.02200029978f // B'
};
float[] weightedPhase2PruningTable = WeightedPruningTables.CreateWeightedPhase2CornerEquatorTable(weights);
Alg solution = WeightedTwoPhaseSolver.FindSolution(cube, timeout, requiredValue, requiredValue, weights, weightedPhase2PruningTable);
float cost = solution.Select(move => weights[(int)move])
.Sum();
Assert.IsTrue(cost <= requiredValue);
Console.WriteLine("\nScramble: " + scramble + "\nSolution: " + solution + "\nCost: " + cost + " Length: " + solution.Length);
}
