Class ExponentialEarlyTardyHeuristic

  • All Implemented Interfaces:
    ConstructiveHeuristic<Permutation>

    public final class ExponentialEarlyTardyHeuristic
    extends Object

    This class implements a constructive heuristic, known as EXPET, for scheduling problems involving minimizing the sum of weighted earliness plus weighted tardiness. EXPET is an acronym for Exponential Early Tardy.

    To define the EXPET heuristic, first let he[j] be the weighted longest processing time heuristic of job j, defined as he[j] = -we[j] / p[j], where we[j] is the earliness weight for job j, and p[j] is the processing time of job j. Next, let ht[j] be the weighted shortest processing time heuristic of job j, defined as ht[j] = wt[j] / p[j], where wt[j] is the tardiness weight of job j. Define the slack s[j] of job j as: s[j] = d[j] - T - p[j], where d[j] is the job's due date and T is the current time. Let k ≥ 1 be a lookahead parameter that can be tuned based on problem instance characteristics, and p̄ is the average processing time of remaining unscheduled jobs.

    Now we can define the EXPET heuristic, h[j] for job j, as follows. Case 1: If s[j] ≤ 0, h[j] = ht[j]. Case 2: if s[j] ≥ k*p̄, h[j] = he[j]. Case 3: If 0 < s[j] ≤ k*p̄*ht[j]/(ht[j]-he[j]), then h[j] = ht[j] * exp((s[j](ht[j]-he[j]))/(he[j]*k*p̄)). Case 4: If k*p̄*ht[j]/(ht[j]-he[j]) < s[j] < k*p̄, then h[j] = he[j]-2 * (ht[j] - s[j](ht[j]-he[j])/(k*p̄))3. For jobs with negative slack, the EXPET heuristic is equivalent to weighted shortest processing time. For jobs with slack greater than some multiple k of the average processing time, EXPET is equivalent to weighted longest processing time.

    We make one additional adjustment to the heuristic as it was originally described. Since this library's implementations of stochastic sampling algorithms assumes that constructive heuristics always produce positive values, we must adjust the values produced by the EXPET heuristic. Specifically, we actually compute h'[j] = h[j] + shift, where shift = MIN_H - min(we[j] / p[j]). The MIN_H is a small non-zero value. In this way, we shift all of the h[j] values by a constant amount such that all h[j] values are positive.

    • Field Detail

      • MIN_H

        public static final double MIN_H
        The minimum heuristic value. If the heuristic value as calculated is lower than MIN_H, then MIN_H is used as the heuristic value. The reason is related to the primary purpose of the constructive heuristics in the library: heuristic guidance for stochastic sampling algorithms, which assume positive heuristic values (e.g., an h of 0 would be problematic).
        See Also:
        Constant Field Values
    • Constructor Detail

      • ExponentialEarlyTardyHeuristic

        public ExponentialEarlyTardyHeuristic​(SingleMachineSchedulingProblem problem)
        Constructs a ExponentialEarlyTardyHeuristic heuristic. Uses a default value of k=1.
        Parameters:
        problem - The instance of a scheduling problem that is the target of the heuristic.
      • ExponentialEarlyTardyHeuristic

        public ExponentialEarlyTardyHeuristic​(SingleMachineSchedulingProblem problem,
                                              double k)
        Constructs a ExponentialEarlyTardyHeuristic heuristic.
        Parameters:
        problem - The instance of a scheduling problem that is the target of the heuristic.
        k - A parameter of the heuristic (see class documentation). Must be at least 1.
        Throws:
        IllegalArgumentException - if k < 1.