EGD-ILS: Hybrid Energy Gradient Descent Optimization for Job Shop Scheduling

1. Introduction

The JSSP constitutes a foundational issue in combinatorial optimization pertinent to operations research. The range of applications varies, which includes manufacturing systems [1], logistics involving the supply chain [2], project management, and new areas of research such as cloud computing and smart grids. It consists of assigning a set of n jobs on a set of m machines. Each job $J_j$ consists of m operations $O_{jo}$ that must be processed in a given order. An operation $O_{jo}$ has a processing time $p_{jo}$ and it has a predefined machine $M_{jo}$. Our goal is to achieve the minimum makespan. Precedence and resource constraints must be satisfied.

Even though the JSSP is a classic NP-hard problem that has been studied for decades, it still proves to be difficult to be solved, which results in further innovations in exact methods, heuristics, and learning-based methods used to approach the problem. The algorithms that can provide exact solutions, such as MILP and B&B, are limited to smaller problem sizes (such as 10 jobs by 10 machines) because of their high computational complexity. Consequently, metaheuristics such as Genetic Algorithms, Simulated Annealing, or Particle Swarm Optimization provide good results but require fine parameter tuning and spend much time in infeasible regions of the search space [3,4].

The use of neural-inspired energy functions for scheduling dates back to the late 1980. In a pioneering study, Foo and Takefuji [5] formulated JSSP as a minimization problem on a Hopfield network by encoding each decision as a binary variable $V_{jot}$ indicating if job j is processed on operation o at time t. This leads to $O\left(nmT\right)$ neurons where T is the number of time steps. Their objective combined penalty terms for constraint violations with a term related to the makespan. A key drawback reported was the difficulty in balancing the different penalty weights, which often led to poor convergence behavior [6]. Van den Bout [7] introduced Mean Field Annealing but this approach suffers from the problem of combinatorial explosion and local minima..

Recent research has focused on energy formulations using modern optimization strategies; for example, the method developed by Peng and others, using an augmented Lagrangian framework that incorporates any constraint violations within the Lagrangian. This approach employed a gradient technique to minimize the Lagrangian and then applied a heuristic to achieve feasibility. This approach works well for medium instances only, but it still depends on choice of the correct penalty [8].

To enhance the robustness level, Wang and Zheng proposed a metaheuristic in two phases. In the first phase, the simulated annealing is utilized to minimize the compound function of the makespan and the violations of constraints. However, once again, some admissible solution is found, the second phase is based on Tabu search and aimed to minimize the makespan [9,10]. With Deep Learning, GNN (Graph Neural Networks) and RL (Reinforcement Learning) methods achieved strong results but require large datasets [11].

Recently, hybrid approaches have emerged to combine the advantages of different methods. The approach involves breaking down the problem into two parts:

1.

Find a feasible solution,

2.

Optimize the objective function [6].

In contrast to the methods above, the proposed EGD-ILS does not rely on stochastic search or data-driven training in the first phase. Instead, we show that by committing to a specific operation order upfront, the feasibility problem becomes convex. This allows us to use deterministic Gradient Descent with a proven convergence property. To our knowledge, this explicit convexity argument and its use for guaranteed feasibility in JSSP have not been explored before.

We propose EGD-ILS, a hybrid metaheuristics that uses the energy-based philosophy but optimize directly the continuous vector of start times $S\in \mathbb{R}{+}^{n\times m}$. A differentiable energy $E\left(S\right)$ measures the magnitude of violations. Minimizing $E\left(S\right)$ via gradient descent repairs an infeasible solution until an admissible schedule is obtained. Iterated Local Search explores admissible solutions to find optimal or near optimal solution. Our main contributions are threefold:

1.

We prove mathematically that by fixing the operation sequence, the feasibility search becomes a convex optimization problem that converges to E=0.

2.

We propose a simple and efficient architecture that combines the speed of Gradient Descent for feasibility and the power of Iterated Local Search for optimization.

3.

Experimental validation on FT and LA benchmarks.

4.

Our work is the first work that provides a theoretical convergence guarantee for the feasibility phase of a hybrid JSSP solver based on gradient methods.

On the other hand; it must be noted that the process of choosing how to represent the problem heavily relies on the representation chosen. Any representation of the JSSP has an influence on the algorithm that has to be used to tackle the problem. The relationship between any chosen representation and the algorithm remains a problem that is yet to be solved in the research of the JSSP in question. The advent of approaches like Graph Neural Network (GNN)-based encoding [12], RL-based allocation [13], and hybrid metaheuristics has shown to be quite successful [14], particularly when it comes to solving dynamic and stochastic versions of the problem. It has further emphasized the need to understand how representation influences JSSP, which shall allow one to develop better and more scalable solution techniques arise.

The two types of representation are:

• Indirect representation (Priority-based): The solution is represented by vectors which contain the priorities dispatching rules (PDR) [15], and then, using those elements, a schedule maker creates an admissible solution.
• Direct representation (Permutation-based): The solution is represented by the order of operations in the schedule.

Each of the methods has its own advantages and disadvantages: PDR method allows more compact representation that limits exploration but contains certain disadvantages, whereas the method based on permutation of operations makes it possible to search in detail, but causes certain problems connected with constraints of feasibility.

Although there is a wealth of literature on JSSP metaheuristics, systematic and controlled comparisons of these representation styles are lacking. Most studies focus on algorithmic variants within a single representation, making it hard to isolate the impact of encoding choice on performance.

This paper proposes two metaheuristics built on these two paradigms:

• Priority-based metaheuristic (META-PDR): Priority-rule driven metaheuristic + local search. Priorities are evolved by the metaheuristic, then a schedule is built and refined locally
• Permutational coding-based metaheuristic (META-Permutation): Permutation-based metaheuristic + local search. Solutions are encoded as feasible operation sequences and improved by direct sequence modifications.

The rest of the paper is laid out this way. Section 1 discuses the literature review. Section 2 presents a formulation of our problem. Section 3 presents the EGD-ILS methodology with the convergence proof and the other metaheuristics META-PDR and META-Permutation. Section 4 discus experimental results. Section 5 concludes.

2. Problem Formulation

We developed a mathematical statement of the JSSP problem [16]. Without loss of generality, Let’s use an instance (Table 1) as example to highlight the mathematical model used.

$S_{ij}$ is the starting time of operation $O_{ij}$. $M_{ij}$ is the resource used. $P_{ij}$ is the processing time .

H : Sum of all processing times $H={\sum }_{i=1}^n{\sum }_{j=1}^m{P}_{ij}$.

We introduce the Boolean variable:

$$Y_{ip}=\left\{\begin{array}{cc}0\hfill & if{S}_{ij}\le S_{pw}and{M}_{ij}=M_{pw}\hfill \\ 1\hfill & if{S}_{pw}\le S_{ij}and{M}_{ij}=M_{pw}\hfill \end{array}\right.$$

(1)

The goal is to minimize:

$$C_{max}=max\{S_{ij}+P_{ij}\}$$

(2)

Subject to :

■ Starting Time constraints : $n\times m$ equations

$$S_{11}\ge 0;S_{12}-8\ge 0;S_{13}-20\ge 0S_{21}\ge 0;S_{22}-11\ge 0;S_{23}-16\ge 0$$

(3)

■ Precedence Constraints : $n\times (m-1)$ equations

$$S_{12}-S_{11}-8\ge 0;S_{13}-S_{12}-12\ge 0S_{22}-S_{21}-11\ge 0;S_{23}-S_{22}-5\ge 0$$

(4)

■ Machine Constraints : $n\times m\times (n-1)$ equations

$$S_{22}-S_{11}+H(1-Y_{12})-8\ge 0;S_{11}-S_{22}+H\times Y_{12}-5\ge 0$$

(5)

$$S_{23}-S_{12}+H(1-Y_{12})-12\ge 0;S_{12}-S_{23}+H\times Y_{12}-14\ge 0$$

(6)

$$S_{21}-S_{13}+H(1-Y_{12})-3\ge 0;S_{13}-S_{21}+H\times Y_{12}-11\ge 0$$

(7)

3. Methods

3.1. THE EGD-ILS Metaheuristic

3.1.1. Phase 1: Feasible Construction by Gradient Descent with Fixed Sequence

■ Starting Penalty Energy:

$$\begin{array}{ccc}\hfill S=\left(\begin{array}{c}{S}_{11}\\ S_{12}\\ S_{13}\\ S_{21}\\ S_{22}\\ S_{23}\end{array}\right)& W_s=I_6=\left(\begin{array}{cccccc}1& 0& 0& 0& 0& 0\\ 0& 1& 0& 0& 0& 0\\ 0& 0& 1& 0& 0& 0\\ 0& 0& 0& 1& 0& 0\\ 0& 0& 0& 0& 1& 0\\ 0& 0& 0& 0& 0& 1\end{array}\right)\hfill & \hfill B_s=\left(\begin{array}{c}0\\ -8\\ -20\\ 0\\ -11\\ -16\end{array}\right)\end{array}$$

(8)

$$Z_s=W_s\times S+B_s$$

(9)

$Z_s$ must be non negative.

$$A_s=max(0;-W_s\times S-B_s)$$

(10)

We define the starting energy as:

$$E_s\left(S\right)={\displaystyle \sum _{i=1}^{n\times m}}{\left(A_s(i,1)\right)}^2$$

(11)

■ Precedence Penalty Energy;

$$\begin{array}{ccc}\hfill S=\left(\begin{array}{c}{S}_{11}\\ S_{12}\\ S_{13}\\ S_{21}\\ S_{22}\\ S_{23}\end{array}\right)& W_p=\left(\begin{array}{cccccc}0& 0& 0& 0& 0& 0\\ -1& 1& 0& 0& 0& 0\\ 0& 0& -1& 1& 0& 0\\ 0& 0& 0& 0& 0& 0\\ 0& 0& 0& -1& 1& 0\\ 0& 0& 0& 0& -1& 1\end{array}\right)\hfill & \hfill B_p=\left(\begin{array}{c}0\\ -8\\ -12\\ 0\\ -11\\ -5\end{array}\right)\end{array}$$

(12)

$$Z_p=W_p\times S+B_p$$

(13)

$Z_p$ must be non negative.

$$A_p=max(0;-W_p\times S-B_p)$$

(14)

We define the precedence energy as:

$$E_p\left(S\right)={\displaystyle \sum _{i=1}^{n\times m}}{\left(A_p(i,1)\right)}^2$$

(15)

■ Machine Penalty Energy

The key idea of EGD-ILS is to fix the operation sequence in phase 1. This transforms the disjunctive machine constraint into a linear constraint. Without any loss of generality, consider that $\pi =\left\{1;2;2;1;2;1\right\}$ is a fixed operation sequence. Machine Constraints becomes:

$$S_{22}-S_{11}-8\ge 0;S_{11}-S_{22}+H-5\ge 0$$

(16)

$$S_{23}-S_{12}-12\ge 0;S_{12}-S_{23}+H-14\ge 0$$

(17)

$$S_{21}-S_{13}+H-3\ge 0;S_{13}-S_{21}-11\ge 0$$

(18)

$$\begin{array}{ccc}\hfill S=\left(\begin{array}{c}{S}_{11}\\ S_{12}\\ S_{13}\\ S_{21}\\ S_{22}\\ S_{23}\end{array}\right)& W_m=\left(\begin{array}{cccccc}-1& 0& 0& 0& 1& 0\\ 1& 0& 0& 0& -1& 0\\ 0& -1& 0& 0& 0& 1\\ 0& 1& 0& 0& 0& -1\\ 0& 0& -1& 1& 0& 0\\ 0& 0& 1& -1& 0& 0\end{array}\right)\hfill & \hfill B_m=\left(\begin{array}{c}-8\\ H-5\\ -12\\ H-14\\ H-3\\ -11\end{array}\right)\end{array}$$

(19)

$$Z_m=W_m\times S+B_m$$

(20)

$Z_m$ must be non negative.

$$A_m=max(0;-W_m\times S-B_m)$$

(21)

We define the Machine Conflict Energy as:

$$E_m\left(S\right)={\displaystyle \sum _{i=1}^{n\times m}}{\left(A_m(i,1)\right)}^2={\parallel max(0;-W_m\times S-B_m)\parallel }^2$$

(22)

We define the energy function to minimize:

$$E(S,\pi )=E_s\left(S\right)+E_p\left(S\right)+E_m(S,\pi )$$

(23)

Algorithm 1 Energy Descent for JSSP

Input: Instance , $\pi$ , Maxiter , $\alpha$: Learning rate Calculate $W_s,B_s,W_p,B_p,W_m,B_m$ Initialize $S=-B_s$ for$k=1$ to $Maxiter$ do     Compute E(S,$\pi$)     if $E(S,\pi )=0$ then         Return S     else         $[E,G]\leftarrow$ Compute Gradient(S)         $S\leftarrow S-\alpha \times G$         $S\leftarrow max(0,S)$     end if end for ReturnS

3.1.2. Mathematical Proof of Convergence

Lemma 1. 

The function $h\left(X\right)={\parallel max(0;AX+B)\parallel }^2$ is convex.

Proof. 

The affine function f(X)= A X + B is convex.

The function $g\left(X\right)=max(0,X)$ is convex and increasing.

Thus $g\left(f\right(X\left)\right)=max(0;AX+B)$ is convex.

The squared Euclidean norm ${\parallel X\parallel }^2$ is convex and increasing for non negative arguments. Thus $h\left(X\right)={\parallel max(0;AX+B)\parallel }^2$ is convex.

   □

Lemma 2. 

The energy function $E(S,\pi )$ for a fixed order π, which was defined above, is convex and L-smooth.

Proof. 

$E(S,\pi )=E_s\left(S\right)+E_p\left(S\right)+E_m(S,\pi )$ where:

$E_s\left(S\right)={\parallel max(0;-W_s\times S-B_s)\parallel }^2$

$E_p\left(S\right)={\parallel max(0;-W_p\times S-B_p)\parallel }^2$

$E_m\left(S\right)={\parallel max(0;-W_m\times S-B_m)\parallel }^2$

The function $E(S,\pi )$ is a sum of convex and smooth functions. Therefore, From Lemma 1$E(S,\pi )$ is convex and L-smooth [17].    □

Lemma 3. 

For any fixed order π, there exists $S^{*}$ such that $E(S^{*},\pi )=0$.

Proof. 

By definition of the JSSP, for any order $\pi$ there exists at least one feasible schedule. For this schedule, all violations are $\le 0$. As $E\ge 0$, $E=0$ is the global minimum.    □

Theorem 1. 

For any fixed order π and For any a fixed learning rate $0<\alpha <2/L$, $S\left(t\right)$ converges to $S^{*}$ such that $E{(}^{*})=0$.

Proof. 

$S(t+1)=max(0,S(t\left)\right)-\alpha \nabla E\left(S\right(t\left)\right)$

From Lemma 2, we can see that E is convex and L-smooth.

From Lemma 3, we know that the set of minima is non-empty.

Moreover $\nabla E$ is L-Lipschitz. We apply the classical convergence theorem of gradient descent for convex functions. ([18], Sec. 9.1)    □

3.1.3. Phase 2: Optimization by Iterated Local Search

The Iterated Local Search, algorithm 2, explores the set of admissible schedules by using neighbours structure and deciding to transit or not to the candidate solution.

Denote $N_1$ permutes two operations.$N_2$ is right shift insertion. $N_3$ uses left shift insertion. $N_4$ is inversion blocks between two positions [19]. $N_5$ uses random combination of the four neighbours $N_k\left(\pi \right),k=1,...,4$.

An initial temperature of $T_0$ is given. The parameter $\beta \in [0.5;0.95]$ the speed of convergence.

Algorithm 2 EGD-ILS Phase 2

Input: Instance ; $\beta$ ; $T_0$ Initialize ${\pi }_0$ ; $\left[S\right]⟵Algorithm1(Instance;{\pi }_0)$ ${\pi }^{\left(best\right)}⟵{\pi }_0$ ;    $\pi ⟵{\pi }_0$ ;    $T⟵T_0$ Compute $C_{max}\left(\pi \right)$ for$k=1$ to K do     Choose $\pi "$ from neighbours of $N_5\left(\pi \right)$     $\left[S\right]⟵Algorithm1(Instance;\pi ")$     Compute $C_{max}(\pi ")$     if $C_{max}(\pi ")<C_{max}\left(\pi \right)$ then         $\pi$ := $\pi "$         if $C_{max}\left(\pi \right)<C_{max}\left({\pi }^{\left(best\right)}\right)$ then            ${\pi }^{\left(best\right)}$ := $\pi$         end if     else         $\Delta =C_{max}(\pi ")-C_{max}\left(\pi \right)$         if $random\le exp(-\Delta /T)$ then            $\pi$ := $\pi "$         end if     end if     T := $\beta \times T$ end for

3.2. META-PDR: Priority-Based Metaheuristic

Denote a sequence $PDR=\{PD{R}_1;...;PD{R}_m\}$, where $PD{R}_i$ is the PDR chosen for the $i^{th}$ resource.

$M_{(i,j)}$: the machine used to process operation ij.

$P_{j,M_{(i,j)}}$ amount of time of j on $M_{(i,j)}$.

Priority-based Metaheuristic explores schedules generated by sequence of PDR, while local search intensifies around promising schedules. The algorithm 3 explains step by step this approach.

Algorithm 3 META-PDR

The initial matrix of release times $R\left(0\right)$ is: $${\left[R\left(0\right)\right]}_{j,M_{(i,j)}}=\left\{\begin{array}{ccc}0\hfill & sii=1{\displaystyle {\sum }_{k=1}^{i-1}}{P}_{j,M_{(k,j)}}\hfill & sinon.\end{array}\right.$$ (24) for$t=1$ to $n\times m$ do     We determine the earliest start time ${\tau }_t=min{\left[R\left(t\right)\right]}_{j,M_{(i,j)}}$     ${\tau }_t$ indicates the operation to choose. If there are many operations using the same resource, apply the PDR.     Denote the chosen operation $(j^{*},m^{*})$ in step t:      $${\left[S\left(t\right)\right]}_{(j^{*},m^{*})}={\tau }_t{\left[C\left(t\right)\right]}_{(j^{*},m^{*})}={\left[S\left(t\right)\right]}_{(j^{*},m^{*})}+{\left[P\right]}_{(j^{*},m^{*})}$$ (25)     The matrix of release time in step t+1 is: $${\left[R(t+1)\right]}_{(j^{*},m^{*})}=+\infty {\left[R(t+1)\right]}_{(j,m^{*})}=max({\left[R\left(t\right)\right]}_{(j,m^{*})};{\left[C\left(t\right)\right]}_{(j^{*},m^{*})})$$ (26) if ${\left[R\left(t\right)\right]}_{(j,m^{*})}\ne +\infty$ and ${\left[R\left(0\right)\right]}_{j,M_{(i,j)}}>{\left[R\left(0\right)\right]}_{(j,m^{*})}$ then $$\begin{array}{cc}\hfill {\left[R(t+1)\right]}_{j,M_{(i,j)}}& =max({\left[R\left(t\right)\right]}_{j,M_{(i,j)}};{\left[R(t+1)\right]}_{(j,m^{*})}+({\left[R\left(0\right)\right]}_{j,M_{(i,j)}}-{\left[R\left(0\right)\right]}_{(j,m^{*})}))\hfill \end{array}$$ (27) end for

3.3. META-Permutation: Permutational Coding-Based Metaheuristic

A permutational coding arranges a solution by listing job indices in a specific sequence, where job appears multiple times (as many times as there are operations for that job). The sequence is often interpreted as a priority list, where jobs appearing earlier in the sequence have higher priority. Specifically, $\pi =\left\{{\pi }_1;{\pi }_2;...;{\pi }_{n\times m}\right\}$ is a sequence of integers representing operations, where ${\pi }_i\in [1,n]$ is an integer corresponding to a job index, and each job index is replicated m times (assuming each job has m operations). The position in the sequence determines the scheduling priority: operations appearing earlier are scheduled first when possible, respecting precedence and resource constraints.

To decode this permutational representation into a feasible schedule, you would typically iterate through the sequence from left to right, scheduling each operation at the earliest possible time on the required machine while respecting precedence constraints. The algorithm 4 describes this approach.

Algorithm 4 META-Permutation

Initialize an empty schedule and a list of available operations (those with no predecessors). for$k=1$ to $n\times m$ do     For each job index, determine the next operation that hasn’t been scheduled.     Schedule this operation at the earliest possible time on the required machine, ensuring it doesn’t conflict with other operations and respects precedence constraints.     Update the schedule and mark the operation as scheduled.     Add new operations to the list of available operations if their predecessors have been scheduled. end for

3.4. Global Approach

META-PDR and META-Permutation generate admissible solutions and calculate $C_{max}$ of the current schedule. The Iterated Local Search, algorithm 5, explores admissible solutions and decides to move or not to another solution. iteratively, this hybrid metaheuristic improves initial solution.

Algorithm 5 Optimization by ILS

Input:${\pi }_0=\left\{{\pi }_1;{\pi }_2;...;{\pi }_{n\times m}\right\}$ ;$\alpha$ ${\pi }^{best}⟵{\pi }_0$ ;    $\pi ⟵{\pi }_0$ ;    $T⟵T_0$ initial temperature for$k=1$ to $MaxIter$ do     select ${\pi }^{*}$ from neighbourhood of $\pi$     if $C_{max}\left({\pi }^{*}\right)<C_{max}\left(\pi \right)$ then         $\pi$ := ${\pi }^{\prime }$         if $C_{max}\left(\pi \right)<C_{max}\left({\pi }^{\left(best\right)}\right)$ then            ${\pi }^{\left(best\right)}$ := $\pi$         end if     else         if $random\le exp(-exp(-(C_{max}\left({\pi }^{*}\right)-C_{max}\left(\pi \right))/T)$ then            $\pi$ := ${\pi }^{*}$         end if     end if     T := $\alpha \times T$ end for

$\alpha \in [0.5;0.95]$ is a parameter that indicates the convergence speed. $N_k\left(\pi \right),k=1,...,5$ are defined. Denote $N_1$ swaps the position of two operations. $N_2$ uses right-shifting and inserting. $N_3$ uses the insertion and left shift. $N_4$ uses blocks inversion between two positions. $N_5$ is a random combination of the four $N_k\left(\pi \right),k=1,...,4$.

4. Results

4.1. Numerical Example

Without loss of generality, let’s use SPT as priority dispatching rule for all resources. Firstly, the initial matrix of release times is generated by summing the processing times of previous operations. the rows represent jobs and columns represent machines.

Table 2. JSSP $3\times 3\mid C_{max}$

Jobs	Operation 1	Operation 2	Operation 3
$J_1$	M3 (7)	M1 (8)	M2 (4)
$J_2$	M1 (4)	M3 (9)	M2 (11)
$J_3$	M3 (6)	M2 (10)	M1 (7)

Table 2. JSSP $3\times 3\mid C_{max}$

Jobs	Operation 1	Operation 2	Operation 3
$J_1$	M3 (7)	M1 (8)	M2 (4)
$J_2$	M1 (4)	M3 (9)	M2 (11)
$J_3$	M3 (6)	M2 (10)	M1 (7)

$$R\left(0\right)=\left(\begin{array}{ccc}7& 15& 0\\ 0& 13& 4\\ 16& 6& 0\end{array}\right)$$

(28)

At step $t=0$ : ${\tau }_0=min{\left[R\left(0\right)\right]}_{i,k}=0$

Operation 21 can be scheduled on machine M1, while operations 13 and 33 are eligible for scheduling on machine M3. Without loss of generality, let’s choose 21.

$$S_{21}={\tau }_0=0;C_{21}=S_{21}+P_{21}=0+4=4$$

(29)

$$R\left(1\right)=\left(\begin{array}{ccc}7& 15& 0\\ +\infty & 13& 4\\ 16& 6& 0\end{array}\right)$$

(30)

At step $t=1$ : ${\tau }_1=min{\left[R\left(1\right)\right]}_{i,k}=0$

13 and 33 can be scheduled on M3. The SPT must be applied. thus, 33 is scheduled.

$$S_{33}={\tau }_1=0;C_{33}=S_{33}+P_{33}=0+6=6$$

(31)

$$R\left(2\right)=\left(\begin{array}{ccc}13& 21& 6\\ +\infty & 15& 6\\ 16& 6& +\infty \end{array}\right)$$

(32)

At sep $t=2$ : ${\tau }_2=min{\left[R\left(2\right)\right]}_{j,\sigma (i,j)}=6$ 13 and 23 can be scheduled on machine M3 while 32 is eligible for scheduling on M2. Let’s start with 32.

$$S_{32}={\tau }_2=6;C_{32}=S_{32}+P_{32}=6+10=16$$

(33)

$$R\left(3\right)=\left(\begin{array}{ccc}13& 21& 6\\ +\infty & 16& 6\\ 16& +\infty & +\infty \end{array}\right)$$

(34)

In step $t=3$ : ${\tau }_3=min{\left[R\left(3\right)\right]}_{j,\sigma (i,j)}=6$

13 and 23 are eligible for scheduling on M3. 31 has the smallest processing time. Thus 31 is scheduled.

$$S_{13}={\tau }_3=6;C_{13}=S_{13}+P_{13}=6+7=13$$

(35)

$$R\left(4\right)=\left(\begin{array}{ccc}13& 21& +\infty \\ +\infty & 23& 13\\ 16& +\infty & +\infty \end{array}\right)$$

(36)

In step $t=4$ : ${\tau }_4=min{\left[R\left(4\right)\right]}_{J,\sigma (i,j)}=13$

11 can be scheduled on resource M1 while 23 can be scheduled on M3. Let’s start with the resource M1.

$$S_{11}={\tau }_4=13;C_{11}=S_{11}+P_{11}=13+8=21$$

(37)

$$R\left(5\right)=\left(\begin{array}{ccc}+\infty & 21& +\infty \\ +\infty & 23& 13\\ 21& +\infty & +\infty \end{array}\right)$$

(38)

In step $t=5$, 23 must be scheduled on resource M3. ${\tau }_5=min{\left[R\left(5\right)\right]}_{j,\sigma (i,j)}=13$

$$S_{23}={\tau }_5=13;C_{12}=S_{23}+P_{23}=13+9=22$$

(39)

$$R\left(6\right)=\left(\begin{array}{ccc}+\infty & 21& +\infty \\ +\infty & 23& +\infty \\ 21& +\infty & +\infty \end{array}\right)$$

(40)

In step $t=6$, 31 is scheduled. : ${\tau }_6=min{\left[R\left(6\right)\right]}_{j,\sigma (i,j)}=21$

$$S_{31}={\tau }_6=21;C_{31}=S_{31}+P_{31}=21+7=28$$

(41)

$$R\left(7\right)=\left(\begin{array}{ccc}+\infty & 21& +\infty \\ +\infty & 23& +\infty \\ +\infty & +\infty & +\infty \end{array}\right)$$

(42)

In step $t=7$, 12 is scheduled. : ${\tau }_7=min{\left[R\left(7\right)\right]}_{j,\sigma (i,j)}=21$

$$S_{12}={\tau }_7=21;C_{12}=S_{12}+P_{12}=21+4=25$$

(43)

$$R\left(8\right)=\left(\begin{array}{ccc}+\infty & +\infty & +\infty \\ +\infty & 23& +\infty \\ +\infty & +\infty & +\infty \end{array}\right)$$

(44)

Finally, 22 is scheduled. $S_{22}={\tau }_8=25;C_{22}=S_{22}+P_{22}=25+11=36$

All operations are scheduled. The makespan equals 36 time units. S and C matrix are generated:

$$\begin{array}{cc}\hfill S=\left(\begin{array}{ccc}13& 21& 6\\ 0& 25& 13\\ 21& 6& 0\end{array}\right)& C=\left(\begin{array}{ccc}21& 25& 13\\ 4& 36& 22\\ 28& 16& 6\end{array}\right)\hfill \end{array}$$

(45)

The Figure 1 represents a Gantt chart of schedule using Shortest Processing Time (SPT) as PDR. $C_{max}$ of this instance is 36 time units.

4.2. Simulation Results-Discussion

The three metaheuristics are tested on the FT and LA benchmarks.

$$RPD={\displaystyle \frac{C_{max}-C_{max}^{*}}{C_{max}^{*}}}\times 100$$

(46)

where $C_{max}$ is the makespan found by the metaheuristic; and $C_{max}^{*}$ is the optimal makespan.

Table 3 and Table 4 present a comparison between metaheuristics META-PDR and META-Permutation. META-Permutation gives lower makespan on all instances. it gives optimal or at least near-optimal for small and large instances. The RPD varies between $0\%$ and $5,2\%$ for LA instances and between $0\%$ and $12,2\%$ for FT instances. We can conclude that using Permutational coding-based metaheuristic(META-Permutation) guided by Iterated Local Search (ILS), gives best results comparing with META-PDR.

The Table 5 and Table 6 present the results of EGD-ILS on FT and LA benchmarks.

EGD-ILS delivers high-quality solutions on FT and LA benchmarks with reduced computation time. It achieves RPD < 3.9%, solving FT06 and LA05 to LA15 optimally.

5. Conclusions

We proposed a straightforward energy-based approach for JSSP that’s simple and fast. EGD-ILS shows strong performance on FT and LA benchmarks with RPD < 3.9% , solving FT06 and LA05-LA15 optimally with reduced computation time.

This paper compared also two metaheuristics META-PDR and META-Permutation that differ only in solution encoding but share the same local search mechanism. The experimental results indicate that META-Permutation is advantageous than META-PDR. Its RPD varies between $0\%$ and $5,2\%$ for LA instances and between $0\%$ and $12,2\%$ for FT instances. Future work will consider adaptive switching between the two representations during search.