org.cicirello.search.hc.SteepestDescentHillClimber Maven / Gradle / Ivy
Show all versions of chips-n-salsa Show documentation
/*
* Chips-n-Salsa: A library of parallel self-adaptive local search algorithms.
* Copyright (C) 2002-2022 Vincent A. Cicirello
*
* This file is part of Chips-n-Salsa (https://chips-n-salsa.cicirello.org/).
*
* Chips-n-Salsa is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Chips-n-Salsa is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see In steepest descent hill climbing, the search always iterates over all of the neighbors of the
* current candidate before deciding which to move to. It then picks the neighbor with lowest cost
* value from among all those neighbors whose cost is lower than the current cost. If no such
* neighbor exists, the search terminates with the current solution.
*
* @param The type of object under optimization.
* @author Vincent A. Cicirello, https://www.cicirello.org/
*/
public final class SteepestDescentHillClimber>
extends AbstractHillClimber {
private final IterableMutationOperator mutation;
private final OptimizationProblem pOpt;
private final IntegerCostOptimizationProblem pOptInt;
private final OneClimb climber;
/**
* Constructs a steepest descent hill climber object for real-valued optimization problem.
*
* @param problem An instance of an optimization problem to solve.
* @param mutation A mutation operator.
* @param initializer The source of random initial states for each hill climb.
* @param tracker A ProgressTracker object, which is used to keep track of the best solution found
* during the run, the time when it was found, and other related data.
* @throws NullPointerException if any of the parameters are null.
*/
public SteepestDescentHillClimber(
OptimizationProblem problem,
IterableMutationOperator mutation,
Initializer initializer,
ProgressTracker tracker) {
super(initializer, tracker);
if (problem == null || mutation == null) {
throw new NullPointerException();
}
this.mutation = mutation;
pOpt = problem;
pOptInt = null;
climber = new DoubleCostClimber();
}
/**
* Constructs a steepest descent hill climber object for integer-valued optimization problem.
*
* @param problem An instance of an optimization problem to solve.
* @param mutation A mutation operator.
* @param initializer The source of random initial states for each hill climb.
* @param tracker A ProgressTracker object, which is used to keep track of the best solution found
* during the run, the time when it was found, and other related data.
* @throws NullPointerException if any of the parameters are null.
*/
public SteepestDescentHillClimber(
IntegerCostOptimizationProblem problem,
IterableMutationOperator mutation,
Initializer initializer,
ProgressTracker tracker) {
super(initializer, tracker);
if (problem == null || mutation == null) {
throw new NullPointerException();
}
this.mutation = mutation;
pOptInt = problem;
pOpt = null;
climber = new IntCostClimber();
}
/**
* Constructs a steepest descent hill climber object for real-valued optimization problem. A
* {@link ProgressTracker} is created for you.
*
* @param problem An instance of an optimization problem to solve.
* @param mutation A mutation operator.
* @param initializer The source of random initial states for each hill climb.
* @throws NullPointerException if any of the parameters are null.
*/
public SteepestDescentHillClimber(
OptimizationProblem problem,
IterableMutationOperator mutation,
Initializer initializer) {
super(initializer, new ProgressTracker());
if (problem == null || mutation == null) {
throw new NullPointerException();
}
this.mutation = mutation;
pOpt = problem;
pOptInt = null;
climber = new DoubleCostClimber();
}
/**
* Constructs a steepest descent hill climber object for integer-valued optimization problem. A
* {@link ProgressTracker} is created for you.
*
* @param problem An instance of an optimization problem to solve.
* @param mutation A mutation operator.
* @param initializer The source of random initial states for each hill climb.
* @throws NullPointerException if any of the parameters are null.
*/
public SteepestDescentHillClimber(
IntegerCostOptimizationProblem problem,
IterableMutationOperator mutation,
Initializer initializer) {
super(initializer, new ProgressTracker());
if (problem == null || mutation == null) {
throw new NullPointerException();
}
this.mutation = mutation;
pOptInt = problem;
pOpt = null;
climber = new IntCostClimber();
}
/*
* private copy constructor in support of the split method.
* note: copies references to thread-safe components, and splits potentially non-threadsafe components
*/
private SteepestDescentHillClimber(SteepestDescentHillClimber other) {
super(other);
// these are threadsafe, so just copy references
pOpt = other.pOpt;
pOptInt = other.pOptInt;
// split: not threadsafe
mutation = other.mutation.split();
climber = pOptInt != null ? new IntCostClimber() : new DoubleCostClimber();
}
@Override
public SteepestDescentHillClimber split() {
return new SteepestDescentHillClimber(this);
}
@Override
public final Problem getProblem() {
return (pOptInt != null) ? pOptInt : pOpt;
}
@Override
final SolutionCostPair climbOnce(T current) {
return climber.climb(current);
}
private class IntCostClimber implements OneClimb {
@Override
public SolutionCostPair climb(T current) {
// compute cost of start
int currentCost = pOptInt.cost(current);
boolean keepClimbing = true;
int neighborCountIncrement = 0;
while (keepClimbing) {
MutationIterator iter = mutation.iterator(current);
int bestNeighborCost = currentCost;
while (iter.hasNext()) {
iter.nextMutant();
neighborCountIncrement++;
int cost = pOptInt.cost(current);
if (cost < bestNeighborCost) {
iter.setSavepoint();
bestNeighborCost = cost;
}
}
iter.rollback();
if (bestNeighborCost == currentCost) {
keepClimbing = false;
} else {
currentCost = bestNeighborCost;
}
}
return reportSingleClimbStatus(
currentCost, current, pOptInt.isMinCost(currentCost), neighborCountIncrement);
}
}
private class DoubleCostClimber implements OneClimb {
@Override
public SolutionCostPair climb(T current) {
// compute cost of start
double currentCost = pOpt.cost(current);
boolean keepClimbing = true;
int neighborCountIncrement = 0;
while (keepClimbing) {
MutationIterator iter = mutation.iterator(current);
double bestNeighborCost = currentCost;
while (iter.hasNext()) {
iter.nextMutant();
neighborCountIncrement++;
double cost = pOpt.cost(current);
if (cost < bestNeighborCost) {
iter.setSavepoint();
bestNeighborCost = cost;
}
}
iter.rollback();
if (bestNeighborCost == currentCost) {
keepClimbing = false;
} else {
currentCost = bestNeighborCost;
}
}
return reportSingleClimbStatus(
currentCost, current, pOpt.isMinCost(currentCost), neighborCountIncrement);
}
}
}