A Petri Net-Based Algorithm for Solving the One-Dimensional Cutting Stock Problem

Abstract

This paper addresses the one-dimensional cutting stock problem, focusing on minimizing total stock usage. Most procedures that deal with this problem reside on linear programming methods, heuristics, metaheuristics, and hybridizations. These methods face drawbacks like handling only low-complexity instances or requiring extensive parameter tuning. To address these limitations we develop a Petri-net model to construct cutting patterns. Using the filtered beam search algorithm, the reachability tree of the Petri net is constructed level by level from its root node to find the best solution, pruning the nodes that worsen the solution as the search progresses through the tree. Our algorithm is compared with the Least Lost Algorithm and the Generate and Solve algorithm over five datasets of instances. These algorithms share some characteristics with ours and have proven to be effective and efficient. Experimental results demonstrate that our algorithm effectively finds optimal and near-optimalsolutions for both low and high-complexity instances. These findings confirm that Petri nets are suitable for modeling and solving the one-dimensional cutting stock problem.

1. Introduction

Cutting stock problems are combinatorial problems involving the creation of small objects from large objects according to a cutting plan made of cutting patterns. The larger the number of small objects, the greater the number of possible cutting patterns, and hence these problems are classified as NP-hard optimization problems [1]. In this study, we focus on the single stock-size cutting problem according to Wascher’s classification [2] for the one-dimensional case, or one-dimensional cutting stock problem (1D-CSP), as it is best known in most of the literature. The 1D-CSP arises in industries manufacturing goods from paper, metal, glass, and wood, among others. The goal is the reduction in material usage and, therefore, the minimization of the related costs. Apart from cost reduction, industries such as the building industry are concerned with reducing gas emissions due to metal and concrete usage, as pointed out in [3]. Some other studies also address the problem by considering mathematical models that include the reuse of leftovers, as in [4]. Reference [5] presents some LP formulations proposed in the early stages of addressing the 1D-CSP.

In the literature, most mathematical models for the 1D-CSP consider functions of only one term, either the total waste or the total number of stocks used. However, ref.  [6] demonstrated the effectiveness of using a function that involves simultaneously the total waste and the total number of stocks used. In this study, we consider the objective function of the mathematical model (1)–(3) based on the one used in [7] for the 1D-CSP without contiguity. The objective function to be minimized accounts for both the minimization of waste and the minimization of the number of stocks with waste.

$$\begin{array}{cc}\hfill \min & W={\displaystyle \frac{1}{k+1}}\left(\sum _{j=1}^k\sqrt{{\displaystyle \frac{w_j}{L_j}}}+\sum _{j=1}^k{\displaystyle \frac{V_j}{k}}\right)\hfill \end{array}$$

(1)

$$\begin{array}{c}\hfill \mathrm{subject}\mathrm{to}\end{array}$$

$$\begin{array}{cc}\hfill & \sum _{j=1}^k{x}_{ij}=d_i,i=1,2,\dots ,m\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill & x_{ij}\ge 0\mathrm{and}\mathrm{integer}.\hfill \end{array}$$

(3)

In model (1)–(3), $L_j$ is the length of the stock, m is the number of different items, k is the total number of stocks used. $d_i$ represents the demand or total number of orders of item i, while $l_i$ is the length of item i, $x_{ij}$ is the number of orders of item i in stock j. $w_j$ and $V_j$ are defined in Equations (4) and (5), respectively, where $w_j$ represents the wastage of stock j.

$$\begin{array}{cc}\hfill w_j& =L_j-\sum _{i=1}^m{x}_{ij}{l}_i,j=1,2,\dots ,k\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill V_j& =\left\{\begin{array}{cccc}1\hfill & \mathrm{if}& w_j>0,\hfill & j=1,2,\dots ,k\\ 0\hfill & & \mathrm{otherwise}.\hfill \end{array}\right.\hfill \end{array}$$

(5)

Most approaches to solving the 1D-CSP are based on linear programming (LP) methods, with the column generation technique being one of the most outstanding ones. Column generation and other techniques focus on generating and reducing the number of cutting patterns. In the 1D-CSP, a cutting pattern is an ordered sequence of items cut from a large object or stock. One-cut models and arc-flow models are other paradigms used to address the 1D-CSP, as solutions to the 1D-CSP can be constructed as sequences of items. This sequential approach to constructing the 1D-CSP solutions motivates our proposal of using ordinary Petri nets (PN) to model the solution construction. We take advantage of the reachability tree to find the best solution through the implementation of a filtered beam search algorithm (FBS). Beam search algorithms are a type of any-time search algorithm, suitable for optimization problems where solutions can be constructed sequentially and represented as a tree structure. Unlike other any-time search methods, beam search algorithms do not perform backtracking. Only the most promising nodes at each level are retained to continue searching for the best path from the root node to a desired final node, while non-promising nodes are pruned permanently. The FBS is an improvement to the classical beam search algorithm. At each level, it first filters the nodes through a local evaluation and then performs a global evaluation among the filtered nodes to retain the best ones for further investigation.

Even though the main drawback of PN is state explosion, we do not generate the complete reachability tree. Instead, we generate promising states from the initial state that lead to the desired final state with minimum waste, according to the FBS, using the objective function (1) to evaluate the nodes. The initial state or marking of the PN is where no items have been taken to form a solution, and the final state or marking is where all items have been taken to form a solution. At each level of the tree, partial solutions are evaluated locally, and the best ones are then evaluated globally. Nodes with the best partial solutions are kept for further investigation. The advantages of using PN are twofold: they are useful for validating solutions when PN is deadlock-free, and they can be combined with graph search methods to solve optimization problems. Some of the problems addressed under the PN paradigm include job and flow shop scheduling problems. In these cases, PN and graph search methods like ${\mathrm{A}}^{*}$ algorithms [8,9,10] and beam search algorithms [11,12,13] have been used to obtain the best scheduling solutions. However, to the best of our knowledge, PN has not been used to solve cutting problems. Based on this, the issues concerned with heuristic, metaheuristic, LP, and even hybridized methods have motivated our study to explore PN as an approach to address the 1D-CSP. Our experimental results show that PN is suitable for modeling pattern generation and solving the 1D-CSP, with acceptable performance in both solution quality and computational time.

2. Literature Review

It is widely considered that Kantorovich first addressed the 1D-CSP in [14] providing an LP formulation of the problem and using the multipliers method to solve it. Later, refs. [15,16] used the column generation technique to solve the integer linear programming formulation by addressing an associated knapsack problem. Following the introduction of the column generation technique, several procedures were developed to improve its computational performance using branch-and-price algorithms [17,18,19,20]. Other algorithms have focused on constructing and reducing the number of patterns [21,22,23,24,25]. Alternative approaches to modeling and solving the 1D-CSP include the arc-flow and one-cut formulations. The arc-flow formulation, a graph-based approach, was introduced in [26]. Recently, [27] proposed and compared arc-flow formulations based on other algorithms. One-cut formulations have received little attention since their use in [28]. Moreover, [29] proved the equivalence among pattern-based formulations, such as that of Gilmore & Gomory [15,16], and the arc-flow and one-cut formulations. [30] used dynamic programming to solve the 1D-CSP, and [31] showed the relationship between arc-flow formulations and dynamic programming in solving optimization problems. Additionally, a comprehensive survey of LP methods used to solve the 1D-CSP up to 2015 can be found in [32].

LP methods are restricted to instances of a small number of items, and to overcome this limitation, many researchers have proposed metaheuristic methods like genetic algorithms. However, the use of genetic algorithms faces the difficulty of finding the best way to encode the solutions or cutting patterns, as pointed out in [33,34,35,36]. Evolutionary programming was used in [7,37] to address the 1D-CSP with and without contiguity. Additionally, ref. [38] concluded that evolutionary programming performs better than genetic algorithms for solving the 1D-CSP. Swarm intelligence algorithms, such as particle swarm optimization algorithms [39,40,41,42] and ant colony optimization algorithms [43,44,45], have also been used to solve the 1D-CSP. The main issues with these two algorithms are parameter tuning and the need for hybridizations to avoid premature convergence and control the search space. Additionally, discretization procedures are required since these algorithms are better suited for continuous problems. Other metaheuristic algorithms for solving the 1D-CSP include tabu search, simulated annealing [46], and iterative local search [47,48]. More recently, ref. [49] introduced the least-lost algorithm to simultaneously minimize waste and stocks with waste in the 1D-CSP, showing better results than the evolutionary programming algorithm of [7]. Ref. [50] compares a Generate and Solve algorithm to the column generation technique. The Generate and Solve algorithm uses a reduction technique based on the one presented in [51] to deal with large instances of the 1D-CSP. Although the algorithm is not better than the column generation technique, it can solve larger instances in acceptable computational time with quasi-optimal solutions. Ref. [52] introduces a deep reinforcement learning algorithm to minimize the number of stocks and maximize the length of leftovers. The algorithm performs well in terms of computational time and handling large instances.

The algorithm we propose in this paper covers some of the limitations of the methods described above. Unlike LP methods, our algorithm is capable of addressing large instances as shown in Section 6 and Section 7 in acceptable computational time. It only needs the instance information to construct the PN model and the tuning of two parameters for the filtered beam search algorithm, while most metaheuristic algorithms and hybridizations require more parameters to address large instances of the 1D-CSP. Additionally, our algorithm yields optimal solutions for the majority of small instances and near-optimal solutions for medium and large instances without the need to implement complex procedures to reduce the instances or to select the promising solutions, as the Generate and Solve method, and the one-cut, arc-flow models, and other similar methods do.

3. Basic Concepts

In this section, we present the basic concepts of ordinary PN and the beam search algorithm necessary to introduce our algorithm. However, PN theory is extensive, so readers are referred to [53,54] for more information on the properties and variants of PN.

3.1. Petri Nets

PN was introduced by Carl A. Petri in 1960 as part of his doctoral dissertation. Since then, many researchers have studied PN theory and its applications. Additionally, other types of PN, such as timed PN, colored PN, and stochastic PN, have been developed to enhance their modeling power. In this paper, we will refer to the ordinary PN.

An ordinary PN, or simply PN, is a bipartite graph consisting of two sets of nodes: $P=\{p_1,p_2,\dots ,p_r\}$, and transitions $T=\{t_1,t_2,\dots ,t_s\}$, such that $P\cap T=\varnothing$. These nodes are connected by a set of directed arcs $F\subseteq \left\{\right(P\times T)\cup (T\times P\left)\right\}$. Places may represent activities or conditions in systems modeling, whereas transitions represent the occurrence of a condition or the execution of an activity [53]. Figure 1 shows a typical example of a PN model, where circles represent places and rectangles represent transitions, respectively. Each arc carries a number or arc weight, defined by the function $W:F\to N^{+}$, which helps simulate the system’s dynamics. Moreover, a particular state of the system is represented by a distribution of tokens (black dots) within the places, resulting in the marking of the PN. Formally, a marking is defined by the function $M:P\to N$. A marked place means that the corresponding activity or condition is being executed.

The dynamics or evolution of PN markings involves removing and adding tokens when a firing occurs. Let ${ }^{•}t$ and $t^{•}$ denote the sets of input and output places of transition t. If $M\left(p\right)\ge W(p,t)$ for each $p\in { }^{•}t$ at some marking M, then the transition t is enabled and can be fired. When transition t is fired, $W(p,t)$ tokens are removed for each $p\in { }^{•}t$, and $W(t,p)$ tokens are added to each output place $p\in t^{•}$. The dynamics of a PN can also be described by matrix operations using Equation (6), known as the state equation where ${\mathbf{M}}_k$ is an $r\times 1$ vector representing the current state or marking of the PN, and ${\mathbf{M}}_0$ is the initial marking or state of the PN. $\mathbf{I}$ is the incidence matrix of size $r\times s$, given by Equation (7) where ${\mathbf{I}}^{+}$ and ${\mathbf{I}}^{-}$ are the input and output incidence matrices, respectively.

$${\mathbf{M}}_{k+1}={\mathbf{M}}_k+\mathbf{Iu}$$

(6)

$$\mathbf{I}={\mathbf{I}}^{+}-{\mathbf{I}}^{-}$$

(7)

Each entry of ${\mathbf{I}}^{+}$ corresponds to the weights $W(t,p)$, while in ${\mathbf{I}}^{-}$ the entries correspond to the weights $W(p,t)$, as shown in Equation (8) for the PN from Figure 1. Finally, $\mathbf{u}$ is the firing vector of size $s\times 1$, where one entry is 1 (indicating the transition to be fired at marking ${\mathbf{M}}_k$), and the remaining entries are zero. Typically, from a set of enabled transitions at a marking $\mathbf{M}$, one transition is fired at a time to explore the possible states that can be reached from that marking. This is represented by the notation $\mathbf{M}\stackrel{t}{\to }{\mathbf{M}}^{\prime }$, where t is the fired transition and ${\mathbf{M}}^{\prime }$ is the marking reached from $\mathbf{M}$.

$$\mathbf{I}={\mathbf{I}}^{+}-{\mathbf{I}}^{-}=\left[\begin{array}{cc}0& 0\\ 1& 0\\ 0& 2\\ 0& 1\end{array}\right]-\left[\begin{array}{cc}2& 0\\ 0& 1\\ 1& 0\\ 0& 0\end{array}\right]=\left[\begin{array}{cc}-2& 0\\ 1& -1\\ -1& 2\\ 0& 1\end{array}\right]$$

(8)

Given a PN with an initial marking ${\mathbf{M}}_0$, a firing path $\sigma$ is a sequence of transitions fired from ${\mathbf{M}}_0$ to marking ${\mathbf{M}}^{\prime }$, denoted as $\mathbf{M}\stackrel{\sigma }{\to }{\mathbf{M}}^{\prime }$. When this occurs, ${\mathbf{M}}^{\prime }$ is said to be reachable from ${\mathbf{M}}_0$. The set of all possible reachable markings from ${\mathbf{M}}_0$ can be represented by a reachability tree, provided that this set is finite. An example of a reachability tree, corresponding to the PN in Figure 1, is shown in Figure 2. Taking the marking ${\mathbf{M}}_0$ as the root of the reachability tree, a new branch is created for each transition fired from ${\mathbf{M}}_0$. After exhausting all possible firings from ${\mathbf{M}}_0$, a new level of markings is created, such as ${\mathbf{M}}_1$ in Figure 2. At the new level, for each marking new branches are created using the same procedure. When all the possible markings have been obtained, a new level is added to the tree. The process is repeated for each of the markings at every new level until all the reachable markings from ${\mathbf{M}}_0$ have been obtained. However, when no transition can be fired from a specified marking, it is considered a dead marking. If the evolution of markings is stopped by dead markings without reaching a desired final marking, the PN is blocked.

It should be noted that although the set of reachable markings from ${\mathbf{M}}_0$ can be finite, the number of these markings could be so large that it becomes impossible to enumerate or represent them using a reachability tree. This issue is known as the state explosion of PN.

3.2. Filtered Beam Search Algorithm

The beam search algorithm was first used as an artificial intelligence technique for speech recognition. It has since been applied to combinatorial optimization problems, such as scheduling problems [55], the traveling salesman problem [56,57,58], and cutting and packing problems [59,60,61,62,63]. This method is efficient because solutions to these problems can be constructed sequentially by appending the next operation, city, or item to the partial solution based on the cost it adds. Thus, the construction of the solution can be viewed as a decision tree. At each level, the corresponding nodes represent partial solutions with given costs, while at the last level, the nodes represent complete solutions. One of these complete solutions is then selected as the best or optimal solution. The beam search algorithm performs a breadth-first search followed by a depth-first search. At each level of the tree, the nodes are branched, and those that are not promising for further branching based on a cost function evaluation are pruned. The number of nodes $\beta$ that are branched at each level are the beams. Once these nodes have been selected, the others are discarded permanently. Since the beam search has no backtracking, it is possible to discard good solutions, but it saves much computational effort. In [64], a modification to the beam search was introduced known as the filtered beam search algorithm. As the name suggests, at each level a local evaluation is carried out over the nodes that share the same parent node. Only those nodes that satisfy a local evaluation condition are considered beam nodes, thereby filtering the nodes. Once all the filtered nodes have been obtained from the parent nodes, only those that satisfy a global evaluation condition become the new beam nodes or parent nodes for the next level.

The number of filtered nodes $\alpha$ (filter width) and the number of beam nodes $\beta$ (beam width) are user-defined. However, it is known that larger values require more computational effort to search the tree, while smaller values reduce the likelihood of finding the best or optimal solution. A representation of the filtered beam search algorithm is shown in Figure 3 for a solution with a sequence of n nodes. Sometimes, it is desired to maintain diversity in the search by setting $\alpha <\beta$, which guarantees that at least one beam node is selected from a different parent node [60].

4. PN-Based Algorithm for Solving the 1D-CSP

In this section, we first provide details about the PN model used to construct solutions for a given instance of the 1D-CSP. Next, we explain how the beam search algorithm, based on the reachability tree, is used to find the best solution.

4.1. PN Model for the 1D-CSP

As mentioned above, we use ordinary PN to model a given instance of the 1D-CSP. Figure 4 illustrates the general PN model for a given instance of the 1D-CSP, with m different items and stock length L. The construction of a solution for a 1D-CSP instance through the PN model follows the next-fit heuristic principle. This means that items are added sequentially to the solution as long as the total length of the items, or pattern length, does not exceed the length of the stock. Otherwise, the next item is put into a new stock, and the process is repeated until all items have been added to the solution. In this way, there will be patterns with or without waste, and the total waste of the solution will be the sum of the waste yielded from each pattern. The PN model allows the formation of patterns with and without waste, enabling the beam search algorithm to find the solution with the minimum waste and the minimum number of stocks with waste.

According to the general PN model, there will be m places for each item type labeled $p_2,p_3,\dots ,p_{m+1}$, as shown in Figure 4. We refer to these places as item places. The number of tokens inside the item places represents the number of orders of each item, denoted $d_1,d_2,\dots ,d_m$. The stock is represented by a single place labeled $p_1$, and the number of tokens inside this place is equal to the stock length, L. We refer to this place as the stock place. Item places, as well as the stock place, are input places for transitions $t_1,t_2,\dots ,t_m$, referred to as item transitions. Each item transition consumes a token from its corresponding item place, indicating that an order of that item is being put into a solution. Similarly, each item transition removes $l_i$ tokens from the stock place, which corresponds to the length of the item of the corresponding item place. As items are taken, a pattern is formed, and its length is accumulated in the place labeled $p_{m+2}$, which we name the pattern place. As shown in Figure 4, the pattern place is an output place of each item transition, where each one adds $l_i$ tokens to the pattern place according to the item length it is being added to the solution. Therefore, the number of tokens inside the pattern place varies from 0 to L. However, the minimum pattern length will be $\lambda =min\{l_1,l_2,\dots ,l_m\}$, representing a pattern formed by only one order of the item with the smallest length.

The transitions $t_{m+1},t_{m+2},t_{m+3},\dots ,t_{m+L}$ are the pattern transitions, and there will be L transitions of this type. A pattern transition removes tokens from the pattern place according to the corresponding pattern length that has been formed. For example, $t_{m+1}$ removes L tokens, $t_{m+2}$ removes $L-1$ tokens, and so on, such that $t_{m+L}$ removes $\lambda$ tokens. Since a pattern includes the lengths of the items as well as the unused material of the stock (if any), pattern transitions $t_{m+2},t_{m+3},\dots ,t_{m+L}$ are output transitions of the stock place to complete the pattern formation. Thus, $t_{m+2}$ removes one token, $t_{m+3}$ removes two tokens, and so on, such that $t_{m+L}$ removes $L-\lambda$ tokens from the stock place. Transition $t_{m+1}$ is not an output transition of the stock place since it corresponds to a pattern without waste. At the same time, the pattern transitions are input transitions of the stock place so that once a pattern has been formed and included in a solution, another stock must be available to continue the process of forming the solution. Each pattern transition adds L tokens to the stock place as shown in Figure 4. So far, the PN model can construct any possible solution by starting with any item, but we included three more places to enhance the model. These places are $p_{m+3}$, $p_{m+4}$ and $p_{m+5}$, where $p_{m+3}$ records the amount of waste, $p_{m+4}$ helps to count the number of stocks without waste, and $p_{m+5}$ counts the number of stocks with waste. Places $p_{m+3}$ and $p_{m+5}$ are output places of the pattern transitions. Each pattern transition adds one token to $p_{m+5}$ while $p_{m+3}$ receives $1,2,\dots ,L-\lambda$ tokens from transitions $t_{m+2},t_{m+3},\dots ,t_{m+L}$, respectively. Place $p_{m+4}$ is an output place of transition $t_{m+1}$, which adds one token each time there is a pattern without waste. Based on the above descriptions, Figure 5 shows the general form of the incidence matrices of the PN model for an instance of the 1D-CSP.

4.2. Marking Evolution and Solution Construction

To obtain a solution for a given instance of the 1D-CSP with the PN model described in the previous section, referred to as PN-CSP, we begin with the initial marking as shown in Figure 4 where there is an unused stock (place $p_1$) and m items with their corresponding number of orders (places $p_2$ to $p_{m+1}$). Hence, the general form of the initial marking of the PN-CSP is as follows:

$${\mathbf{M}}_0={[L{d}_1{d}_2\cdots d_{m+1}0000]}^T.$$

From the initial marking, the enabled transitions are $t_1,t_2,\dots ,t_m$ so that any of the items could be the first in the solution. The solution is constructed in a linear sequence of items arranged from left to right. Once an enabled transition is fired, the pattern place accumulates tokens representing the length of the item placed first in the solution. Suppose transition $t_2$ is fired; then, the resulting marking is as follows:

$${\mathbf{M}}_1={[L-l_2{d}_1{d}_2-1\cdots d_{m+1}{l}_{2}000]}^T.$$

While the number of tokens in $p_{m+2}$ is not equal to or greater than any of the weights of the arcs $L,L-1,L-2,\dots ,\lambda$, transitions $t_1,t_2,\dots ,t_m$ can be fired one at a time because they will be the only ones enabled. This means the pattern formation continues as long as there is space in the current stock. However, if a determined pattern length less than the stock length is reached, such as $L-1,L-2$, or $\lambda$, the corresponding transition from $t_{m+2}$ to $t_{m+L}$ is enabled, considering there will be $1,2,$ or $L-\lambda$ tokens in place $p_1$, representing the waste of the stock. If one of the transitions $t_{m+2},\dots ,t_{m+L}$ is selected to be fired, the pattern formation stops to renew the stock for a new pattern. For example, consider the marking:

$${\mathbf{M}}_k={[2ab\cdots cL-2000]}^T,$$

where $a,b,\dots ,c$ are the corresponding remaining number of item orders after $k-1$ items have been included in the first pattern of the solution, and $M_k\left(p_{m+2}\right)=L-2$. Then, $t_{m+3}$ is enabled and can be fired, yielding the marking:

$${\mathbf{M}}_{k+1}={[Lab\cdots c0201]}^T.$$

Here, there is a new empty stock of length L, and one stock with waste ($M_{k+1}\left(p_{m+5}\right)=1$) has been generated as part of the solution with a waste of 2 ($M_{k+1}\left(p_{m+3}\right)=2$). With the new empty stock, the construction of the solution continues with the remaining items’ orders. When a pattern transition is fired, it means that a cutting pattern has been formed, adding a new stock with or without waste to the solution. These markings that enable and fire a pattern transition are called pattern markings. On the other hand, if an item transition is fired, it means that an item has been added to the current pattern in construction. These markings that enable and fire an item transition are called item markings. The marking evolution is performed as described, forming patterns and renewing the stocks when needed until all of the items have been included in a solution.

When the number of tokens in places $p_2,p_3,\dots ,p_{m+1}$ is zero, the solution has been completed, and the marking ${\mathbf{M}}_f={[L00\cdots 00\omega \nu \eta ]}^T$ is considered the final marking, where $\omega$ is the final total waste, $\nu$ is the final number of stocks without waste, and $\eta$ is the final number of stocks with waste. Therefore, the solution can be obtained with the firing sequence $\sigma$ obtained from ${\mathbf{M}}_0$ to ${\mathbf{M}}_f$, that is ${\mathbf{M}}_0\stackrel{\sigma }{\to }{\mathbf{M}}_f$. A final firing sequence would have the following form:

$$\sigma =t_2,t_m,\dots ,t_1,t_{m+3},t_1,t_3,\dots ,t_m,t_{m+1},\cdots ,t_{m+L},t_m,t_1,\dots ,t_3,t_{m+2}.$$

To decode $\sigma$ into a sequence of item lengths, the pattern transitions $t_{m+3}$, $t_{m+1}$, $t_{m+L}$ and $t_{m+2}$ are dropped, and a new sequence is made up with the remaining transitions. This new sequence is as follows:

$$\varsigma =t_2,t_m,\dots ,t_1,t_1,t_3,\dots ,t_m,\cdots ,t_m,t_1,\dots ,t_3.$$

The solution is formed with either the weights $W(t_i,p_{m+2})$ or $W(p_1,t_i)$ for $1\le i\le m$ for each of the transitions in $\varsigma$, such that these weights correspond to the lengths of the items. Therefore, for the final firing sequence $\sigma$, the solution would have the following form:

$$s=l_2,l_m,\dots ,l_1,l_1,l_3,\dots ,l_m,\cdots ,l_m,l_1,\dots ,l_3.$$

5. Filtered Beam Search Algorithm Implementation

Consider the reachability tree construction of the PN-CSP with initial marking ${\mathbf{M}}_0={[L{d}_1{d}_2\cdots d_{m+1}0000]}^T$ for a given instance of the 1D-CSP. Starting from this initial marking, all potential solutions are derived by investigating firing sequences leading to the final marking ${\mathbf{M}}_f={[L00\cdots 00\omega \nu \eta ]}^T$. However, exhaustive exploration of all sequences is computationally intensive. To solve this issue, we use the FBS, which reduces explored markings as we progress in the reachability tree. FBS does not perform backtracking like traditional any-time search methods, optimizing computational efficiency. The effectiveness of FBS depends on parameters $\alpha$ and $\beta$, chosen to balance exploration and exploitation. Algorithm 1 outlines our FBS implementation, starting by generating all child nodes from firing transitions $t_1,t_2,\dots ,t_m$ at the initial marking or the root node (level 0 or $L0$), resulting in m markings at level 1 ($L1$), as shown in Figure 6. In our FBS, each marking at L1 is neither locally nor globally evaluated, treating each node as a potential beam node, contrary to [55]. We made this decision because, by the local evaluation, the algorithm will tend to select the solutions with the largest items placed first, minimizing waste in the initial stock. Preliminary experiments showed this approach yields better solutions compared to selecting only $\beta$ nodes at $L1$. Thus, starting from L2, we apply both local and global evaluations, setting $\alpha \le \beta$ to ensure solution diversity.

Algorithm 1 Pseudocode of algorithm FBS-PN-CSP

Input:  Number of different item types (m), stock length (L), item lengths $(l_1,l_2,\dots ,l_m)$, and item orders $(d_1,d_2,\dots ,d_m)$. Output:  $F_{best}$ 1: With the instance data, generate the incidence matrices ${\mathbf{I}}^{+}$, ${\mathbf{I}}^{-}$ and obtain the incidence matrix $\mathbf{I}$. 2: Generate the initial marking as ${\mathbf{M}}_0=[L{d}_1{d}_2\cdots d_{m+1}0000]$. 3: Set the beamwidth $\beta$ and the filterwidth $\alpha$. 4: $F_{best}\leftarrow \infty$ 5: $W_w\leftarrow 0$ 6: $W_{sw}\leftarrow 0$ 7: Generate level $L0$ of the reachability tree with the marking ${\mathbf{M}}_0$ as the root node such that $Currentlevel=\left\{{\mathbf{M}}_0\right\}$. 8: $level\leftarrow 0$ 9: $Bestsolution\leftarrow False$ 10: while  $BestsolutionisFalse$  do 11:    for each marking in $Currentlevel$ do 12:      Get $W_w$, $W_{sw}$ and $F_{global}$. 13:    end for 14:    if level > 1 then 15:      Kept the $\mu =\min (\beta ,|Currentlevel\left|\right)$ best markings in $Currentlevel$ with the lowest $F_{global}$ cost and form the set $\mathcal{B}$ with these markings. Eliminate the remaining markings from $Currentlevel$. 16:    else 17:      Kept the $\mu =\left|Currentlevel\right|$ markings in $Currentlevel$ and form the set $\mathcal{B}$ with these markings. 18:    end if 19:    $Newlevel=\varnothing$ 20:    for each marking $\mathbf{M}$ in $\mathcal{B}$ do 21:      Determine the reachable markings ${\mathbf{M}}^{\prime }$ from $\mathbf{M}$ with Equation (6) and form the set ${\mathcal{M}}_r$ with those reachable markings, where $r=1,2,\dots ,\left|\mathcal{B}\right|$. 22:      if ${\mathcal{M}}_r\ne \varnothing$ then 23:         Obtain $W_w$, $W_{sw}$, $F_{local}$ and $F_{global}$ for each ${\mathbf{M}}^{\prime }\in {\mathcal{M}}_r$. 24:         if level >0 then 25:           Check whether any marking ${\mathbf{M}}^{\prime }\in {\mathcal{M}}_r$ has already been generated previously. If it has, let ${\mathbf{M}}_{prev}^{\prime }\in {\mathcal{M}}_1\cup {\mathcal{M}}_2\cup \cdots \cup {\mathcal{M}}_{r-1}$ be the previously generated marking that is equal to ${\mathbf{M}}^{\prime }\in {\mathcal{M}}_r$, and then eliminate from the reachability tree the one with the maximum $F_{global}$ cost. 26:           if ${\mathcal{M}}_r\ne \varnothing$ then 27:              Kept the $\tau =\min (\alpha ,|{\mathcal{M}}_r\left|\right)$ markings with the lowest $F_{local}$ cost and eliminate the remaining ones from ${\mathcal{M}}_r$. 28:           end if 29:         else 30:           Keep the markings in ${\mathcal{M}}_r$. 31:         end if 32:         Make $Newlevel\cup {\mathcal{M}}_r$ 33:      end if 34:    end for 35:    Check whether the final marking ${\mathbf{M}}_f=[L00\cdots 00***]$ has been reached. 36:    if ${\mathbf{M}}_f$ has been reached then 37:      $F_{best}\leftarrow F_{global}$ 38:      $Bestsolution\leftarrow True$ 39:    else 40:      $level\leftarrow level+1$ 41:      $Currentlevel=Newlevel$ 42:    end if 43: end while

In most beam search algorithm implementations, node costs at any node are computed using a function that considers cumulative costs up to the node and an estimation of the remaining solution’s cost. The effectiveness of these algorithms heavily depends on choosing the right estimation cost function. Usually, in the FBS algorithm, local evaluation uses cumulative costs, while global evaluation considers both cumulative and estimated costs. Our FBS implementation employs the objective function (1) as a fitness function to perform both local and global evaluations. This function calculates the complete solution, capturing the number of stocks used, the total waste generated, and the number of stocks with waste that have been generated in the solution.

As we progress in constructing the reachability tree, each node or marking represents only a partial solution, thus its corresponding cost is also partial. Despite not having a complete solution, partial solutions provide insights into the number of stocks used, those with or without waste, and the amount of unused material or potential waste on the current stock. For example, at the initial marking or root node, no stock has been used, resulting in no stocks with or without waste, and an unused material length of L. At level L1, item markings represent solutions where one order of each item has been taken, but no stock has been fully utilized with or without waste. Eventually, as the reachability tree progresses, pattern markings are reached at some level, indicating that a cutting pattern has been obtained. At the first pattern marking, a stock has been used, and the waste amount for the stock is known. Subsequent item markings’ costs must consider the used stock and its waste. It can be seen from the objective function (1) that the first term sums the partial wastage of each used stock, while the second sums the number of stocks with waste. We compute two cumulative costs accordingly: one for waste using Equation (9) and another for the number of stocks with waste using Equation (10). Both are employed in Equation (11) for the global evaluation of nodes. These two cumulative costs are computed upon reaching a pattern marking, while Equation (12) is utilized for local evaluations, considering the unused material of the current stock in each solution.

$$W_w=W_w+\sqrt{{\displaystyle \frac{w_j}{L}}}$$

(9)

$$W_{sw}={\displaystyle \frac{M\left(p_{m+5}\right)}{M\left(p_{m+5}\right)+M\left(p_{m+4}\right)}}$$

(10)

$$F_{global}={\displaystyle \frac{W_w+W_{sw}}{M\left(p_{m+5}\right)+M\left(p_{m+4}\right)+1}}$$

(11)

$$\begin{array}{cc}\hfill F_{local}& =\left\{\begin{array}{cc}{\displaystyle \frac{1}{M\left(p_{m+5}\right)+M\left(p_{m+4}\right)+1}}\left({\displaystyle \frac{M\left(p_1\right)}{L}}+W_{sw}\right)\hfill & \mathrm{if}M\mathrm{is}\mathrm{an}\mathrm{item}\mathrm{marking}.\hfill \\ & \\ {\displaystyle \frac{1}{M\left(p_{m+5}\right)+M\left(p_{m+4}\right)+1}}\left({\displaystyle \frac{w_j}{L}}+W_{sw}\right)\hfill & \mathrm{if}M\mathrm{is}\mathrm{a}\mathrm{pattern}\mathrm{marking}.\hfill \end{array}\right.\hfill \end{array}$$

(12)

In Equations (9) and (12), $w_j$ is obtained from the incidence matrix of PN-CSP, where $w_j=\mathbf{I}(p_{m+3},t)$ for $t\in \{t_{m+2},t_{m+3},\dots ,t_{m+L}\}$. This is because when a pattern transition is fired, the marking of place $p_1$ is immediately updated to L, indicating that the amount of waste in the already used stock is lost. However, this amount of waste can be determined from the incidence matrix. The cumulative costs $W_w$ and $W_{sw}$ are set to zero for the item markings between the initial marking and the first pattern marking. These costs are computed and updated at each reached pattern marking. Consequently, the outcomes of $W_w$ and $W_{sw}$ are retained for the item markings between two subsequent pattern markings. Once the final marking is reached, the last $F_{global}$ outcome is set as the best solution $F_{best}$. To determine whether the final marking has been reached, at each level, we compare the markings obtained with the desired final marking ${\mathbf{M}}_f\left(p_1\right)$. However, we only consider the marking of places $p_1,p_2,\dots ,p_{m+2}$. Specifically, we compare the marking $\mathbf{M}=[M\left(p_1\right)M\left(p_2\right)M\left(p_3\right)\cdots M\left(p_{m+1}\right)M\left(p_{m+2}\right)***]$, obtained at some level, with the final marking ${\mathbf{M}}_f=[L00\cdots 00***]$. The ‘*’ means that the marking of the corresponding places is not considered for the comparison. This is because we do not know in advance how much waste would be generated by the best solution or the number of stocks with and without waste. However, we know that at the final marking, there are no more item orders to place, and the last stock is generated when the last item order is taken for the final cutting pattern.

Observe from Algorithm 1, lines 17 and 29, that when performing global and local evaluations, we do not necessarily select $\beta$ or $\alpha$ number of markings, respectively. Instead, we select the minimum value between $\beta$ (or $\alpha$) and the number of markings obtained globally (or locally). This is because, in a reachability tree, a marking could be generated by firing different transitions, resulting in fewer markings than the $\beta$ markings needed at a level or fewer than the $\alpha$ markings needed from a parent marking or beam node. In some beam search algorithm implementations, if the required $\beta$ nodes are not met for some level, then more parent nodes at the previous level are explored to meet the required $\beta$ nodes. However, we do not conduct this in our FBS implementation, as it is possible to encounter dead markings. This might make it impossible to complete the required number of nodes. Dead markings are related to the liveness property of a PN and this property is closely related to the presence of siphons [65]. It is known that a PN with siphons is likely to be non-live, as once the places of a siphon become unmarked at some marking, they remain unmarked in all subsequent markings. We performed a structural analysis for an instance with ten different items and a total of 20 orders, using an open-source PN modeling platform called PIPE2 version 4.3.0 [66] to determine the presence of siphons. The results are shown in Figure 7, indicating that place $p_2$ ($p_1$ according to the enumeration of the PIPE2 platform) is a minimal siphon. Extending this result for the general PN-CSP model with the initial marking in the general form, and considering the dynamics described in the above paragraphs, places $p_1,p_2,\dots ,p_m$ could be minimal siphons and could become unmarked at some marking. The PN-CSP would become deadlocked if all the places $p_1,p_2,\dots ,p_m$ are unmarked, although this situation indicates that the desired final marking has been reached. However, to prevent our algorithm from getting stuck due to incomplete $\beta$ nodes at some levels and potentially failing to reach the desired final marking, we decided to use the minimum number of nodes as outlined in Algorithm 1.

6. Experiments

Although we identified a wide variety of datasets in the literature, most studies do not use common datasets or performance measures to compare the algorithms. Additionally, implementing the published algorithms correctly can be challenging, and often, the code is not shared. Nevertheless, we identified two algorithms that share some similarities with our algorithm and are not based on populations. These algorithms were tested on five datasets that we found suitable for comparison with our algorithm. The first algorithm is the Least Lost Algorithm (LLA), introduced in [49], which uses a dataset of ten instances with a single stock size. We refer to this dataset as hinterding because, to the best of our knowledge, it was first used in [67]. The LLA is executed in two phases. In the first one, the item lengths are arranged in decreasing order while in the second, the second half of the arrangement is put before the first half. In both phases, the items are taken from the arrangement to construct cutting patterns by beginning with those that have no waste. If no additional cutting patterns without waste can be found, the search continues with patterns that have one unit of waste. This process continues by increasing the allowed waste by one unit until all the item orders have been included in a cutting pattern. If the number of stocks used is above the optimal theoretical value by more than 5%, the algorithm performs the second phase. The feature of increasing the allowed waste by one unit is represented in our PN-CSP model with the pattern transitions. The LLA was compared to the EP algorithm shown in [7] over the same dataset and the LLA yielded better results.

The other algorithm we compare to the FBS-PN-CSP is the Generate and Solve algorithm (G&S) presented in [50]. This algorithm is also executed in two phases. The first one reduces the problem size using a tree method that constructs all possible cutting patterns. Feasible cutting patterns are then selected and sent to the second phase, where an integer linear programming (ILP) method is implemented to obtain the best solution for the reduced set of solutions. In the first phase, a new reduced set of solutions is generated by considering an aging mechanism for previously used solutions, which can be re-selected as long as they have not reached a specified age limit. These new solutions are then sent to the second phase to determine the best solution among them, replacing the older solution if the new one is better. This process continues until a predefined time limit is reached, and the last solution found is returned as the best solution for the problem. The G&S algorithm was compared to the column generation technique. Both algorithms performed similarly for small instances, but the G&S algorithm was more effective for large instances. From the datasets used in [50], we selected the ones called hard28, hard10, and wae_gau1, available at [68]. Additionally, we included the dataset falkenauer_U from the same repository, which consists of four groups named binpack1, binpack2, binpack3, and binpack4.

Table 1. Data sets details used in this study.

Dataset	Number of Instances	Min-Max Number of Item Types	Number of Different Item Types (Std. Dev.)	Number of Orders 1	Stock Length 2
hinterding	10	8–36	4 (10.55)	20, 50, 60, 126, 200, 400, 600	14, 15, 25, 25, 4300, 86, 120, 120, 120, 120
hard28	28	136–189	21 (14.43)	160, 180, 200	1000
hard10	10	197–200	4 (0.89)	200	100,000
wae_gau1	17	33–64	14 (9.39)	114, 96, 57, 111, 164, 141, 144, 142, 239, 91, 60, 163, 228, 86, 92, 153, 119	10,000
falkenauer_U:
binpack1	20	58–68	11 (2.71)	120	150
binpack2	20	71–81	8 (2.14)	250	150
binpack3	20	80–81	2 (0.40)	500	150
binpack4	20	81	1 (0)	1000	150

¹ Among all instances. ² For each instance.

provides details about the datasets. The third column lists the minimum and maximum number of item types among the instances of each dataset, while the fourth column shows the number of different item types, along with the standard deviation in rounded brackets. Both the hinterding dataset and the hard10 dataset have four different item types, but the variability in the former is greater than in the latter.

The comparisons among the three algorithms were made with respect to the number of stocks used and their optimal theoretical value, which can be obtained using Equation (13). The experiments were conducted on a Quad-Core Intel^(R) Core^(TM) i5 computer with a 3.4 GHz processor and 8 GB RAM. All three algorithms were coded in Python 3.11.1. For the second phase of the G&S algorithm, we used the Scipy package with the linprog library. We also set the same parameter values as in [50], that is, specifically: a time limit of 600 s for the G&S algorithm, a mutation rate of 10%, a maximum age of 2, and a maximum number of cutting patterns for the tree construction of 1,000,000. Additionally, we also executed the G&S algorithm 10 times for each instance. However, we did not set a time limit in the second phase of the G&S algorithm, as the solutions from the ILP solver were obtained in an acceptable time.

$$lb=⌈{\displaystyle \frac{{\sum }_i^m{l}_i{d}_i}{L}}⌉$$

(13)

One of the issues with beam search algorithms is the selection of the beam width $\beta$. The smaller the $\beta$ value, the faster the search, but this comes with the loss of optimality due to aggressive pruning. We conducted preliminary experiments to determine suitable $\beta$ and $\alpha$ values, considering the condition $\alpha \le \beta$. These experiments were carried out with the hinterding dataset and we tested for $\beta$ values chosen from 5 to 45. In all ten instances of this dataset, we observed that the best solutions were found with a beam width between 5 and 25. For small instances, the best solutions were found with lower $\beta$ values while for large instances the values were higher. However, with higher values (namely from 30 to 45) there was no improvement in the solutions among the tested instances. Thus, for all the experiments with the FBS-PN-CSP algorithm, we used the interval $5\le \beta \le 35$ for the beam width, at steps 5, 15, 25, and 35. We chose these $\beta$ values since from the preliminary experiments, at these values we observed improvements in the solutions of the tested instances. Furthermore, apart from finding no solution improvements in the preliminary experiments, higher values of $\beta$ impact the efficiency of the FBS algorithm. However, for the hinterding dataset, we also implemented the $\beta$ value of 45 as in the preliminary experiments. For the hard10 dataset, we only could implement a beam width of $\beta =5$ due to the length of the stock, as it will be discussed in Section 8. The filter width was set in the interval $2\le \alpha \le \beta$ for each value of $\beta$. With $\alpha =1$, no good solution was found in any instance.

7. Results

For each tested instance of the datasets, we report the best results obtained with each algorithm for the number of stocks used and the time taken in seconds. Additionally, we provide the $lb$ value for all the instances and the percentage above this value (%$>lb$) obtained by each algorithm. The FBS-PN-CSP, G&S, and LLA algorithms were compared only with the hinterding and falkenauer_U datasets since the LLA algorithm ran out of memory for the other datasets. The minimum value of stocks used among the compared algorithms is highlighted in boldface. For the G&S algorithm, we provide the best solution found within the 10 executions, and likewise, for the FBS-PN-CSP algorithm, we include the best combinations of beam width and filter width where the best stock result was found. The results of the hinterding, hard10, and waegau1 datasets are reported in this section. The results of the hard28, binpack1, binpack2, binpack3, and binpack4 datasets are included in Appendix A.

For the hinterding dataset, the three algorithms obtained the same optimal theoretical value for the 1a–5a instances and the 7a instance as shown in

Table 2. Best stock results for hinterding instances.

		FBS-PN-CSP						G&S						LLA
Instance	lb	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time		Stock	% > lb	Time (s)
1a	9	9	5	5	0.00	0.08		9	0.00	0.01	9.00	9.18		9	0.00	0.00
2a	23	23	5	2	0.00	0.19		23	0.00	34.15	23.00	304.45		23	0.00	0.00
3a	15	15	5	5	0.00	0.23		15	0.00	2.09	15.00	269.23		15	0.00	0.05
4a	19	19	15	2	0.00	1.24		19	0.00	27.16	19.00	266.60		19	0.00	0.03
5a	51	53	5	5	3.92	25.71		53	3.92	35.83	53.00	276.56		53	3.92	5.06
6a	78	79	15	4	1.28	9.87		79	1.28	21.91	79.00	243.05		80	2.56	1.13
7a	68	68	15	15	0.00	9.89		68	0.00	110.58	68.00	373.81		68	0.00	0.53
8a	143	144	15	3	0.70	23.18		143	0.00	11.25	143.00	273.35		145	1.40	29.14
9a	149	150	15	15	0.67	31.43		149	0.00	35.82	149.00	339.76		152	2.01	10.86
10a	215	216	25	22	0.47	117.90		215	0.00	12.10	215.00	294.33		216	0.47	13.39

From the algorithms’ stock results for each instance, the minimum is in boldface.

. The FBS-PN-CSP and the G&S algorithms also obtained the same best result for the 6a instance. Only the G&S had the optimal theoretical value for the 8a–10a instances. The FBS-PN-CSP algorithm had better results than the LLA algorithm for the 6a, 8a, and 9a instances, while for the 10a instance, both had the same result. Although the FBS-PN-CSP algorithm was not better than the G&S algorithm for instances 8a–10a, it obtained a percentage above the optimal theoretical value of less than 1%. The FBS-PN-CSP algorithm was more efficient than the G&S algorithm in six out of seven instances where they are equal, namely 2a–7a. However, the LLA algorithm had better times in all the instances where it had the same results as the other two algorithms. The beam width of the FBS-PN-CSP algorithm seems to increase as the number of items and the stock length increase. The highest beam width and filter width values were obtained in the 10a instance, which has the higher number of items and the longest stock.

In 12 out of 17 instances of the wae_gau1 dataset, the FBS-PN-CSP algorithm matched the best results of the G&S algorithm (

Table 3. Best stock results for wae_gau1 instances.

		FBS-PN-CSP						G&S
Instances	lb	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time
TEST0005	28	29	5	2	3.57	56.71		29	3.57	139.58	29.00	352.83
TEST0014	23	24	5	2	4.35	39.37		24	4.35	64.83	24.00	243.59
TEST0022	14	15	5	2	7.14	19.90		15	7.14	48.72	15.00	322.90
TEST0030	27	28	5	2	3.70	52.06		28	3.70	61.94	28.00	312.79
TEST0044	14	14	25	4	0.00	367.03		15	7.14	380.16	42.00	38.02
TEST0049	11	11	25	2	0.00	276.48		12	9.09	241.32	15.50	304.08
TEST0054	14	14	35	3	0.00	484.86		14	0.00	356.10	47.80	146.63
TEST0055	15	16	5	2	6.67	62.91		16	6.67	427.36	34.90	154.52
TEST0055_2	20	20	15	14	0.00	257.22		96	380.00	0.00	96.00	0.01
TEST0058	20	21	5	2	5.00	34.71		20	0.00	350.58	20.60	351.83
TEST0065	15	16	5	2	6.67	22.52		16	6.67	18.94	16.00	309.42
TEST0068	12	13	5	2	8.33	61.89		13	8.33	240.98	49.00	143.78
TEST0075	13	13	25	6	0.00	418.74		14	7.69	294.42	47.30	320.35
TEST0082	24	25	5	2	4.17	36.54		25	4.17	136.45	25.00	426.39
TEST0084	16	16	15	15	0.00	116.07		16	0.00	76.77	17.80	223.36
TEST0095	16	17	5	2	6.25	77.83		17	6.25	88.63	17.00	354.11
TEST0097	12	12	15	15	0.00	110.32		12	0.00	397.77	25.20	197.42

From the algorithms’ stock results for each instance, the minimum is in boldface.

), and in 9 of these 12 instances, it had better times. In 4 out of the 17 instances, the FBS-PN-CSP had better results, and only in one instance, the G&S was better than the FBS-PN-CSP. In 7 out of the 17 instances, the FBS-PN-CSP obtained the optimal theoretical value, meanwhile, the G&S did so in only four instances. Regarding beam width, four instances required the higher tested values, namely 25 and 35, but with a small filter width. For the hard10 instances, the G&S algorithm was better than the FBS-PN-CSP algorithm as shown in

Table 4. Best stock results for hard10 instances.

		FBS-PN-CSP						G&S
Instances	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time
HARD0	55	59	5	2	7.27	5673.86		56	1.82	79.64	64.40	129.34
HARD1	56	60	5	2	7.14	5669.64		57	1.79	327.97	59.20	394.00
HARD2	56	60	5	2	7.14	5707.35		57	1.79	132.01	57.00	276.31
HARD3	55	59	5	2	7.27	5663.16		56	1.82	96.01	57.90	296.15
HARD4	56	60	5	2	7.14	5628.17		57	1.79	139.28	57.00	331.95
HARD5	55	59	5	2	7.27	5454.04		56	1.82	241.52	60.20	325.61
HARD6	56	60	5	2	7.14	5462.07		57	1.79	123.19	57.00	370.79
HARD7	54	59	5	2	9.26	5645.90		56	3.70	273.06	61.10	273.82
HARD8	56	59	5	2	5.36	5447.00		57	1.79	112.20	59.30	314.82
HARD9	56	60	5	2	7.14	5529.23		56	0.00	265.34	64.40	266.41

From the algorithms’ stock results for each instance, the minimum is in boldface.

. However, the G&S algorithm only had the optimal theoretical value in one instance, namely HARD9. Even with the smaller value of the beam width, the time required for the FBS-PN-CSP was far higher than the time of the G&S algorithm. For this reason, we could not implement larger values for the beam width since the computational cost was prohibited, although it did not run out of memory. Despite the results for stock used by the FBS-PN-CSP algorithm, it was not far from those of the G&S and could be at least equal if higher values of the beam width can be implemented.

The results of the FBS-PN-CSP and G&S algorithms are shown in

Table A1. Best stock results for hard28 instances.

		FBS-PN-CSP						G&S
Instances	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time
BPP13	67	68	5	2	1.49	62.64		68	1.49	62.85	68.00	318.00
BPP14	61	62	5	3	1.64	39.00		62	1.64	80.02	62.20	271.94
BPP40	59	60	5	2	1.69	45.43		60	1.69	55.68	60.00	386.12
BPP47	71	72	5	3	1.41	55.45		72	1.41	33.30	72.10	335.88
BPP60	63	64	5	2	1.59	41.82		64	1.59	83.76	64.00	341.97
BPP119	76	77	5	2	1.32	81.96		77	1.32	70.20	77.00	394.30
BPP144	73	74	5	3	1.37	86.90		74	1.37	55.30	74.00	154.26
BPP175	83	84	5	2	1.20	79.39		84	1.20	162.17	84.20	368.87
BPP178	80	81	5	2	1.25	76.44		81	1.25	56.91	81.00	317.22
BPP181	72	73	5	2	1.39	53.15		73	1.39	77.70	73.00	241.26
BPP195	64	65	5	2	1.56	63.60		65	1.56	80.06	65.00	230.26
BPP359	75	76	5	2	1.33	55.20		76	1.33	42.19	76.00	277.42
BPP360	62	63	5	2	1.61	42.86		63	1.61	46.44	63.00	278.08
BPP419	80	81	5	2	1.25	88.21		81	1.25	101.71	81.00	393.38
BPP485	71	72	5	2	1.41	60.96		72	1.41	50.03	72.00	293.62
BPP531	83	84	5	2	1.20	66.61		84	1.20	56.32	87.80	232.66
BPP561	72	73	5	3	1.39	91.02		73	1.39	104.56	73.00	266.22
BPP640	74	75	5	2	1.35	57.74		75	1.35	50.65	75.00	174.81
BPP645	58	59	5	2	1.72	42.29		59	1.72	50.29	59.00	333.46
BPP709	67	68	5	2	1.49	63.62		68	1.49	64.85	68.00	353.67
BPP716	75	76	5	2	1.33	48.80		76	1.33	121.97	76.00	437.33
BPP742	64	65	5	2	1.56	43.19		65	1.56	48.39	65.00	279.50
BPP766	62	63	5	2	1.61	42.38		63	1.61	41.52	63.00	325.24
BPP781	71	72	5	2	1.41	80.94		75	5.63	77.74	79.10	323.78
BPP785	68	69	5	2	1.47	63.15		69	1.47	56.98	69.00	276.04
BPP814	81	82	5	2	1.23	76.95		82	1.23	35.57	86.70	281.63
BPP832	60	61	5	3	1.67	44.76		61	1.67	64.45	61.00	349.86
BPP900	75	76	5	2	1.33	84.50		78	4.00	62.22	81.70	318.96

From the algorithms’ stock results for each instance, the minimum is in boldface.

for the hard28 dataset. Both algorithms obtained the same best results except for the BPP900 and BPP781 instances, where the FBS-PN-CSP had the better results. Nevertheless, neither obtained the optimal theoretical value. The FBS-PN-CSP was more efficient in 15 out of 27 instances where both algorithms obtained the same result. As for the beam width of the FBS-PN-CSP, this was the minimum value of the tested values, that is, $\beta =5$ for all the instances.

Table A2. Best stock results for binpack1 instances of the falkenauer_U dataset.

		FBS-PN-CSP						G&S						LLA
Instance	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time		Stock	% > lb	Time (s)
u120_00	48	48	5	4	0.00	3.63		48	0.00	66.14	48.00	301.95		50	4.17	0.82
u120_01	49	49	5	2	0.00	3.81		49	0.00	69.35	49.00	387.81		49	0.00	0.31
u120_02	46	46	5	2	0.00	4.13		46	0.00	21.05	46.00	278.44		46	0.00	0.13
u120_03	49	49	5	4	0.00	5.05		49	0.00	66.65	49.00	267.99		50	2.04	0.20
u120_04	50	50	5	2	0.00	3.89		50	0.00	42.77	50.00	309.69		50	0.00	0.64
u120_05	48	48	5	4	0.00	3.99		48	0.00	5.30	48.00	301.55		48	0.00	0.11
u120_06	48	48	15	4	0.00	15.98		48	0.00	60.51	48.00	280.38		48	0.00	0.08
u120_07	49	49	5	2	0.00	4.30		49	0.00	78.09	49.00	338.12		50	2.04	0.31
u120_08	50	50	35	19	0.00	89.01		50	0.00	49.47	50.20	360.79		51	2.00	0.46
u120_09	46	46	15	5	0.00	16.70		46	0.00	5.41	46.00	228.50		47	2.17	0.17
u120_10	52	52	5	4	0.00	4.37		52	0.00	101.61	52.00	346.15		52	0.00	0.61
u120_11	49	49	5	3	0.00	3.72		49	0.00	113.57	49.00	309.34		50	2.04	0.25
u120_12	48	48	15	7	0.00	17.26		48	0.00	11.03	48.00	265.06		48	0.00	0.07
u120_13	49	49	5	2	0.00	4.21		49	0.00	72.02	49.00	286.47		49	0.00	0.08
u120_14	50	50	5	2	0.00	3.90		50	0.00	16.79	50.00	354.72		50	0.00	0.12
u120_15	48	48	5	2	0.00	4.08		48	0.00	14.23	48.00	315.78		48	0.00	0.17
u120_16	52	52	5	2	0.00	3.94		52	0.00	18.84	52.00	212.41		52	0.00	0.40
u120_17	52	52	15	4	0.00	15.45		52	0.00	126.78	52.00	360.08		54	3.85	0.40
u120_18	49	49	5	2	0.00	5.57		49	0.00	85.73	49.00	386.07		49	0.00	0.14
u120_19	49	49	25	15	0.00	46.86		49	0.00	248.72	49.00	421.32		50	2.04	0.22

From the algorithms’ stock results for each instance, the minimum is in boldface.

shows the best stock results for the binpack1 instances of the falkenauer_U dataset, where the FBS-PN-CSP, G&S, and LLA algorithms are compared. The FBS-PN-CSP and the G&S algorithms obtained the optimal theoretical values of each instance, but the FBS-PN-CSP had the best times. The LLA algorithm achieved the optimal theoretical values in 12 out of 20 instances and had better times than the FBS-PN-CSP algorithm. Only in two instances did the FBS-PN-CSP use the higher beam width values (25 and 35), but in most instances, the value was 5, which is the smallest value tested. For the binpack2 instances, the FBS-PN-CSP had the same results as the G&S algorithm in 19 instances (

Table A3. Best stock results for binpack2 instances of the falkenauer_U dataset.

		FBS-PN-CSP						G&S						LLA
Instance	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time		Stock	% > lb	Time (s)
u250_00	99	99	15	6	0.00	33.85		99	0.00	4.26	99.00	228.18		100	1.01	1.73
u250_01	100	100	15	2	0.00	29.94		100	0.00	11.45	100.00	325.27		100	0.00	1.54
u250_02	102	102	15	6	0.00	35.00		102	0.00	7.85	102.00	210.82		102	0.00	1.06
u250_03	100	100	15	8	0.00	44.55		100	0.00	3.51	100.00	244.05		100	0.00	0.79
u250_04	101	101	15	4	0.00	38.23		101	0.00	60.58	101.00	308.18		102	0.99	1.54
u250_05	101	101	25	12	0.00	111.61		101	0.00	32.51	101.00	224.12		102	0.99	0.99
u250_06	102	102	5	5	0.00	10.71		102	0.00	39.23	102.00	266.80		102	0.00	0.97
u250_07	103	104	5	2	0.97	8.56		103	0.00	229.20	103.00	436.35		106	2.91	18.98
u250_08	105	105	15	15	0.00	42.41		105	0.00	125.70	105.00	323.60		106	0.95	1.17
u250_09	101	101	15	3	0.00	36.00		101	0.00	130.38	101.00	269.30		101	0.00	1.42
u250_10	105	105	5	4	0.00	9.29		105	0.00	12.88	105.00	186.12		106	0.95	1.84
u250_11	101	101	15	4	0.00	37.57		101	0.00	90.22	101.00	348.27		101	0.00	0.91
u250_12	105	106	15	4	0.95	36.89		106	0.95	52.65	106.00	275.21		107	1.90	1.69
u250_13	102	103	5	5	0.98	8.73		103	0.98	2.53	103.00	303.67		105	2.94	11.61
u250_14	100	100	5	5	0.00	9.34		100	0.00	61.36	100.00	266.81		100	0.00	1.37
u250_15	105	105	35	11	0.00	208.32		105	0.00	81.33	105.00	323.16		106	0.95	1.84
u250_16	97	97	15	3	0.00	35.66		97	0.00	15.31	97.00	303.89		97	0.00	1.56
u250_17	100	100	5	2	0.00	8.62		100	0.00	21.74	100.00	269.75		100	0.00	2.12
u250_18	100	100	15	14	0.00	39.82		100	0.00	50.33	100.00	232.61		101	1.00	0.95
u250_19	102	102	15	2	0.00	37.07		102	0.00	33.11	102.00	269.78		102	0.00	1.14

From the algorithms’ stock results for each instance, the minimum is in boldface.

), and these were equal to the corresponding optimal theoretical values. All the results of the G&S algorithm were equal to the optimal theoretical value. The LLA algorithm had the optimal theoretical values in half of the instances and the best times among the three algorithms. The FBS-PN-CSP algorithm had better times than the G&S in ten of the instances where they had the same stock result. The beam width was mostly 15 throughout the binpack2 instances. The binpack3 results (

Table A4. Best stock results for binpack3 instances of the falkenauer_U dataset.

		FBS-PN-CSP						G&S						LLA
Instance	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time		Stock	% > lb	Time (s)
u500_00	198	198	25	18	0.00	208.24		198	0.00	9.56	198.00	213.83		200	1.01	38.97
u500_01	201	201	25	25	0.00	204.73		201	0.00	3.34	201.00	218.07		201	0.00	11.38
u500_02	202	202	15	15	0.00	86.07		202	0.00	4.22	202.00	227.23		203	0.50	7.78
u500_03	204	204	25	18	0.00	225.18		204	0.00	17.38	204.00	311.51		206	0.98	17.62
u500_04	206	206	15	5	0.00	80.46		206	0.00	8.85	206.00	135.02		206	0.00	8.72
u500_05	206	206	5	5	0.00	14.90		206	0.00	5.98	206.00	84.34		207	0.49	92.10
u500_06	207	208	15	15	0.48	80.16		207	0.00	11.64	207.00	267.07		209	0.97	145.43
u500_07	204	205	15	14	0.49	75.37		204	0.00	48.52	204.00	274.48		205	0.49	9.92
u500_08	196	197	5	5	0.51	14.51		196	0.00	13.30	196.00	274.11		197	0.51	10.39
u500_09	202	202	15	15	0.00	84.90		202	0.00	10.33	202.00	235.44		203	0.50	18.24
u500_10	200	200	15	5	0.00	75.91		200	0.00	7.73	200.00	155.28		200	0.00	9.01
u500_11	200	200	15	15	0.00	79.07		200	0.00	32.06	200.00	338.97		200	0.00	11.20
u500_12	199	199	15	15	0.00	81.50		199	0.00	13.29	199.00	270.59		199	0.00	8.36
u500_13	196	196	25	24	0.00	183.00		196	0.00	40.66	196.00	224.57		196	0.00	13.95
u500_14	204	204	15	14	0.00	79.55		204	0.00	84.34	204.00	327.05		205	0.49	256.22
u500_15	201	201	15	15	0.00	92.35		201	0.00	5.28	201.00	153.72		201	0.00	15.26
u500_16	202	202	15	4	0.00	76.45		202	0.00	14.52	202.00	259.93		202	0.00	11.55
u500_17	198	198	15	14	0.00	77.82		198	0.00	15.23	198.00	303.33		198	0.00	14.39
u500_18	202	202	15	14	0.00	83.07		202	0.00	4.49	202.00	223.85		202	0.00	10.47
u500_19	196	196	25	24	0.00	175.40		196	0.00	40.97	196.00	283.72		196	0.00	17.06

From the algorithms’ stock results for each instance, the minimum is in boldface.

) show that the G&S algorithm obtained the optimal theoretical values in all instances, and the FBS-PN-CSP algorithm did so in 17 instances. Likewise, the LLA algorithm achieved this in only 11 instances, but with better times than the FBS-PN-CSP and G&S algorithms. Only in the instance u500_14 did the FBS-PN-CSP obtain a better time than the G&S algorithm. The values of the beam width were 15 and 25 in most instances, and the filter value was higher than in the previous groups of instances of the falkenauer_U dataset. Similar results were obtained for the binpack4 instances shown in

Table A5. Best stock results for binpack4 instances of the falkenauer_U dataset.

		FBS-PN-CSP						G&S						LLA
Instance	$\mathit{lb}$	Stock	$\mathit{\beta }$	$\mathit{\alpha }$	% > lb	Time (s)		Stock	% > lb	Time (s)	Avg. Stock	Avg. Time		Stock	% > lb	Time (s)
u1000_00	399	399	25	25	0.00	384.32		399	0.00	33.14	399.00	273.93		399	0.00	233.65
u1000_01	406	406	25	25	0.00	396.57		406	0.00	38.95	406.00	327.19		406	0.00	183.11
u1000_02	411	411	15	14	0.00	157.75		411	0.00	11.72	411.00	235.33		413	0.49	222.21
u1000_03	411	412	15	14	0.24	149.09		411	0.00	33.87	411.00	376.97		414	0.73	1180.83
u1000_04	397	398	15	15	0.25	166.43		397	0.00	14.33	397.00	217.89		398	0.25	131.97
u1000_05	399	399	25	25	0.00	402.64		399	0.00	80.63	399.00	306.18		400	0.25	239.32
u1000_06	395	395	25	25	0.00	411.92		395	0.00	52.29	395.00	261.37		395	0.00	324.66
u1000_07	404	404	25	16	0.00	448.63		404	0.00	17.09	404.00	285.22		405	0.25	157.17
u1000_08	399	399	25	25	0.00	361.70		399	0.00	52.52	399.00	196.93		399	0.00	181.93
u1000_09	397	398	25	25	0.25	422.89		397	0.00	110.50	397.00	275.50		398	0.25	227.06
u1000_10	400	400	25	25	0.00	415.00		400	0.00	34.23	400.00	319.72		401	0.25	244.35
u1000_11	401	401	25	25	0.00	376.47		401	0.00	27.73	401.00	262.44		401	0.00	152.76
u1000_12	393	393	25	5	0.00	383.05		393	0.00	16.95	393.00	268.04		394	0.25	1167.22
u1000_13	396	396	25	25	0.00	389.70		396	0.00	16.50	396.00	248.92		396	0.00	110.01
u1000_14	394	395	15	15	0.25	176.44		394	0.00	30.22	394.00	175.43		395	0.25	199.63
u1000_15	402	403	25	25	0.25	366.57		402	0.00	24.67	402.00	202.19		403	0.25	137.30
u1000_16	404	404	25	25	0.00	361.73		404	0.00	8.34	404.00	177.77		405	0.25	355.25
u1000_17	404	405	15	14	0.25	152.53		404	0.00	39.31	404.00	241.15		405	0.25	240.64
u1000_18	399	399	25	25	0.00	365.81		399	0.00	23.69	399.00	221.26		399	0.00	227.91
u1000_19	400	400	25	18	0.00	412.94		400	0.00	24.85	400.00	232.95		401	0.25	919.10

From the algorithms’ stock results for each instance, the minimum is in boldface.

, where the G&S algorithm outperformed the other two algorithms. In all instances, this algorithm obtained the optimal theoretical value, the FBS-PN-CSP did so in 14 instances, and the LLA algorithm in seven instances, but only with better times than the FBS-PN-CSP. The beam width was mostly higher, namely 25 throughout the instances, as was the filter width. Although in the instances of binpack2, binpack3, and binpack4 the FBS-PN-CSP was not better than the G&S in terms of the number of stocks used, the percentage above the optimal theoretical values was less than 1% with a difference of one stock in all cases.

8. Discussion

It can be observed from the results shown in the previous section that the FBS-PN-CSP algorithm is effective and efficient in most of the instances it was tested in comparison with the other two algorithms, except for the hard10 dataset. The LLA algorithm could only address the instances of the hinterding, binpack1, binpack2, binpack3, and binpack4 datasets. It was less effective than the FBS-PN-CSP but more efficient in those instances where they obtained the same best stock result. A reason for this better efficiency is that to construct the cutting patterns the LLA increases the allowed waste in one unit from one iteration to the next, obtaining the best cutting patterns that meet the waste requirement without considering higher amounts of allowed waste. Meanwhile, the FBS-PN-CSP considers several amounts of waste simultaneously, represented by the pattern transitions. As the stock gets longer and the item types increase, the incidence matrix increases accordingly making the computations slower. This observation can be noted with the hard10 dataset, which has the longest stock among the datasets tested, and a higher number of item types. A modification in the structure of the PN model such as considering one pattern transition per unit of waste like in the LLA algorithm may improve the performance of the FBS-PN-CSP. Contrary to the LLA algorithm, which tests complete cutting patterns for each allowed waste on each iteration impacting its effectiveness as the stock gets longer, the FBS-PN-CSP constructs the solutions adding one item at a time. The algorithm would have to be modified accordingly to consider the different amounts of waste.

Considering the time for the best solution found by the G&S algorithm, the FBS-PN-CSP was more efficient in 50% or more of the instances where both algorithms obtained the same best results for the hinterding, wae_gau1, hard28, binpack1, and binpack2 datasets. Most of the time required by the G&S algorithm is spent on the cutting patterns construction. Then, as the number of items increases the number of cutting patterns also increases. Nevertheless, the G&S algorithm was limited to constructing 1,000,000 cutting patterns for each instance. In contrast, the FBS-PN-CSP only generates cutting patterns considering those partial solutions with the least waste, and discards immediately the worst solutions. It also should be taken into account that the G&S algorithm had a time limit for its execution of 600 s. Except for the hard10 dataset, the FBS-PN-CSP best results were obtained below this time in only one execution. Additionally, the average time from 10 executions of the G&S was longer than the FBS-PN-CSP algorithm and the LLA algorithm in most instances.

The results of the binpack1, binpack2, binpack3, and binpack4 datasets provide us insights into the sensitivity of the beam width and filter width as the number of item types and the number of orders increase while the stock length remains equal. As the number of orders and item types increased, the best solutions were found with the higher tested values for the beam width and the filter width. The reason is that the more item types, the more item places are needed in the PN model. Thus, more solutions need to be evaluated at the first level of the reachability tree, and higher values of beam width and filter width are preferred to evaluate most of those solutions from the second level, but this impacts the efficiency. The proposed improvement for the PN model structure could also be useful to address this efficiency issue since with a smaller incidence matrix size the computations should be faster and the FBS algorithm could be implemented with higher values of beam width and filter width.

From the results of all the tested instances, it is demonstrated that the FBS-PN-CSP could address real-world 1D-CSP problems from small to large number of items. However, the length of the stock impacts its efficiency as shown with the hard10 dataset. It should be remarked that, in instances where the FBS-PN-CSP algorithm does not achieve the best solutions, its results were very close to the best ones and in most cases just by one stock above. Therefore, industries handling stock lengths and item types as those of the hinterding and falkenauer_U datasets could obtain good or optimal cutting plans. Even, the FBS-PN-CSP can yield optimal or near-optimal cutting plans for stock lengths like the ones of hard28 and wae_gau1 datasets in acceptable times. The building industry, the door and window framing industry, and the furniture industry to name a few, could benefit from the FBS-PN-CSP algorithm implementation. These industries usually have several orders, few item types, and not-so-long stocks. However, in industries like the wire industry where the stock length can be extremely long, in the tens of thousands of units, the FBS-PN-CSP could fail to yield cutting plans close to the optimum number of stocks used and in an acceptable time.

9. Conclusions

In this paper, an algorithm based on the modeling power of Petri nets was presented for solving the one-dimensional cutting stock problem (1D-CSP). To the best of our knowledge, Petri nets had not been used to address the 1D-CSP. Firstly, we provided the Petri net general model to construct the solutions of a given instance of the 1D-CSP. Each solution consists of a series of cutting patterns with or without waste. Then, the filtered beam search algorithm is used to search for the best solution throughout the exploration of the nodes of the reachability tree. The algorithm, called FBS-PN-CSP, was compared to the Generate and Solve and the Least Lost algorithms over five datasets with a total of 145 instances and shown to be effective and efficient in most datasets. Therefore, either with instances of low or high complexity, the FBS-PN-CSP is shown to be competitive. However, the efficiency of the FBS-PN-CSP is sensitive to the sock length. In further research, we envisage improving the PN model structure and modifying the algorithm implementation, accordingly, to address this issue. Other research directions may include the beam width and filter width values tuning according to the number of item types to use suitable parameter values for specific features of the instances.