/// <summary>
/// Runs the search algorithm.
/// Call method Search, which search for solutions.
/// </summary>
/// <param name="bestChoiceSearcher">The best choice searcher.</param>
/// <param name="propagationResult">The propagation result.</param>
/// <returns>The solutions.</returns>
public List <Solution> runSearchAlgorithm(IBestChoiceSearcher bestChoiceSearcher, PropagationResult propagationResult)
{
List <Solution> solutions = new List <Solution>();
search(bestChoiceSearcher, propagationResult, solutions);
return(solutions);
}
// old search method
/*
* private void search2(IBestChoiceSearcher bestChoiceSearcher, PropagationResult result, List<Solution> solutions)
* {
* Set[,] s = result.matrix;
*
* // Find the top list of possible choices of Set with maximum minFactor range.
* List<FactorRangeRecord> bestRecords = searchForTheBestRecords(s);
* // If the it is only one possible Set, after shorten will be matrix singleton
* bool isSingleton = bestRecords.Count == 1;
*
* // Find the set to be shortened.
* FactorRangeRecord best = bestChoiceSearcher.chooseBestRecord(bestRecords);
* Set currentSet = s[best.Row, best.Col];
*
* // Create the order in which we will try to find a solution, best possibility first.
* List<int> sortedMinutes = new List<int>(currentSet.MinimizationFactor.Keys);
* sortedMinutes.Sort(delegate(int i, int j)
* {
* return currentSet.MinimizationFactor[i] - currentSet.MinimizationFactor[j];
* });
*
* // Search for the solution.
* foreach (int minute in sortedMinutes)
* {
* // TODO: Use the branch and bound prunning.
*
* // Copy the matrix.
* Set[,] newMatrix = GenerationAlgorithmPESPUtil.cloneDiscreteSetMatrix(s);
*
* // Create a singleton set.
* Set newSet = new Set(currentSet.Modulo);
* newSet.Add(minute, currentSet.MinimizationFactor[minute]);
*
* // Remeber to the new matrix.
* newMatrix[best.Row, best.Col] = newSet;
* newMatrix[best.Col, best.Row] = new Set(newSet);
* newMatrix[best.Col, best.Row].Reverse();
*
* // Propagate newly created constraints.
* PropagationUtils.propagate(newMatrix, result.TrainLinesMap);
*
* // Check if the solution may be found.
* if (!MatrixUtils.isValid(s))
* {
* continue;
* }
*
* // If the solution is found, remember it, otherwise search for it.
* if (isSingleton)
* {
* solutions.Add(new Solution(newMatrix));
* }
* else
* {
* search(new PropagationResult(newMatrix, result.TrainLinesMap), solutions);
* }
* }
* }
*/
/// <summary>
/// Searches for solution.
/// It is called recursively, backtracking all possiblities with respect to specific choice searcher.
/// </summary>
/// <param name="bestChoiceSearcher">The best choice searcher.</param>
/// <param name="propagationResult">The propagation result.</param>
/// <param name="solutions">The solutions.</param>
/// <returns>True if solution found, terminate recursive calls. Otherwise continue in backtracking.</returns>
private Boolean search(IBestChoiceSearcher bestChoiceSearcher, PropagationResult propagationResult, List <Solution> solutions)
{
//reportProgress();
// retreive discrete set matrix after propagation from propagation result
Set[,] discreteSetMatrix = propagationResult.DiscreteSetMatrix;
// while until you can still find some solution (still can found best record)
while (true)
{
// Propagate newly created constraints.
PropagationUtil.propagate(discreteSetMatrix, propagationResult.TrainLinesMap);
// Check if the solution may be found.
if (!MatrixUtils.isValid(discreteSetMatrix))
{
// No valid matrix - solution can not be found.
return(false);
}
// Find the set to be shortened.
FactorRangeRecord bestRecord;
// if no best record found ()
if (!bestChoiceSearcher.chooseBestRecord(discreteSetMatrix, out bestRecord))
{
// then solution found, matrix is single (contains singletons only).
solutions.Add(new Solution(discreteSetMatrix));
// End of recursive calls
return(true);
}
reportProgress();
// fix one potential set with item founded as best
Set[,] newMatrix = fixOnePotentialOfSetInMatrix(discreteSetMatrix, bestRecord);
// matrix was changed, continue in recursive calls
Boolean solutionFound = search(bestChoiceSearcher, new PropagationResult(newMatrix, propagationResult.TrainLinesMap), solutions);
// Test if solution was found
if (solutionFound)
{
return(true);
}
// after return from recursive call, remove fixed object and try to
discreteSetMatrix[bestRecord.Row, bestRecord.Col].Remove(bestRecord.MinItemOfSet);
discreteSetMatrix[bestRecord.Col, bestRecord.Row].RemoveReverse(bestRecord.MinItemOfSet);
}
}
/// <summary>
/// Runs the specialized generation algorithm.
/// Propagetes constraints, searches for solutions and constructs timetables.
/// </summary>
/// <param name="constraints">The constraints.</param>
/// <param name="constraintPropagator">The constraint propagator.</param>
/// <param name="bestChoiceSearcher">The best choice searcher.</param>
/// <returns>The timetables.</returns>
public void runSpecializedGenerationAlgorithm(List <Constraint> constraints, IConstraintPropagator constraintPropagator,
IBestChoiceSearcher bestChoiceSearcher, List <Timetable> timetables)
{
// start time
Stopwatch watch = new Stopwatch();
watch.Start();
// Propagate constraints with specific constraintPropagator
PropagationResult propagationResult = constraintPropagator.runPropagationAlgorithm(constraints, GenerationAlgorithmDSAUtil.MODULO_DEFAULT);
// Search for the solution with specific bestChoiceSearcher
List <Solution> solutions = runSearchAlgorithm(bestChoiceSearcher, propagationResult);
// finish time
watch.Stop();
TimeSpan runningTime = watch.Elapsed;
// crete note for generated solutions
String note = constraintPropagator.getDescription() + ", " + bestChoiceSearcher.getDescription();
// Construct timetables from solutions generated above.
runConstructionTimetableAlgorithm(solutions, propagationResult.TrainLinesMap, timetables, stepCount, note, runningTime);
}
/// <summary>
/// Generates the timetables.
/// </summary>
public void generateTimetables(int numberOftimetables)
{
// initialize the algorithm
List <Constraint> constraints;
runInitializeAlgorithm(out constraints);
// propagator with set creator will be choosen in this sequence
IConstraintPropagator[] propagators = new IConstraintPropagator[]
{
new BisectionPropagator(new SameTransferTime()),
new BisectionPropagator(new AlfaTTransferTime()),
new SimplePropagator(new FullDiscreteSet()),
new SimplePropagator(new FullDiscreteSet()),
};
// best searcher will be choosen in this sequence
IBestChoiceSearcher[] creators = new IBestChoiceSearcher[]
{
new DeterministicSearcher(),
new DeterministicSearcher(),
new DeterministicSearcher(),
new ProbableSearcher()
};
// new timetables
this.timetables.Clear();
List <Timetable> newTimetables = this.timetables;
// shift for percentage complete
double shift = 1 / (double)creators.Length;
//
percentageComplete = 0;
Exception lastException = null;
// each predefined combination do
for (int i = 0, c = creators.Length; i < c; ++i)
{
try
{
// step count
stepCount = 0;
// generation for this combination
runSpecializedGenerationAlgorithm(
constraints,
propagators[i],
creators[i],
newTimetables
);
// percentage is completed so far
percentageComplete += shift;
// if cancellation
if (IsCancelled)
{
break;
}
} catch (Exception exception) {
lastException = exception;
}
}
if (lastException != null)
{
throw lastException;
}
}
