InversionMutation.java

package com.aim.project.ssp.heuristics.mutation;

import AbstractClasses.ProblemDomain;
import com.aim.project.ssp.heuristics.HeuristicOperators;
import com.aim.project.ssp.interfaces.HeuristicInterface;
import com.aim.project.ssp.interfaces.SSPSolutionInterface;
import com.aim.project.ssp.interfaces.SolutionRepresentationInterface;
import java.util.Random;

/**
 * Inversion Mutation heuristic.
 * This mutation selects a random segment of the tour and reverses it.
 *
 * <p>The number of inversions is determined by the intensity of mutation (iom).</p>
 *
 * @author Sushant Nepal
 * @since 17/03/25
 */
public class InversionMutation extends HeuristicOperators implements HeuristicInterface {

    /**
     * Constructor for the InversionMutation heuristic.
     *
     * @param random Random instance for stochastic behaviour.
     */
    public InversionMutation(Random random) {
        super(random);
    }

    /**
     * Applies the inversion mutation on the given solution.
     * Reverses a number of randomly selected segments in the tour.
     *
     * @param solution The solution to be mutated.
     * @param dDepthOfSearch Unused parameter for this mutation.
     * @param dIntensityOfMutation Controls the number of inversions.
     * @return The updated objective function value after mutation.
     */
    @Override
    public double apply(SSPSolutionInterface solution, double dDepthOfSearch, double dIntensityOfMutation) {
        // Retrieve the tour and its length
        SolutionRepresentationInterface rep = solution.getSolutionRepresentation();
        int[] tour = rep.getSolutionRepresentation();
        int n = tour.length;

        // Determine how many inversion operations to perform
        int numInversions = getInversionCount(dIntensityOfMutation);

        for (int i = 0; i < numInversions; i++) {
            int startIndex, endIndex;

            // Generate a valid segment where startIndex < endIndex
            startIndex = m_oRandom.nextInt(n);
            endIndex = m_oRandom.nextInt(startIndex, n); // exclusive upper bound

            // Reverse the segment in place
            reverseSegment(tour, startIndex, endIndex);
        }

        // Update the solution's representation and calculate its new cost
        rep.setSolutionRepresentation(tour);
        double newCost = m_oObjectiveFunction.getObjectiveFunctionValue(rep);
        solution.setObjectiveFunctionValue(newCost);
        return newCost;
    }

    /**
     * Determines the number of inversions to perform based on intensity of mutation (IOM).
     *
     * @param iom the intensity of mutation value [0, 1]
     * @return the number of inversion operations
     */
    private int getInversionCount(double iom) {
        if (iom == 1) return 32;
        else if (iom >= 0.8) return 16;
        else if (iom >= 0.6) return 8;
        else if (iom >= 0.4) return 4;
        else if (iom >= 0.2) return 2;
        else return 1;
    }

    /**
     * This heuristic is not a crossover operator.
     *
     * @return false
     */
    @Override
    public boolean isCrossover() {
        return false;
    }

    /**
     * This heuristic uses intensity of mutation.
     *
     * @return true
     */
    @Override
    public boolean usesIntensityOfMutation() {
        return true;
    }

    /**
     * This heuristic does not use depth of search.
     *
     * @return false
     */
    @Override
    public boolean usesDepthOfSearch() {
        return false;
    }

    /**
     * Returns the type of heuristic: MUTATION.
     *
     * @return HeuristicType.MUTATION
     */
    @Override
    public ProblemDomain.HeuristicType getType() {
        return ProblemDomain.HeuristicType.MUTATION;
    }
}