/// <summary>
/// Create a pruning table using corner orientation, equator
/// distribution and edge orientation. Every table entry contains the
/// exact number of moves required to solve the position represented by
/// said coordinates.
/// </summary>
/// <returns>
/// Create a pruning table using corner orientation, equator
/// distribution and edge orientation.
/// </returns>
public static byte[] CreatePhase1Table()
{
byte invalid = 0xFF;
byte[] pruningTable = Enumerable
.Repeat(invalid, PruningTableConstants.PruningTableSizePhase1)
.ToArray();
TableController.InitializeCornerOrientationMoveTable();
TableController.InitializeEdgeOrientationMoveTable();
TableController.InitializeEquatorDistributionMoveTable();
pruningTable[0] = 0; //solved
int done = 1;
int depth = 0;
string outputFormat = "depth: {0}, done: {1}/" + PruningTableConstants.PruningTableSizePhase1 + " ({2:P})";
Console.WriteLine(string.Format(outputFormat, depth, done, done / (double)PruningTableConstants.PruningTableSizePhase1));
while (done < PruningTableConstants.PruningTableSizePhase1)
{
for (int reducedEoEquator = 0; reducedEoEquator < SymmetryReduction.NumEoEquatorSymmetryClasses; reducedEoEquator++)
{
for (int cornerOrientation = 0; cornerOrientation < NumCornerOrientations; cornerOrientation++)
{
int index = NumCornerOrientations * reducedEoEquator + cornerOrientation;
if (pruningTable[index] == depth)
{
int expandedEoEquator = SymmetryReduction.ExpandEoEquatorCoordinate[reducedEoEquator];
int edgeOrientation = expandedEoEquator % NumEdgeOrientations;
int equatorDistribution = expandedEoEquator / NumEdgeOrientations;
for (int move = 0; move < NumMoves; move++)
{
//apply move
int newCornerOrientation = TableController.CornerOrientationMoveTable[cornerOrientation, move];
int newEdgeOrientation = TableController.EdgeOrientationMoveTable[edgeOrientation, move];
int newEquatorDistribution = TableController.EquatorDistributionMoveTable[equatorDistribution, move];
//same as calling GetPhase1PruningIndex,
//but the reduced edge orientation and equator
//distribution coordinate is required.
int newExpandedEoEquator = newEquatorDistribution * NumEdgeOrientations + newEdgeOrientation;
int newReducedEoEquator = SymmetryReduction.ReduceEoEquatorCoordinate[newExpandedEoEquator];
int reductionSymmetry = SymmetryReduction.EoEquatorReductionSymmetry[newExpandedEoEquator];
newCornerOrientation = SymmetryReduction.ConjugateCornerOrientationCoordinate[newCornerOrientation, reductionSymmetry];
int newIndex = newReducedEoEquator * NumCornerOrientations + newCornerOrientation;
//store depth
if (pruningTable[newIndex] == invalid)
{
pruningTable[newIndex] = (byte)(depth + 1);
done++;
int flags = SymmetryReduction.EoEquatorSymmetries[newReducedEoEquator];
for (int symmetry = 1; symmetry < Symmetries.NumSymmetriesDh4; symmetry++)
{
flags >>= 1;
if ((flags & 0b1) == 1)
{
int rotatedCornerOrientation = SymmetryReduction.ConjugateCornerOrientationCoordinate[newCornerOrientation, symmetry];
int rotatedIndex = NumCornerOrientations * newReducedEoEquator + rotatedCornerOrientation;
if (pruningTable[rotatedIndex] == invalid)
{
pruningTable[rotatedIndex] = (byte)(depth + 1);
done++;
}
}
}
}
}
}
}
}
depth++;
Console.WriteLine(string.Format(outputFormat, depth, done, done / (double)PruningTableConstants.PruningTableSizePhase1));
}
return(pruningTable);
}
//TEST with impossible length
/// <summary>
/// Find a near-optimal solution for a cube in respect to the number of
/// moves. If no matching solution is found, the return value is null.
/// </summary>
/// <param name="cubeToSolve">The cube to solve.</param>
/// <param name="timeout">
/// Interrupt the search after that much time has passed.
/// </param>
/// <param name="returnLength">
/// The search stops as soon as a solution of the specified length is
/// found. Be careful with setting <paramref name="returnLength"/> to a
/// value smaller than 20, beacuse there might not be a solution
/// shorter than or matching that length. In which case the algorithm
/// will run for a long time.
/// </param>
/// <param name="requiredLength">
/// Ignore the timeout until a solution of a length less than or equal to
/// <paramref name="requiredLength"/> is found. If the value of
/// <paramref name="requiredLength"/> is negative, this parameter is
/// ignored. If <paramref name="requiredLength"/> is positive, it must
/// be larger than or equal to <paramref name="returnLength"/>. Setting
/// the value to 30 or higher will cause the first solution found after
/// timeout to be returned.
/// </param>
/// <param name="searchDifferentOrientations">
/// Start three threads each solving a 120° offset of the cube.
/// </param>
/// <param name="searchInverse">
/// For every orientation solved, start another thread that solves its
/// inverse.
/// </param>
/// <returns>
/// A near-optimal solution for the specified cube in respect to ist
/// length. Null, if not matching solution is found.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="cubeToSolve"/> is null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if <paramref name="returnLength"/> is negative or if
/// <paramref name="requiredLength"/> is positive but smaller than
/// <paramref name="returnLength"/>.
/// </exception>
public static Alg FindSolution(CubieCube cubeToSolve, TimeSpan timeout, int returnLength, int requiredLength, bool searchDifferentOrientations = true, bool searchInverse = true)
{
#region parameter checks
if (cubeToSolve is null)
{
throw new ArgumentNullException(nameof(cubeToSolve) + " is null.");
}
if (timeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(timeout) + " cannot be negative: " + timeout);
}
if (returnLength < 0)
{
throw new ArgumentOutOfRangeException(nameof(returnLength) + " cannot be negative: " + returnLength);
}
if ((uint)requiredLength < returnLength)
{
throw new ArgumentOutOfRangeException(nameof(requiredLength) + " must either be negative or >= " + nameof(returnLength) + ": " + requiredLength + " (" + nameof(requiredLength) + ") < " + returnLength + " (" + nameof(returnLength) + ")");
}
#endregion paramter checks
//initialize move tables
TableController.InitializeCornerOrientationMoveTable();
TableController.InitializeCornerPermutationMoveTable();
TableController.InitializeDEdgePermutationMoveTable();
TableController.InitializeEdgeOrientationMoveTable();
TableController.InitializeEquatorPermutationMoveTable();
TableController.InitializeUdEdgeOrderMoveTable();
TableController.InitializeUEdgePermutationMoveTable();
//initialize pruning tables
TableController.InitializePhase1PruningTable();
TableController.InitializePhase2CornerEquatorPruningTable();
TableController.InitializePhase2CornerUdPruningTable();
Stopwatch timePassed = new Stopwatch();
timePassed.Start();
SyncedBoolWrapper isTerminated = new SyncedBoolWrapper()
{
Value = false
};
SyncedIntWrapper shortestSolutionLength = new SyncedIntWrapper()
{
Value = 30
};
SyncedIntWrapper shortestSolutionIndex = new SyncedIntWrapper()
{
Value = -1
};
List <Alg> solutions = new List <Alg>();
int numThreads = (searchDifferentOrientations ? 3 : 1) * (searchInverse ? 2 : 1);
int increment = searchDifferentOrientations ? 1 : 2;
Thread[] solvers = new Thread[numThreads];
for (int orientation = 0; orientation < numThreads; orientation += increment)
{
TwoPhaseSolver solver = new TwoPhaseSolver()
{
_notRotatedCube = cubeToSolve.Clone(), //create a copy to avoid issues caused by multithreading
_timePassed = timePassed,
_timeout = timeout,
_returnLength = returnLength,
_requiredLength = requiredLength,
IsTerminated = isTerminated,
_solutions = solutions,
_shortestSolutionLength = shortestSolutionLength,
_shortestSolutionIndex = shortestSolutionIndex,
_rotation = orientation % 3,
_inversed = orientation / 3 == 1
};
Thread solverThread = new Thread(new ThreadStart(solver.StartSearch));
solvers[orientation] = solverThread;
solverThread.Start();
}
foreach (Thread solverThread in solvers)
{
solverThread.Join();
}
timePassed.Stop(); //not required, only for the sake of completeness
if (solutions.Count > 0)
{
return(solutions[shortestSolutionIndex.Value]);
}
else
{
return(null);
}
}
/// <summary>
/// Find a near-optimal solution for a cube in respect to the cost of
/// the moves. If no matching solution is found, the return value is
/// null.
/// </summary>
/// <param name="cubeToSolve">The cube to solve.</param>
/// <param name="timeout">
/// Interrupt the search after that much time has passed.
/// </param>
/// <param name="returnCost">
/// The search stops as soon as a solution of the specified cost is
/// found. Be careful with setting <paramref name="returnCost"/> to a
/// value too small, because there might not be a solution cheaper than
/// or matching that cost. In which case the algorithm will run for a
/// long time.
/// </param>
/// <param name="requiredCost">
/// Ignore the timeout until a solution of a cost less than or equal to
/// <paramref name="requiredCost"/> is found. If the value of
/// <paramref name="requiredCost"/> is negative, this parameter is
/// ignored. If <paramref name="requiredCost"/> is positive, it must be
/// larger than or equal to <paramref name="returnCost"/>. Setting the
/// value to a large value will cause the first solution found after
/// timeout to be returned.
/// </param>
/// <param name="weights">The weights to use.</param>
/// <param name="weightedCornerEquatorPruningTable">
/// The weighted corner permutation and equator order pruning table
/// created by
/// <see cref="WeightedPruningTables.CreateWeightedPhase2CornerEquatorTable(float[])"/>.
/// The weights used to create this table must be equatl to
/// <paramref name="weights"/>.
/// </param>
/// <param name="deltaMin">
/// The minimum difference a newly found solution has to exceed the
/// cheapest solution found. Only used to experiment. Set to 0 for
/// optimal solutions.
/// </param>
/// <param name="searchDifferentOrientations">
/// Start three threads each solving a 120° offset of the cube.
/// </param>
/// <param name="searchInverse">
/// For every orientation solved, start another thread that solves its
/// inverse.
/// </param>
/// <returns>
/// A near-optimal solution for the specified cube in respect to its
/// cost. Null, if no matching solution is found.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="cubeToSolve"/> or
/// <paramref name="weightedCornerEquatorPruningTable"/> is null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if <paramref name="timeout"/>,
/// <paramref name="returnCost"/> or <paramref name="deltaMin"/> is
/// negative. Also thrown if <paramref name="requiredCost"/> is
/// positive and less than <paramref name="returnCost"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// Thrown if <paramref name="weightedCornerEquatorPruningTable"/>.Length
/// is not of the expected size.
/// </exception>
/// <exception cref="InvalidWeightsException">
/// Thrown if <paramref name="weights"/> is invalid.
/// </exception>
public static Alg FindSolution(CubieCube cubeToSolve, TimeSpan timeout, float returnCost, float requiredCost, float[] weights, float[] weightedCornerEquatorPruningTable, float deltaMin = 0f, bool searchDifferentOrientations = true, bool searchInverse = true)
{
#region parameter checks
if (cubeToSolve is null)
{
throw new ArgumentNullException(nameof(cubeToSolve) + " is null.");
}
if (timeout < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(timeout) + " cannot be negative: " + timeout);
}
if (returnCost < 0d)
{
throw new ArgumentOutOfRangeException(nameof(returnCost) + " cannot be negative: " + returnCost);
}
if (requiredCost > 0d && requiredCost < returnCost)
{
throw new ArgumentOutOfRangeException(nameof(requiredCost) + " must either be negative or >= " + nameof(returnCost) + ": " + requiredCost + " (" + nameof(requiredCost) + ") < " + returnCost + " (" + nameof(returnCost) + ")");
}
MoveWeightsUtils.ValidateWeights(weights);
if (weightedCornerEquatorPruningTable is null)
{
throw new ArgumentNullException(nameof(weightedCornerEquatorPruningTable) + " is null.");
}
if (weightedCornerEquatorPruningTable.Length != PruningTableConstants.CornerEquatorPruningTableSizePhase2)
{
throw new ArgumentException(nameof(weightedCornerEquatorPruningTable) + " must be of size " + PruningTableConstants.CornerEquatorPruningTableSizePhase2);
}
if (deltaMin < 0d)
{
throw new ArgumentOutOfRangeException(nameof(deltaMin) + " cannot be negative: " + deltaMin);
}
#endregion paramter checks
//initialize move tables
TableController.InitializeCornerOrientationMoveTable();
TableController.InitializeCornerPermutationMoveTable();
TableController.InitializeDEdgePermutationMoveTable();
TableController.InitializeEdgeOrientationMoveTable();
TableController.InitializeEquatorPermutationMoveTable();
TableController.InitializeUdEdgeOrderMoveTable();
TableController.InitializeUEdgePermutationMoveTable();
//initialize pruning tables
TableController.InitializePhase1PruningTable();
TableController.InitializePhase2CornerEquatorPruningTable();
TableController.InitializePhase2CornerUdPruningTable();
Stopwatch timePassed = new Stopwatch();
timePassed.Start();
SyncedBoolWrapper isTerminated = new SyncedBoolWrapper()
{
Value = false
};
SyncedFloatWrapper bestSolutionCost = new SyncedFloatWrapper()
{
Value = float.MaxValue
};
SyncedIntWrapper bestSolutionIndex = new SyncedIntWrapper()
{
Value = -1
};
List <Alg> solutions = new List <Alg>();
int numThreads = (searchDifferentOrientations ? 3 : 1) * (searchInverse ? 2 : 1);
int increment = searchDifferentOrientations ? 1 : 2;
Thread[] solvers = new Thread[numThreads];
for (int orientation = 0; orientation < numThreads; orientation += increment)
{
WeightedTwoPhaseSolver solver = new WeightedTwoPhaseSolver()
{
_notRotatedCube = cubeToSolve.Clone(), //create a copy to avoid issues caused by multithreading
_timePassed = timePassed,
_timeout = timeout,
_returnCost = returnCost,
_requiredCost = requiredCost,
IsTerminated = isTerminated,
_solutions = solutions,
_bestSolutionCost = bestSolutionCost,
_bestSolutionIndex = bestSolutionIndex,
_rotation = orientation % 3,
_inversed = orientation / 3 == 1,
_nonRotatedWeights = (float[])weights.Clone(), //create a copy to avoid issues caused by multithreading
_weightedCornerEquatorPruningTable = weightedCornerEquatorPruningTable,
_deltaMin = deltaMin
};
Thread solverThread = new Thread(new ThreadStart(solver.StartSearch));
solvers[orientation] = solverThread;
solverThread.Start();
}
foreach (Thread solverThread in solvers)
{
solverThread.Join();
}
timePassed.Stop(); //not required, only for the sake of completeness
if (solutions.Count > 0)
{
return(solutions[bestSolutionIndex.Value]);
}
else
{
return(null);
}
}