/// <summary> /// Creates a new ClimberAlgorithm using the given comparison strategy to compare /// evaluations and the given successorPicker to select the next EvaluableState to /// evaluate against in a greedy or non-greedy configuration /// </summary> /// <param name="greedy">Determines the greedyness of the algorithm</param> /// <param name="comparisonStrategy">The Comparer that which Optimize will use to compare optimizations</param> /// <param name="successorPicker">The successor picker to choose the next EvaluableState in to evaluate at an optimization step</param> protected ClimberAlgorithm(bool greedy, IComparer <TEvaluation> comparisonStrategy, ISuccessorPicker <TState, TEvaluation> successorPicker) { this.successorPicker = successorPicker; this.comparisonStrategy = comparisonStrategy; this.greedy = greedy; }
public void TestRandomRestartHillClimberSameRestartPointEachTime() { comparer = new MaximizingComparer <int>(); generator = new TestLinearIntegerSuccessorGenerator(); picker = new ClimberSuccessorPicker <TestIntegerEvaluableState, int>(generator, comparer); algorithm = new LocalClimberAlgorithm <TestIntegerEvaluableState, int>(comparer, picker); randomizer = new TestIntegerEvaluableStateNonRandomizer(); climber = new RandomRestartHillClimber <TestIntegerEvaluableState, int>(randomizer, algorithm, 5); RunTest(climber, 2, 100); }
public void TestRandomRestartHillClimberIncrementingRestartPoint() { comparer = new MaximizingComparer <int>(); generator = new TestExponentialIntegerSuccessorGenerator(); picker = new ClimberSuccessorPicker <TestIntegerEvaluableState, int>(generator, comparer); algorithm = new LocalClimberAlgorithm <TestIntegerEvaluableState, int>(comparer, picker); randomizer = new TestIntegerRandomizerSimulator(); climber = new RandomRestartHillClimber <TestIntegerEvaluableState, int>(randomizer, algorithm, 5); RunTest(climber, 1, 64); }
/// <summary> /// Creates a new LocalClimberAlgorithm using the given comparison strategy to compare /// evaluations and the given successorPicker to select the next EvaluableState to /// evaluate against in a greedy or non-greedy configuration /// </summary> /// <param name="greedy">Determines the greedyness of the algorithm</param> /// <param name="comparisonStrategy">The Comparer that which Optimize will use to compare optimizations</param> /// <param name="successorPicker">The successor picker to choose the next EvaluableState in to evaluate at an optimization step</param> public LocalClimberAlgorithm(bool greedy, IComparer <TEvaluation> comparisonStrategy, ISuccessorPicker <TState, TEvaluation> successorPicker) : base(greedy, comparisonStrategy, successorPicker) { }
/// <summary> /// Creates a new LocalClimberAlgorithm using the given comparison strategy to compare /// evaluations and the given successorPicker to select the next EvaluableState to /// evaluate against non-greedily /// </summary> /// <param name="comparisonStrategy">The Comparer that which Optimize will use to determine optimality</param> /// <param name="successorPicker">The successor picker to choose the next EvaluableState in to evaluate at an optimization step</param> public LocalClimberAlgorithm(IComparer <TEvaluation> comparisonStrategy, ISuccessorPicker <TState, TEvaluation> successorPicker) : this(false, comparisonStrategy, successorPicker) { }
protected Optimizer(ISuccessorPicker <TState, TEvaluation> successorPicker) { this.successorPicker = successorPicker; }
/// <summary> /// Create a new StateRandomizer with the given compaer, using the given SuccessorPicker that will perform /// the given number of randomizations before returning a result. A numRanfomizations of -1 will have the optimier /// return the first encountered optimal state /// </summary> /// <param name="evaluationComparer"></param> /// <param name="successorPicker"></param> /// <param name="numRandomizations"></param> public StateRandomizer(IComparer <TEvaluation> evaluationComparer, ISuccessorPicker <TState, TEvaluation> successorPicker, int numRandomizations) : base(successorPicker) { EvaluationComparer = evaluationComparer; NumRandomizations = numRandomizations; }
/// <summary> /// Create a new StateRandomizer with the given compaer, using the given SuccessorPicker that will perform /// a single randomization and return the most optimal result /// </summary> /// <param name="evaluationComparer"></param> /// <param name="successorPicker"></param> public StateRandomizer(IComparer <TEvaluation> evaluationComparer, ISuccessorPicker <TState, TEvaluation> successorPicker) : this(evaluationComparer, successorPicker, 1) { }
/// <summary> /// Creates a RandomRestartHillClimber that will restart the Optimization from the given ClimberAlgorithm /// up to numRestarts in parallel with the given ParallelOptions /// </summary> /// <param name="stateRandomizer">A successor picker that will generate a random successor state from the initial state</param> /// <param name="algorithm">The climber algorithm to use for optimzation</param> /// <param name="numRestarts">The number of random restart operations to complete</param> /// <param name="parallelOptions">The options for the Parallel restart operations</param> public RandomRestartHillClimber(ISuccessorPicker <TState, TEvaluation> stateRandomizer, ClimberAlgorithm <TState, TEvaluation> algorithm, uint numRestarts, ParallelOptions parallelOptions) : base(algorithm) { this.numRestarts = numRestarts; this.parallelOptions = parallelOptions; this.stateRandomizer = stateRandomizer; }
/// <summary> /// Creates a RandomRestartHillClimber that will restart the Optimization from the given ClimberAlgorithm /// up to numRestarts. The operation will run in parallel with as many available processors up to maxDegreeOfParallelism. /// </summary> /// <param name="stateRandomizer">A successor picker that will generate a random successor state from the initial state</param> /// <param name="algorithm">The climber algorithm to use for optimzation</param> /// <param name="numRestarts">The number of random restart operations to complete</param> /// <param name="maxDegreeOfParallelism">The maximum number of processors that will attempt to perform an optimization operation</param> public RandomRestartHillClimber(ISuccessorPicker <TState, TEvaluation> stateRandomizer, ClimberAlgorithm <TState, TEvaluation> algorithm, uint numRestarts, int maxDegreeOfParallelism) : this(stateRandomizer, algorithm, numRestarts, new ParallelOptions() { MaxDegreeOfParallelism = maxDegreeOfParallelism }) { }
/// <summary> /// Creates a RandomRestartHillClimber that will restart the Optimization from the given ClimberAlgorithm /// up to numRestarts. If parallel is true, the operation will be completed with all available processors /// </summary> /// <param name="stateRandomizer">A successor picker that will generate a random successor state from the initial state</param> /// <param name="algorithm">The climber algorithm to use for optimzation</param> /// <param name="numRestarts">The number of random restart operations to complete</param> /// <param name="parallel">Flag to determine if the process should run in parallel</param> public RandomRestartHillClimber(ISuccessorPicker <TState, TEvaluation> stateRandomizer, ClimberAlgorithm <TState, TEvaluation> algorithm, uint numRestarts, bool parallel) : this(stateRandomizer, algorithm, numRestarts, parallel ? -1 : 1) { }
/// <summary> /// Creates a RandomRestartHillClimber that will restart the Optimization from the given ClimberAlgorithm /// up to numRestarts in serial (one thread) /// </summary> /// <param name="stateRandomizer">A successor picker that will generate a random successor state from the initial state</param> /// <param name="algorithm">The climber algorithm to use for optimzation</param> /// <param name="numRestarts">The number of random restart operations to complete</param> public RandomRestartHillClimber(ISuccessorPicker <TState, TEvaluation> stateRandomizer, ClimberAlgorithm <TState, TEvaluation> algorithm, uint numRestarts) : this(stateRandomizer, algorithm, numRestarts, false) { }