Metaheuristiques/src/main/java/jobshop/solvers/DescentSolver.java

package jobshop.solvers;

import jobshop.Instance;
import jobshop.Result;
import jobshop.encodings.ResourceOrder;
import jobshop.encodings.Schedule;
import jobshop.solvers.neighborhood.Neighbor;
import jobshop.solvers.neighborhood.Neighborhood;
import jobshop.solvers.neighborhood.Nowicki;

import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

/** An empty shell to implement a descent solver. */
public class DescentSolver implements Solver {

    final Neighborhood<ResourceOrder> neighborhood;
    final Solver baseSolver;

    /** Creates a new descent solver with a given neighborhood and a solver for the initial solution.
     *
     * @param neighborhood Neighborhood object that should be used to generates neighbor solutions to the current candidate.
     * @param baseSolver A solver to provide the initial solution.
     */
    public DescentSolver(Neighborhood<ResourceOrder> neighborhood, Solver baseSolver) {
        this.neighborhood = neighborhood;
        this.baseSolver = baseSolver;
    }

    @Override
    public Result solve(Instance instance, long deadline) {
        Schedule schedule = baseSolver.solve(instance, deadline).schedule.get();
        ResourceOrder resourceOrder = new ResourceOrder(schedule);
        boolean ended = false;
        int bestMakespan;
        Neighbor<ResourceOrder> bestNeighbor;

        while (!ended) {
            schedule = resourceOrder.toSchedule().get();
            bestMakespan = schedule.makespan();
            bestNeighbor = null;
            List<Neighbor<ResourceOrder>> generatedNeighbors = neighborhood.generateNeighbors(resourceOrder);
            Iterator<Neighbor<ResourceOrder>> iter = generatedNeighbors.iterator();
            while (iter.hasNext()) {
                Neighbor<ResourceOrder> neighbor = iter.next();
                neighbor.applyOn(resourceOrder);
                try {
                    Schedule currentSchedule = resourceOrder.toSchedule().get();
                    int currentMakespan = currentSchedule.makespan();
                    if (currentMakespan < bestMakespan) {
                        bestMakespan = currentMakespan;
                        bestNeighbor = neighbor;
                    }
                } catch (Exception e) {
                }
                neighbor.undoApplyOn(resourceOrder);
            }
            if (bestNeighbor == null) {
                ended = true;
            } else {
                bestNeighbor.applyOn(resourceOrder);
            }
        }
        return new Result(instance, resourceOrder.toSchedule(), Result.ExitCause.ProvedOptimal);
    }

}