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;
    int pts = 10;
    int iterMax = 100;

    /** 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 ArrayList<Result> solve(Instance instance, long deadline) {
        Schedule schedule = baseSolver.solve(instance, deadline).get(0).schedule.get();
        ResourceOrder resourceOrder = new ResourceOrder(schedule);
        boolean ended = false;

        Result result;
        ArrayList<Result> list = new ArrayList<>();
        int bestMakespan;
        Neighbor<ResourceOrder> bestNeighbor;
        int voisinsVisites = 0;
        int k = 0;
        while (!ended && deadline - System.currentTimeMillis() > 0 && k <= iterMax) {
            k++;
            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()) {
                voisinsVisites++;
                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);
            }

            if (k % (iterMax/pts) == 0) {
                result = new Result(instance, resourceOrder.toSchedule(), Result.ExitCause.Timeout);
                result.setVoisinsVisites(voisinsVisites);
                list.add(result);
            }
        }

        if (ended) {
            result = new Result(instance, resourceOrder.toSchedule(), Result.ExitCause.Blocked);
        } else {
            result = new Result(instance, resourceOrder.toSchedule(), Result.ExitCause.Timeout);
        }
        result.setVoisinsVisites(voisinsVisites);
        int i;
        for (i=list.size(); i<pts; i++) {
            list.add(result);
        }
        return list;
    }

    @Override
    public void setIterMax(int iterMax) {this.iterMax = iterMax;}

    @Override
    public void setpts(int pts) {this.pts = pts;}
}