• Home
• org.cicirello
• chips-n-salsa
• 6.2.1
• source code
• AbstractHillClimber.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.cicirello.search.hc.AbstractHillClimber Maven / Gradle / Ivy

/*
 * 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 .
 */

package org.cicirello.search.hc;

import org.cicirello.search.Metaheuristic;
import org.cicirello.search.ProgressTracker;
import org.cicirello.search.SimpleLocalMetaheuristic;
import org.cicirello.search.SolutionCostPair;
import org.cicirello.search.operators.Initializer;
import org.cicirello.util.Copyable;

/**
 * This class serves as an abstract base class for the Hill Climbing implementations, including the
 * common functionality.
 *
 * @param  The type of object under optimization.
 * @author Vincent A. Cicirello, https://www.cicirello.org/
 */
abstract class AbstractHillClimber>
    implements Metaheuristic, SimpleLocalMetaheuristic {

  private final Initializer initializer;
  private ProgressTracker tracker;
  private long neighborCount;

  /**
   * Constructs a hill climber object.
   *
   * @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.
   */
  AbstractHillClimber(Initializer initializer, ProgressTracker tracker) {
    if (initializer == null || tracker == null) {
      throw new NullPointerException();
    }
    this.initializer = initializer;
    this.tracker = tracker;
  }

  /*
   * package-private copy constructor in support of the split method.
   * note: copies references to thread-safe components, and splits potentially non-threadsafe components
   */
  AbstractHillClimber(AbstractHillClimber other) {

    // this one must be shared.
    tracker = other.tracker;

    // split: not threadsafe
    initializer = other.initializer.split();

    // use default of 0 for this one: neighborCount
  }

  @Override
  public final SolutionCostPair optimize() {
    if (tracker.didFindBest() || tracker.isStopped()) return null;
    neighborCount++;
    return climbOnce(initializer.createCandidateSolution());
  }

  @Override
  public final SolutionCostPair optimize(T start) {
    if (tracker.didFindBest() || tracker.isStopped()) return null;
    return climbOnce(start.copy());
  }

  /**
   * Executes multiple restarts of the hill climber. Each restart begins from a new random starting
   * solution. Returns the best solution across the restarts.
   *
   * @param numRestarts The number of restarts of the hill climber.
   * @return The best solution of this set of restarts, which may or may not be the same as the
   *     solution contained in this hill climber's {@link org.cicirello.search.ProgressTracker
   *     ProgressTracker}, which contains the best of all runs across all calls to the various
   *     optimize methods. Returns null if no runs executed, such as if the ProgressTracker already
   *     contains the theoretical best solution.
   */
  @Override
  public final SolutionCostPair optimize(int numRestarts) {
    if (tracker.didFindBest() || tracker.isStopped()) return null;
    SolutionCostPair best = null;
    for (int i = 0; i < numRestarts && !tracker.didFindBest() && !tracker.isStopped(); i++) {
      SolutionCostPair current = climbOnce(initializer.createCandidateSolution());
      neighborCount++;
      if (best == null || current.compareTo(best) < 0) best = current;
    }
    return best;
  }

  @Override
  public final ProgressTracker getProgressTracker() {
    return tracker;
  }

  @Override
  public final void setProgressTracker(ProgressTracker tracker) {
    if (tracker != null) this.tracker = tracker;
  }

  /**
   * Gets the total run length, where run length is number of candidate solutions generated by the
   * hill climber. This is the total run length across all calls to the search.
   *
   * @return the total number of candidate solutions generated by the search, across all calls to
   *     the various optimize methods.
   */
  @Override
  public final long getTotalRunLength() {
    return neighborCount;
  }

  @Override
  public abstract AbstractHillClimber split();

  final SolutionCostPair reportSingleClimbStatus(
      int currentCost, T current, boolean isMinCost, long neighborCountIncrement) {
    neighborCount = neighborCount + neighborCountIncrement;
    // update tracker
    if (currentCost < tracker.getCost()) {
      tracker.update(currentCost, current, isMinCost);
    }
    return new SolutionCostPair(current, currentCost, isMinCost);
  }

  final SolutionCostPair reportSingleClimbStatus(
      double currentCost, T current, boolean isMinCost, long neighborCountIncrement) {
    neighborCount = neighborCount + neighborCountIncrement;
    // update tracker
    if (currentCost < tracker.getCostDouble()) {
      tracker.update(currentCost, current, isMinCost);
    }
    return new SolutionCostPair(current, currentCost, isMinCost);
  }

  interface OneClimb> {
    SolutionCostPair climb(T current);
  }

  abstract SolutionCostPair climbOnce(T current);
}