Algorithmic Advances for 1.5-Dimensional Two-Stage Cutting Stock Problem

Abstract

The Cutting Stock Problem (CSP) is an optimization challenge that involves dividing large objects into smaller components while considering various managerial objectives. The problem’s complexity can differ based on factors such as object dimensionality, the number of cutting stages required, and any technological constraints. The demand for coils of varying sizes and quantities necessitates intermediate splitting and slitting stages to produce the finished rolls. Additionally, relationships between orders are affected by dimensional variations at each stage of processing. This specific variant of the problem is known as the One-and-a-Half Dimensional Two-Stage Cutting Stock Problem (1.5-D TSCSP). To address the 1.5-D TSCSP, two algorithmic approaches were developed: the Generate-and-Solve (G&S) method and a hybrid Row-and-Column Generation (R&CG) approach. Both aim to minimize total trim loss while navigating the complexities of the problem. Inspired by existing problems in the literature for simpler versions of the problem, a set of randomly generated test cases was prepared, as detailed in this paper. An implementation of the two approaches was used to obtain solutions for the generated test campaign. The simpler G&S approach demonstrated superior performance in solving smaller instances of the problem, while the R&CG approach exhibited greater efficiency and provided superior solutions for larger instances.

1. Introduction

Many manufacturing processes, including paper rolls, plastic packaging, and metal rolling, involve the production of coils of various sizes and quantities, tailored to meet specific customer demands. The slitting process can be divided into distinct stages, as outlined in Figure 1.

These stages are categorized into two types, splitting and slitting, based on whether semi-finished or finished rolls are produced. This division is required by intermediate conversion processes and the minimum and maximum input widths that slitters can handle, as defined by their technological specifications. Slitting refers to the final cutting of a roll, which exits the production cycle. In contrast, splitting involves cutting an intermediate roll that will be further processed in subsequent stages. A single cutting stage encompasses the process of slicing an input roll, known by various names such as stock object or mill roll, into smaller rolls called items. These items may be narrower or shorter. In this production environment, there exists an additional relationship between stock objects and items: during the splitting phase, intermediate rolls are produced, which serve as finished rolls for the upstream stage and as mill rolls for the downstream stage.

According to the typology proposed in [1] and the refined classification discussed in [2], the development of slitting programs falls within the expansive optimization domain of cutting and packing problems. These problems are fundamentally characterized by two core entities: stock objects that represent input and items that represent demand. Specifically, by integrating dimensionality, assignment, and assortment, this problem can be succinctly represented by the 1.5/V/I/R tuple or as a 1.5-D rectangular SSSCSP. In particular, the assignment of dimensionality in this context deviates from conventional interpretations. As described in [3,4], traditional two-dimensional problems account for width and length as degrees of freedom in the generation of cutting patterns. In contrast, the One-and-a-Half-Dimensional (1.5-D) problem constructs patterns by combining items (or final orders) based on their width, analogous to a one-dimensional problem. However, the number of feasible patterns is constrained by the length of the input rolls. Specifically, the length of a pattern corresponds to the length of the orders cut in that particular combination, and patterns can be generated only until the total length of the input roll is exhausted. Consequently, the second dimension functions partially as a production constraint rather than a degree of freedom in the pattern generation process.

The shapes of both items and objects are rectangular, and their orientation is fixed. As a result, the items must align adjacently, akin to the two-dimensional problem with guillotine cuts in the exact case, but only along their shorter edges. The objective, therefore, is to combine orders in both the transverse and longitudinal directions of the slitter, subject to length constraints. These constraints are intrinsically linked to the availability of stock rolls and the capability to slit rolls of varying lengths within the same setup, which are restricted to a discrete set of predefined values.

Taking into account these factors, this problem can be classified as a One-and-a-Half Two-Stage Cutting Stock Problem (1.5-D TSCSP). The relationships between orders are influenced not only by the transitions between stages but also by the varying lengths within the same stage. The following scenarios may arise:

• Case 1: The first and second stages have the same length. This scenario reduces to a one-dimensional problem, which has been extensively studied in the literature.
• Case 2: Only one length is present in the first stage and only one length at the second stage, but they are different. Each unit of intermediate product must always produce the same number of patterns in the second stage.
• Case 3: Multiple lengths are present in both the first and second stages, which are different and cannot be mixed. In each pattern, the length must be fixed.
• Case 4: Multiple lengths are present in both the first and second stages. Within a single pattern, there can be at most two different lengths, provided that one is an integer multiple of the other.

This study is focused on Case 3, which addresses the intricate challenges associated with managing multiple roll lengths within a Two-Stage cutting process, while maintaining the restriction of non-mixing lengths within individual cutting patterns. The primary objective is to develop and propose solution methodologies capable of efficiently addressing the computational complexity inherent in this problem. In the Two-Stage cutting process, distinct cutting patterns are generated for each stage, as well as for each intermediate order between the first and second stages. These intermediate orders impose constraints on the number of rolls that can be cut, thereby influencing the structure of the cutting patterns. As a result, the problem exhibits combinatorial growth in both the dimension of potential patterns and the dimension of intermediate orders, the latter being indeterminate a priori. Simplified versions of the problem, represented by Cases 1 and 2, can be derived as special instances of Case 3 by imposing additional constraints or relaxing specific complexities. In contrast, Case 4 extends the framework to incorporate advanced technological constraints relevant to specialized manufacturing processes. For example, duplex rewinding, which facilitates the simultaneous processing of a single roll on both sides, introduces operational nuances. However, it does not require significant modifications to the underlying mathematical modeling framework.

In Section 2, a comprehensive review of the key contributions available in the literature is provided, providing context and highlighting the state-of-the-art methodologies relevant to the problem domain. Section 3 offers a formal definition of the problem and situates it within the established classification frameworks discussed in the literature. The proposed solution methodology is elaborated in Section 4, which includes an extension of a foundational approach to address the specific complexities of the case under consideration. Section 5 details the validation of the proposed methodology through an extensive experimental campaign, accompanied by a benchmark for comparative analysis. Lastly, Section 6 consolidates the findings, outlines the objectives achieved, and provides recommendations for future research directions. The subsequent section delineates the structure of the proposed approach, following an overview of the principal insights drawn from the literature.

2. Comprehensive Technical Review of Relevant Literature

A substantial body of literature exists on Cutting Stock Problems (CSPs), encompassing both 1D and 2D scenarios with constrained cutting patterns and diverse objective functions. The following references provide insightful perspectives on the field.

The linear programming approach proposed by [5,6] for one-object and one-stage CSPs is based on column generation, where the pricing problem is solved using dynamic programming. Ref. [7] developed a combined column generation and branch-and-bound algorithm to obtain optimal integer solutions for binary CSPs. Ref. [8] presents a nested decomposition approach for solving a three-stage two-dimensional (2D) CSP with orthogonal guillotine cuts. This method, aimed at minimizing waste and accommodating various industrial constraints, employs a recursive column generation algorithm that provides lower bounds and feasible upper bounds, facilitating potential integration into branch-and-bound for optimal solutions. Ref. [9] solves the 1.5-D assortment problem with multiple objectives using a genetic algorithm, generating cutting patterns with implicit enumeration. Ref. [10] developed an accelerated column generation method by introducing dual-optimal inequalities, reducing the number of column generation iterations and run time. In [11], polylithic solution approaches integrated into an ERP system are developed to address real-world 1D and 2D cutting stock problems in the paper industry, incorporating novel column generation techniques for handling multiple master roll widths, limited stock availability, and underproduction minimization. The enhanced heuristic algorithm in [12] addresses 2D CSPs with constrained and guillotine cutting and multiple stock objects. It is based on a multi-phase genetic algorithm, where the objective function is not the residual area but a modified trim loss equation.

Despite this, the most flexible approach in the literature is that proposed by [13,14], who developed a linear programming model based on the generation of columns for the multi-stage problem. The presence of multiple stages presents the challenge of generating intermediate objects. This challenge has been addressed through a revised separation problem for generating the rows of the constraint matrix, where the rows correspond to the items. However, their focus is typically on minimizing the number of patterns used in the first stage rather than the total trim loss. Refs. [15,16] classify the 1D TSCSP as a Column-Dependent Row (CDR) problem with no interactions. This class of problems is characterized by the presence of so-called linking constraints, which, in the context of CSPs, are associated with the rows corresponding to intermediate orders. These constraints are contained within the connecting matrices of the main constraint matrix. They outlined a simultaneous Row-and-Column generation algorithm based on three assumptions, which correctly price columns in the absence of certain linking constraints and allow for the generation of multiple intermediate orders at a time. In [17], they developed a hybrid algorithm based on a branch-and-price approach, applying a second-level column generation to the row-generating subproblem for the unknown intermediate orders. Importantly, their objective is also to minimize the number of first-stage patterns used, rather than minimizing the total trim loss. Additionally, they made a comparison with Zak’s approach, highlighting the differences in terms of the computational time and solution gap. Ref. [18] tackles a new variant of the Cutting Stock Problem involving two-dimensional skiving and significant setup costs. They consider scenarios where the output sheets are longer but narrower than the input coils, allowing the combination of two or more coils to satisfy the sheet demands. To minimize both material and setup costs, they propose an integer programming formulation characterized by an exponential number of binary variables and column-dependent constraints. Their approach utilizes a Row-and-Column generation framework to solve the linear programming relaxation, involving a knapsack subproblem and a nonlinear integer programming subproblem for which they develop a decomposition-based exact solution method with pseudo-polynomial time complexity.

In [19], the Generate-and-Solve (G&S) framework is implemented for the 1D-CSP, employing a recursive pattern generation procedure structured as a search tree. This tree represents all feasible cutting patterns, where the root node corresponds to the length of the large object, the internal nodes represent the inclusion of specific item types, and the leaf nodes indicate the cut loss. By limiting the tree’s height to the number of different item types and constraining the number of items per type to their respective demands, the method efficiently generates a reduced set of promising patterns. The G&S framework then utilizes an exact solver on these reduced instances, consistently obtaining quasi-optimal solutions across various instance sizes. This approach effectively balances computational efficiency and solution quality, and when integrated with Column Generation techniques, it has the potential to enhance convergence in branch-and-price algorithms, especially when Column Generation alone does not yield high-quality integer solutions.

Recent advancements in cutting and packing optimization encompass a diverse range of settings and methodologies. For instance, ref. [20] presents a linear programming model designed to minimize trim loss in a Make-to-Order paper mill. This model stands out from previous studies by incorporating flexible master reel widths and reusing stocked over-produced and leftover reels to fulfill customer orders. The model explicitly considers operational and technological constraints and employs a post-optimization procedure to ensure integer-feasible solutions with minimal computational effort. Both [21,22] employ iterative strategies based on Column-and-Constraint Generation (C&CG) frameworks to address distinct problems. The approach in [21] is nested and addresses non-convex, bi-level subproblems under complex uncertainties for solving the Two-Stage Robust Optimization model for prosumers considering multiple uncertainties. In contrast, the [22] implementation is more conventional, focusing on container booking decisions with uncertain demands and emphasizing computational efficiency and heuristic initialization. Despite sharing the common objective of iteratively refining the solution space, these techniques fundamentally differ in the complexity of the subproblems and the nature of the constraints introduced at each iteration. Ref. [23] develops a robust optimization model for a Two-Dimensional Strip-Packing Problem characterized by uncertain demands and the availability of multiple strip sizes, employing KKT-based transformations integrated with column generation. Ref. [24] concentrates on rebar cutting operations in reinforced concrete beams, proposing a Two-Stage optimization algorithm to minimize cutting waste and rebar usage. Furthermore, a recent Deep Reinforcement Learning (DRL)-based algorithm proposed by [25] addresses large-scale One-Dimensional Constraint Satisfaction Problems (CSPs) by learning cutting patterns directly from data, achieving high material utilization. Although also addressing a Cutting Stock-type problem, their method is more narrowly tailored to specific industrial constraints and employs heuristic strategies rather than the more general, exact methods prevalent in the literature. These studies underscore the diversity of approaches employed in various cutting and packing environments. While all provide valuable insights, the problem addressed in this paper presents its own unique challenges that necessitate a meticulous adaptation of state-of-the-art methods.

In summary, while numerous studies concentrate on reducing the number of patterns utilized in multi-stage CSPs, this research pursues the objective of minimizing the total trim loss throughout all stages. This objective generalizes the approaches presented by [13,14,17]. This objective is particularly significant for the paper and plastic film industries, where minimizing material waste is of paramount importance. This study seeks to advance these methodologies to address the unique challenges posed by the 1.5-D TSCSP, as previously introduced.

3. Problem Formulation

The addressed problem pertains to a cutting process involving S stages. At each stage s, a set of $m_s$ final orders is generated. Each order is associated with a minimum demand $b_{si}$ for rolls of width $w_{si}$ and length ${\ell }_{si}$. The objective is to determine, for each stage s, the set of $n_s$ cutting patterns ${\mathbf{a}}_{sj}$ and their corresponding quantities $x_{sj}$, such that the trim loss in width ${\gamma }_{sj}$ is greater than or equal to the minimum allowable $t_{min,s}$. Each pattern ${\mathbf{a}}_{sj}$ is a vector consisting of $m_s$ components, where each component i indicates the number of times order i is produced in that cutting pattern. All orders with a positive entry have the same length ${\ell }_{sk}$. Additionally, the intermediate orders k at each stage $s=1,\dots ,S-1$ must be determined through splitting and feeding the subsequent stages $t=s+1,\dots ,S$, specifying their widths $w_{sk}$ within an interval $\left[z_{min,st},z_{max,st}\right]$ and their lengths ${\ell }_{sk}$ selected from a set ${\mathcal{B}}_{st}$ of feasible length ratios. The objective is to minimize the total trim loss ${\sum }_{s=1}^S{\sum }_{j=1}^{n_s}{c}_{sj}{x}_{sj}$, where $c_{sj}$ is the trim area, i.e., the product of the trim width ${\gamma }_{sj}$ and the pattern length ${\ell }_{sk}$. In addition, the first stage is assumed to always use a single mill roll of a fixed width W and unlimited supply, and that for each stage s, there is no initial stock for each intermediate order k; therefore, the total length produced must be greater than or equal to the length consumed by the subsequent stages. For simplicity, final orders are assumed to be present only at the last stage. Afterwards, the problem with only two stages is formulated and the total quantity produced of each intermediate order is forced to be entirely consumed.

The problem stated will be formulated as a Cutting Stock Problem, which is well known to be NP-Hard, where a sufficiently large inventory of single fixed width mill rolls, which serve as input for the first cutting stage, are first split into intermediate stock rolls, and each of them is then slit to produce finished rolls, meeting the minimum demand across all orders. Due to technological constraints, it is not feasible to convert the entire width of the mill roll, resulting in trim loss, which constitutes the primary source of waste in the process. Trim loss is typically divided into two types: fixed and variable. The fixed component is unavoidable and cannot be eliminated, while the variable component depends on the quality of the optimization. In practical applications, treatments are applied to the produced rolls, making the minimization of intermediate orders secondary to the need to minimize trim loss, expressed in units of surface area. This surface area is the product of the pattern length and the trim width, contrasting with the formulation by [13,17], which minimizes the number of first-stage patterns used.

A comprehensive formulation that encapsulates the intricacies of multiple cutting stages is presented in the following section. This extended set-covering approach integrates the interactions between various stages, ensuring that intermediate orders are optimally managed throughout the production flow. In this formulation, a cost coefficient is associated with each cutting pattern, and an integer decision variable represents the number of times each pattern is utilized. The following subsections provide a detailed description of the structure and components of the general Multi-Stage CSP, as well as its specialization to the Two-Stage version. This version will be explored further through the application of the Row-and-Column generation algorithm and an adapted version of the Generate-and-Solve method.

3.1. Multi-Stage Master Problem

Let ${\mathbf{c}}^T={\left(\begin{array}{cccc}{\mathbf{c}}_1^T& {\mathbf{c}}_2^T& \cdots & {\mathbf{c}}_S^T\end{array}\right)}^T$ be the global cost vector, where S is the number of stages. Each ${\mathbf{c}}_s$ for $s=1,\dots ,S$ is the cost vector specific to the s-th stage, with $n_s$ components, where $n_s$ is the number of cutting patterns at the s-th stage.

Similarly, let ${\mathbf{b}}^T={\left(\begin{array}{cccc}{\mathbf{b}}_1^T& {\mathbf{b}}_2^T& \dots & {\mathbf{b}}_S^T\end{array}\right)}^T$ be the global minimum demand vector. Each ${\mathbf{b}}_s$ for $s=1,\dots ,S$ is the minimum demand vector specific to the s-th stage, with $m_s$ components, where $m_s$ is the number of orders at the s-th stage. For the intermediate orders, the demand is set to zero, representing that no minimum quantity needs to be produced beyond consumption.

The global decision variable is the vector ${\mathbf{x}}^T={\left(\begin{array}{cccc}{\mathbf{x}}_1^T& {\mathbf{x}}_2^T& \cdots & {\mathbf{x}}_S^T\end{array}\right)}^T$, where each ${\mathbf{x}}_s$ indicates how many times each pattern at stage s is used in the solution.

The model in matrix form is shown below:

$$\begin{array}{cc}\hfill \mathrm{minimize}& {\mathbf{c}}^T\mathbf{x}\hfill \end{array}$$

(1)

$$\begin{array}{cc}\hfill \mathrm{subject}\mathrm{to}& A\mathbf{x}\ge \mathbf{b}\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill & \mathbf{x}\in {\mathbb{Z}}_{+}^n\hfill \end{array}$$

(3)

Here, $n={\sum }_{s=1}^S{n}_s$ is the total number of cutting patterns across all stages. The constraint matrix A has a special block structure, reflecting the relationships between stages and patterns. Each element $A_{s_1{s}_2}$ is a sub-matrix of dimensions $m_{s_1}\times n_{s_2}$, with $s_1,s_2=1,\dots ,S$.

$$A=\left(\begin{array}{cccc}{A}_{11}& A_{12}& \cdots & A_{1S}\\ A_{21}& A_{22}& \cdots & A_{2S}\\ ⋮& ⋮& \ddots & ⋮\\ A_{S1}& A_{S2}& \cdots & A_{SS}\end{array}\right)$$

(4)

The matrices $A_{s_1{s}_2}$ represent the interactions between orders at stage $s_1$ and patterns at stage $s_2$. Specifically, these are as follows:

• The diagonal blocks $A_{ss}$ for $s=1,\dots ,S$ are the canonical cutting stock matrices for the s-th stage. Each column in $A_{ss}$ corresponds to a cutting pattern at stage s, and each row corresponds to an order at that stage. The element ${A_{ss}}_{ij}$ indicates the quantity of order i produced by pattern j.
• The off-diagonal blocks $A_{s_1{s}_2}$ for $s_1\ne s_2$ represent the consumption of intermediate stock rolls between stages. These blocks are called connection matrices. For $s_1<s_2$, $A_{s_1{s}_2}$ captures the consumption of stock rolls from stage $s_1$ by patterns at stage $s_2$.

Each column in a connection matrix $A_{s_1{s}_2}$ represents a pattern at stage $s_2$, and each element indicates the consumption of an intermediate roll from order i at stage $s_1$ by pattern j at stage $s_2$. This consumption is quantified by $-{\delta }_{ij}$, where ${\delta }_{ij}$ is the fraction of the intermediate roll consumed by one use of pattern j. For example, if the intermediate roll from order i at stage 1 has a length of ${\ell }_{1,i}=8000$ m, and a pattern j at stage 2 produces rolls of length ${\ell }_{2,j}=2000$ m, then the consumption is ${\delta }_{ij}={\displaystyle \frac{{\ell }_{2,j}}{{\ell }_{1,i}}}=0.25$. This means that four uses of pattern j are necessary to consume an entire intermediate roll from order i. Let the length ratio be ${\beta }_{ij}={\displaystyle \frac{{\ell }_{1,i}}{{\ell }_{2,j}}}={\displaystyle \frac{1}{{\delta }_{ij}}}$. This ratio indicates how many times a pattern at the downstream stage can be applied to fully consume an intermediate roll from the upstream stage.

Without loss of generality, let $A_{s_1{s}_2}=\mathbf{0}$ when $s_1>s_2$, because conversion flows from downstream to upstream are not practical and are not permitted due to possible treatments applied to the items. This block structure of the constraint matrix allows us to capture the material flow and dependencies between stages in the multi-stage CSP. The decision variables $\mathbf{x}$ and the constraints $A\mathbf{x}\ge \mathbf{b}$ ensure that customer demands are met, intermediate stock roll consumption is properly accounted for, and the overall trim loss is minimized through the objective function ${\mathbf{c}}^T\mathbf{x}$. This approach also allows us to incorporate the possibility of having items of different lengths within the same pattern, accommodating the complexities of the 1.5-D TSCSP, described in the next section.

3.2. Two-Stage Master Problem

The previous model represents the most general case, which can be easily adapted to the two-stage version. In this case, the master problem formulated using the matrix form becomes as follows:

$$\begin{array}{ccc}\hfill \mathrm{minimize}& {\mathbf{c}}_1^T{\mathbf{x}}_1+{\mathbf{c}}_2^T{\mathbf{x}}_2\hfill & \end{array}$$

(5)

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

(6)

$$\begin{array}{c}{A}_{11}{\mathbf{x}}_1+A_{12}{\mathbf{x}}_2=\mathbf{0}\hfill \end{array}$$

(7)

$$\begin{array}{c}{A}_{22}{\mathbf{x}}_2\ge {\mathbf{b}}_{\mathbf{2}}\hfill \end{array}$$

(8)

$$\begin{array}{c}{\mathbf{x}}_1\ge \mathbf{0},\mathrm{integer}\hfill \end{array}$$

(9)

$$\begin{array}{c}{\mathbf{x}}_2\ge \mathbf{0},\mathrm{integer}\hfill \end{array}$$

(10)

In this formulation, note that the demand vector for the first stage, ${\mathbf{b}}_1$, is set to zero. This is because the intermediate orders produced at the first stage must be entirely consumed at the second stage; partial consumption would result in significant waste and logistical issues due to leftovers. Therefore, a set partitioning constraint is enforced at the first stage (7) to ensure that all intermediate stock produced is fully utilized, while at the second stage, a set covering constraint (8) is enforced to meet the customer demands for finished rolls. A schedule with the least number of different intermediate sizes is most desirable, as it minimizes both complexity and waste in the production process.

The difficulty in solving this model derives from the multitude of unknown cutting patterns and intermediate stock orders, corresponding to the columns and rows of A matrix, respectively. Generating the entire matrix is impractical because the number of cutting patterns grows exponentially with the number of orders.

4. Solution Approach

In CSPs, as the number of orders increases, the cutting patterns—and thus the number of variables—grow exponentially. This exponential growth poses significant computational challenges, making it impractical to generate all possible cutting patterns (columns of the coefficient matrix A) in advance, especially for large-scale problems. For this reason, the model is initialized with a short and restricted coefficient matrix A consisting of only a minimal number of columns necessary to ensure feasibility. Additional columns (cutting patterns) and rows (intermediate orders) are then iteratively generated only when they have the potential to reduce the objective function value.

Initially, $A_{11}$ is constructed as an identity matrix, where each column corresponds to a first-stage cutting pattern that produces exactly one unit of an intermediate order. This means that each cutting pattern at the first stage cuts exactly one intermediate roll, and $A_{11}$ is a diagonal matrix with ones on the diagonal. For $A_{22}$, a pattern for each second-stage order that is compatible with the existing intermediate orders based on admissible length ratios is created. Specifically, for each intermediate roll $i_1$ and each second-stage order $i_2$ where the length ratio ${\beta }_{i_1{i}_2}={\displaystyle \frac{{\ell }_{1,i_1}}{{\ell }_{2,i_2}}}$ is admissible and integer, a second-stage cutting pattern that produces exactly one unit of order $i_2$ using intermediate roll $i_1$ is created.

The coefficient matrix is initialized with an intermediate order for each feasible first stage length with width equal to the maximum value. For this reason, the problem is referred to as short, indicating that the number of rows is less than the total number possible. Just as columns (cutting patterns) are dynamically generated when needed, the rows—representing the intermediate orders—are also generated on demand. This process occurs concurrently with the creation of a first-stage cutting pattern that includes the new intermediate order with a non-zero coefficient and a second-stage cutting pattern that consumes units of this intermediate order. The objective is to reduce the value of the objective function, i.e., the total trim loss measured as surface, by introducing these new rows and associated cutting patterns when they have the potential to improve the solution.

4.1. Generate-and-Solve Algorithm

In this section, the implementation of the Generate-and-Solve (G&S) framework applied to the 1.5-D TSCSP is presented. The proposed approach adapts the traditional G&S method, originally designed for one-dimensional CSPs [19], to address the additional complexities introduced by the multi-dimensional and multi-stage nature of the problem, such as the rolls produced in the first stage that serve as input for the second stage.

Our algorithm operates by alternating between two primary phases:

• Pattern Generation Iterations: In this phase, the algorithm focuses on generating new cutting patterns for both the first and second stages without altering the set of intermediate orders. The goal is to improve the current solution by exploring new combinations of existing orders.
• Order Generation Iterations: When pattern generation no longer yields significant improvements, the algorithm transitions to this phase, where new intermediate orders are introduced. By expanding the set of intermediate orders, the solution space gets enlarged, allowing for potentially better solutions that were not possible with the previous set of orders.

At each iteration, a Relaxed Short and Restricted Master Problem (RSRMP) is solved, which includes only a limited set of cutting patterns and intermediate orders, making it computationally feasible to solve repeatedly within the iterative framework. The algorithm initializes with an initial set of existing first-stage and second-stage patterns and intermediate orders. Each cutting pattern has an associated countdown integer value, which determines its lifespan in the algorithm based on recent usage. Patterns that are not utilized in recent iterations are gradually phased out through the aging mechanism to maintain computational efficiency and prevent the model from becoming too large.

Dedicated pattern generators for the first and second stages are responsible for creating new patterns when needed. These pattern generators utilize a lexicographic search tree to systematically explore potential patterns. A priority queue manages the exploration of the pattern generation trees, prioritizing nodes based on their potential to improve the solution. Each node in the search tree represents a partial pattern, containing information about the currently used width, the level in the tree, the remaining width, and the set of remaining orders that can be added to the pattern, determined by lexicographic ordering and feasibility based on residual width. Nodes are prioritized based on trim loss, ensuring a depth-first exploration. When generating child nodes, feasible orders are added to the current pattern, respecting width constraints, one unit at a time. The remaining width is updated accordingly, and the set of remaining orders is adjusted to consider only orders that have not yet been included and fit within the residual width.

In the order generation iterations, the algorithm introduces new intermediate orders to expand the solution space. This is a significant difference from the standard G&S method, which typically does not alter the set of items (orders) but focuses on pattern generation. The algorithm identifies inefficient second-stage patterns that contribute most to trim loss and negatively impact the objective function. Based on these patterns, new intermediate orders are created with dimensions designed to reduce waste. The pattern generators are then updated to include these new intermediate orders, allowing the generation of new patterns that incorporate them. When a new intermediate order is introduced, it is added to the leftmost branch of the search tree with maximum priority to ensure it is explored promptly in subsequent iterations. The pseudocode for the Generate-and-Solve algorithm is presented in Algorithm 1.

The algorithm employs several parameters to control its execution:

• PatternGenIter: A boolean flag indicating whether the current iteration is a pattern generation iteration (True) or an order generation iteration (False).
• PatternGenAttempts and OrderGenAttempts: Counters for the remaining attempts in each phase before switching or terminating. These are initialized to a maximum value (MaxAttempts).
• UpdateLimit: A predefined threshold for considering an iteration successful, based on the relative improvement in the objective function.

At each iteration, after solving the RSRMP, the algorithm evaluates the improvement in the objective value. If the improvement exceeds UpdateLimit, the iteration is considered successful, and the corresponding attempt counter is reset. If not, the attempt counter is decremented. When the attempt counter reaches zero, the algorithm switches phases or terminates if both counters reach zero.

To manage the size of the RSRMP and maintain computational efficiency, the countdown value for the patterns used in the current solution is increased by 1, reinforcing their relevance in future iterations; instead, for the unused patterns, this is decremented by 1.Patterns with a countdown value of 0 are removed from the coefficients matrix A. Orders that no longer have associated patterns are also removed.

By iteratively refining the set of patterns and intermediate orders considered in the RSRMP, the algorithm converges to high-quality solutions without the need to enumerate all possible combinations upfront. The ability to dynamically introduce new intermediate orders allows the algorithm to escape local optima and explore a broader solution space than methods that only generate patterns.

Algorithm 1: Generate-and-Solve Generation Algorithm.

1: Construct initial RSRMP   2: $\mathrm{OptimalObj}\leftarrow +\infty$   3: $\mathrm{Improvement}\leftarrow 0$   4: $\mathrm{PatternGenIter}\leftarrow \mathrm{True}$   5: $\mathrm{PatternGenAttempts}\leftarrow \mathrm{MaxAttempts}$   6: $\mathrm{OrderGenAttempts}\leftarrow \mathrm{MaxAttempts}$   7: while True do   8:       Solve RSRMP   9:       Update CurrentObj 10:       $\mathrm{Improvement}\leftarrow 1-{\displaystyle \frac{\mathrm{CurrentObj}}{\mathrm{OptimalObj}}}$ 11:       if PatternGenIter then 12:             if $\mathrm{Improvement}\le \mathrm{UpdateLimit}$ then 13:                    $\mathrm{PatternGenAttempts}\leftarrow \mathrm{PatternGenAttempts}-1$ 14:                    if $\mathrm{PatternGenAttempts}=0$ then 15:                          $\mathrm{PatternGenIter}\leftarrow \mathrm{False}$ 16:                    end if 17:             else 18:                    $\mathrm{PatternGenAttempts}\leftarrow \mathrm{MaxAttempts}$ 19:             end if 20:       else 21:             if $\mathrm{Improvement}\le \mathrm{UpdateLimit}$ then 22:                    $\mathrm{OrderGenAttempts}\leftarrow \mathrm{OrderGenAttempts}-1$ 23:                    if $\mathrm{OrderGenAttempts}=0$ then 24:                          break 25:                    end if 26:             else 27:                    $\mathrm{OrderGenAttempts}\leftarrow \mathrm{MaxAttempts}$ 28:                    $\mathrm{PatternGenAttempts}\leftarrow \mathrm{MaxAttempts}$ 29:                    $\mathrm{PatternGenIter}\leftarrow \mathrm{True}$ 30:             end if 31:     end if 32:     if PatternGenIter then 33:             Update pattern usage counters 34:             Remove obsolete column(s) from RSRMP 35:             Remove rows with no linking constraints from RSRMP 36:             Generate and Add column(s) to RSRMP 37:     else 38:             Select worst second-stage pattern 39:             Generate and Add new row to RSRMP 40:             Generate and Add column(s) to RSRMP 41:     end if 42: end while

The advantages of this approach are manifold:

• Algorithm Efficiency It mitigates combinatorial explosion by restricting patterns and orders, and using a countdown mechanism to remove unused patterns.
• Computational Resource Allocation Priority-based exploration ensures efficient allocation of resources, focusing on patterns with the highest potential for improvement.
• Solution Quality Improvement Flexibility to introduce new intermediate orders allows the algorithm to navigate the solution space more effectively, overcoming local optima.

Figure 2 illustrates the lexicographic search tree used for pattern generation, incorporating priorities to guide the search towards the most promising patterns.

4.2. Row-and-Column Generation Algorithm

There is a rich body of literature available on Cutting Stock Problems, dealing with both one-dimensional and two-dimensional cases, where Column Generation is employed. It starts with the Relaxed and Restricted Master Problem (RRMP), where each diagonal block is initialized with a small subset of cutting patterns and the decision variables are real values. The idea is to generate the least number of patterns necessary for the optimal solution. This approach is based on the iterative resolution of the Relaxed and Restricted Master Problem (RRMP) and an auxiliary model called the Pricing Subproblem (PSP), which has the form of a knapsack problem. The first dynamic approach for classic CSP was proposed by [5,6] and can be extended to the case of two stages when the intermediate stock rolls are already known. In that case, a Column Generation algorithm that comprises two auxiliary models, each related to a specific cutting stage, is sufficient.

If intermediate rolls are unknown in advance, a more complicated situation must be addressed. Any suitable intermediate width z from a given range of intermediate roll widths $\left[z_{min},z_{max}\right]$ can be picked. Since every intermediate roll and finished roll is associated with a row of the LP matrix, generating all the feasible intermediate orders whose widths fall within that interval would cause the problem to expand in both directions: columns and rows. Hence, the application of the Column Generation algorithm falls short since it would not take into account the dual variables of the missing intermediate rolls, and the potentially huge number of intermediate rolls precludes generating all the possible cutting patterns beforehand. Refs. [13,14,17] proposed a Row-and-Column Generation (R&CG) algorithm for the One-Dimensional Two-Stage Cutting Stock Problem (1D-TSCSP), which starts from a Relaxed Short and Restricted Master Problem (RSRMP)—an initial model that limits not only the number of decision variables (columns) but also the number of constraints (rows)—and is based on three types of auxiliary subproblems. Specifically, the first auxiliary subproblem generates the cutting patterns for the first stage (columns of $A_{11}$), the second generates the cutting patterns for the second stage (columns of $A_{22}$), and the third simultaneously generates new intermediate rolls and their associated cutting patterns. This third subproblem involves adding new rows (representing intermediate orders) to the matrices $A_{11}$ and $A_{22}$, and new columns to $A_{11}$, $A_{12}$, and $A_{22}$. It requires generating at least one pattern at the first stage that includes the new intermediate orders and a pattern at the second stage that consumes them.

In this section, an adapted version of the Row-and-Column Generation algorithm proposed by [15] tailored to the One-and-Half-Dimensional problem is presented.

At each iteration, the dual problem of the restricted problem is solved. The dual problem is advantageous in CSPs because it typically has fewer variables than the primal problem—the number of dual variables corresponds to the number of orders, which is a fixed quantity, where ${\mathbf{u}}_1$ and ${\mathbf{u}}_2$ are the dual variables associated with the first and second stage constraints, respectively.

$$\begin{array}{ccc}\hfill \mathrm{maximize}& {\mathbf{b}}_2^T{\mathbf{u}}_2\hfill & \end{array}$$

(11)

$$\begin{array}{cc}\hfill \mathrm{subject}\mathrm{to}& \end{array}$$

(12)

$$\begin{array}{c}{A}_{11}^T{\mathbf{u}}_1\le {\mathbf{c}}_{\mathbf{1}}\hfill \end{array}$$

(13)

$$\begin{array}{c}{A}_{12}^T{\mathbf{u}}_1+A_{22}^T{\mathbf{u}}_2\le {\mathbf{c}}_{\mathbf{2}}\hfill \end{array}$$

(14)

$$\begin{array}{c}{\mathbf{u}}_1\in {\mathbb{R}}^{m_1}\hfill \end{array}$$

(15)

$$\begin{array}{c}{\mathbf{u}}_2\in {\mathbb{R}}_{+}^{m_2}\hfill \end{array}$$

(16)

Note that ${\mathbf{u}}_1$ is unrestricted in sign due to the equality constraints in the first stage, and ${\mathbf{u}}_2\ge \mathbf{0}$ corresponds to the inequality constraints in the second stage. Observe that since each row of the matrix $A_{12}^T$ has only a single non-zero component, the constraint corresponding to each second-stage pattern j simplifies to $-{\delta }_{kj}{u}_{1k}+{\sum }_{i=1}^{m_2}{u}_{2i}{A_{22}}_{ij}\le c_{2j}$, where k is the index of the intermediate order from which pattern j is produced and ${\delta }_{kj}$ is the inverse of the length ratio.

Let ${u_1^{★}}_i$ for $i=1,\dots ,m_1$ and ${u_2^{★}}_i$ for $i=1,\dots ,m_2$ be the optimal dual prices for first and second stage, respectively. To determine whether there exists a constraint, i.e., cutting pattern, not present in the restricted problem that is violated by the current solution, a maximization problem known as the Pricing Subproblem (PSP) must be solved for each stage and subset of compatible orders.

As illustrated in Algorithm 2, the procedure encompasses three distinct types of Pricing Subproblems (PSPs):

• First-Stage Pricing Subproblem (1S-CG-PSP): searches for a new column ${\mathbf{a}}_{\mathbf{1}}$ of $A_{11}$ that have negative reduced costs with respect to the current set of constraints in the Relaxed Restricted Master Problem (RSRMP).
• Second-Stage Pricing Subproblem (2S-CG-PSP): searches for a new column ${\mathbf{a}}_{\mathbf{2}}$ of $A_{22}$ that have negative reduced costs with respect to the current set of constraints in the Relaxed Restricted Master Problem (RSRMP).
• Row-Generating Pricing Subproblem (RCG-PSP): searches for new intermediate orders (rows) and their associated columns ${\mathbf{a}}_{\mathbf{1}}$ and ${\mathbf{a}}_{\mathbf{2}}$ for $A_{11}$, $A_{22}$ and $A_{12}$.

Algorithm 2: Row-and-Column Generation Algorithm.

1: FLAG ← 1   2: Construct initial RSRMP   3: Solve RSRMP   4: while True do                       ▹ first-stage-pricing   5:       for $L_1$ in First Stage Lengths do   6:             Solve 1S-CG-PSP   7:       end for   8:       if A negatively priced column exists then   9:             FLAG ← 1 10:             Add column(s) to RSRMP 11:             Solve RSRMP 12:       else 13:             FLAG ← 0 14:             while True do                   ▹ second-stage-pricing 15:                   for intermediate order k in Intermediate Orders do 16:                         for $L_2$ in Second Stage Feasible Lengths do 17:                               Solve 2S-CG-PSP 18:                         end for 19:                   end for 20:                   if A negatively priced column exists then 21:                         FLAG ← 1 22:                         Add column(s) to RSRMP 23:                         Solve RSRMP 24:                   else 25:                         break 26:                   end if 27:           end while 28:           if FLAG = 0 then 29:                   while True do                    ▹ row-generating 30:                         for $L_1$ in First Stage Lengths do 31:                               for $L_2$ in Second Stage Feasible Lengths do 32:                                     for ${\alpha }^{★}$ in $1,\dots ,{\displaystyle \frac{w_0-t_{min,1}}{z_{min}}}$ do 33:                                           Solve RCG-PSP 34:                                     end for 35:                               end for 36:                         end for 37:                         if A negatively priced column exists then 38:                               FLAG ← 1 39:                               Add column(s)/row(s) to RSRMP 40:                               Solve RSRMP 41:                         else 42:                               break 43:                         end if 44:                   end while 45:                   if FLAG = 0 then 46:                         break 47:                   end if 48:           else 49:                   continue 50:           end if 51:       end if 52: end while

The algorithm begins by repeatedly solving 1S-CG-PSP. Once no additional first-stage columns can be generated, 2S-CG-PSP is solved to identify new second-stage columns following a similar iterative approach. If neither of the CG-PSPs yield new columns given the current intermediate orders, RCG-PSP is employed. This subproblem potentially introduces both new rows and related columns into the RSRMP. After solving a Pricing Subproblem with at least a negatively priced column, the algorithm returns to the 1S-CG-PSP because the dual variables may have changed due to the addition of new constraints and variables. The algorithm terminates when, in the same iteration, all PSPs do not produce any negatively priced columns—this is indicated when the FLAG variable remains zero.

Addressing Case 3 as presented in the introduction, it is necessary to partition the orders at each stage into multiple Pricing Subproblems. Each PSP consists of orders that share the same length within the same stage and have the same length ratio between different stages. This partitioning ensures compatibility among the orders within each PSP and allows us to effectively apply the Row-and-Column Generation algorithm.

4.2.1. First-Stage Column-Generating PSP

The aim of the first-stage Column Generation Pricing Subproblem (1S-CG-PSP) is to find a negatively priced column ${\mathbf{a}}_1$ for the first stage. For each distinct first-stage length $L_1$, the following optimization problem is solved:

$$\begin{array}{c}\hfill \mathrm{maximize}\sum _{i=1:{\ell }_{1i}=L_1}^{m_1}{u}_{1i}^{★}{a}_{1i}-{\gamma }_1{L}_1\end{array}$$

(17)

$$\mathrm{subject} \mathrm{to}$$

$$\begin{array}{cc}& {\gamma }_1=w_0-\sum _{i=1:{\ell }_{1i}=L_1}^{m_1}{w_1}_i{a_1}_i\hfill \end{array}$$

(18)

$${\gamma }_1\ge t_{min,1}$$

(19)

$${a_1}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_1:{\ell }_{1i}=L_1$$

(20)

Here, $a_{1i}$ is the decision variable representing the quantity of the i-th order of the first stage with length ${\ell }_{1i}=L_1$ and width ${w_1}_i$ included in the cutting pattern. ${u_1^{★}}_i$ is the optimal dual variable obtained from the current RSRMP. $w_0$ is the width of the input roll at the first stage, $t_{min,1}$ is the minimum allowable trim loss and ${\gamma }_1$ represents the actual trim loss in the cutting pattern. Equation (17) tries to maximize the reduced cost of a potential new first-stage cutting pattern, where the cost associated is calculated as the product of the trim loss and the pattern length.

If the optimal value is strictly positive, a new first-stage cutting pattern is generated, defined as ${{\mathbf{a}}_1^T}^{★}={\left(\begin{array}{ccc}{a}_{11}& \dots & a_{1m_1}\end{array}\right)}^T$. The generated column ${{\mathbf{a}}_1}^{★}$ is then added to the coefficient matrix A, as follows. By adding the new column, the cost vector ${\mathbf{c}}_1^T={\left(\begin{array}{cccc}{c}_{11}& \dots & c_{1n_1}& {\gamma }_1{L}_1\end{array}\right)}^T$ and the ${\mathbf{x}}_1$ are also expanded with a new decision variable for the new pattern.

$$A=\left(\begin{array}{ccc}{A}_{11}& {{\mathbf{a}}_1}^{★}& A_{12}\\ O& \mathbf{0}& A_{22}\end{array}\right)$$

(21)

4.2.2. Second-Stage Column-Generating PSP

The aim of the second-stage Column Generation Pricing Subproblem (2S-CG-PSP) is to find a negatively priced column ${\mathbf{a}}_2$ for the second stage. For each intermediate order k and for each distinct second-stage length $L_2$, the following optimization problem is solved:

$$\begin{array}{c}\hfill \mathrm{maximize}\sum _{i=1:{\ell }_{2i}=L_2}^{m_2}{u}_{2i}^{★}{a}_{2i}-{\gamma }_2{L}_2\end{array}$$

(22)

$$\mathrm{subject} \mathrm{to}$$

$$\begin{array}{c}{\gamma }_2=w_{1k}-\sum _{i=1:{\ell }_{2i}=L_2}^{m_2}{w}_{2i}{a_2}_i\hfill \end{array}$$

(23)

$${\gamma }_2\ge t_{min,2}$$

(24)

$${a_2}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_2:{\ell }_{2i}=L_2$$

(25)

Here, $a_{2i}$ is the decision variable representing the quantity of the i-th order of the second stage with length ${\ell }_{2i}=L_2$ and width $w_{2i}$ included in the cutting pattern. ${u_2^{★}}_i$ is the optimal dual variable obtained from the current RSRDP. $w_{1k}$ is the width of the intermediate order k, $t_{min,2}$ is the minimum allowable trim loss, and ${\gamma }_2$ represents the actual trim loss in the cutting pattern.

If the optimal value is greater than $u_{1k}^{★}{\displaystyle \frac{L_2}{{\ell }_{1k}}}$, a new second-stage cutting pattern is generated, defined as ${{\mathbf{a}}_2^T}^{★}={\left(\begin{array}{ccc}{a}_{21}& \dots & a_{2m_2}\end{array}\right)}^T$. The generated column ${{\mathbf{a}}_2}^{★}$ is then added to the coefficient matrix A as follows. By adding the new column, the cost vector ${\mathbf{c}}_2^T={\left(\begin{array}{cccc}{c}_{21}& \dots & c_{2n_2}& {\gamma }_2{L}_2\end{array}\right)}^T$ and the ${\mathbf{x}}_2$ are also expanded with a new decision variable for the new pattern.

$$A=\left(\begin{array}{ccc}{A}_{11}& A_{12}& \omega \\ O& A_{22}& {{\mathbf{a}}_2}^{★}\end{array}\right)$$

(26)

Here, ${\omega }^T={\left(\begin{array}{c}0,\dots ,-{\displaystyle \frac{L_2}{{\ell }_k}},\dots ,0\end{array}\right)}^T$ is a column vector added to $A_{12}$, representing the linking coefficients due to the consumption of the intermediate order k.

4.2.3. Row-Generating PSP

The Row-Generating Pricing Subproblem (RCG-PSP) aims to identify new intermediate rolls as new rows and their associated cutting patterns as new columns that, when added to the RSRMP, expand the feasible solution space and enhance the likelihood of achieving optimality.

In the context of the 1.5-D TSCSP, the Row-Generating PSP is particularly challenging due to four main reasons:

• The lengths of the intermediate rolls are unknown, as are their widths.
• The dual variables associated with these new intermediate rolls are not known in advance, except that they are non-negative in any feasible dual solution. These dual variables must be accurately estimated to effectively incorporate them into the solution of the row-generating PSP effectively.
• Multiple second-stage cutting patterns can be produced from a single intermediate roll.
• Multiple intermediate rolls may need to be generated simultaneously.

To address the first challenge, only one first-stage length $L_1$ is considered at a time. Considering Case 3 as presented in the introduction, all intermediate orders generated in the same first-stage pattern must have the same length $L_1$. However, it is not necessary for patterns cut from different intermediate rolls to have the same length.

Regarding the estimation of the dual variables for the intermediate orders, the complementary slackness condition from linear programming duality theory can be used. When generating second-stage patterns that reduce the total trim loss—that is, the objective function value of the RSRMP—then the corresponding dual variable for the intermediate roll will take a strictly positive value. This implies that the corresponding dual constraint is tight, i.e., satisfied with equality. Consider an intermediate roll k and a second-stage cutting pattern j. The corresponding dual constraint from the dual problem is $-{u_1}_k{\delta }_{kj}+{\sum }_{i=1}^{m_2}{u_2}_i{A_{22}}_{ij}\le {c_2}_j$. If the constraint is forced to be tight and ${c_2}_j={{\gamma }_2}_j{L}_2$, where ${{\gamma }_2}_j$ represents the trim loss for pattern j, and ${\delta }_{ij}={\displaystyle \frac{L_2}{{{\ell }_1}_k}}$, where $L_2$ is the length of the second-stage pattern j, then the dual constraint can be rearranged to solve for ${u_1}_k$: ${u_1}_k=-{{\gamma }_2}_j{{\ell }_1}_k+{\displaystyle \frac{{\ell }_k}{L_2}}{\sum }_{i=1}^{m_2}{u_2}_i{A_{22}}_{ij}$.

This consideration is closely related to the third challenge. Since the dual variables ${u_2}_i$ for $i=1,\dots ,m_2$ are positive, as they are associated with demand constraints in the second stage, and the coefficients ${A_{22}}_{ij}$ are non-negative, representing quantities of orders in patterns, each term ${u_2}_i{A_{22}}_{ij}$ is positive. Therefore, to generate a new intermediate roll with a negatively priced column, it suffices to consider the second-stage pattern that maximizes ${\sum }_{i=1}^{m_2}{u_2}_i{A_{22}}_{ij}$. This means that is sufficient to consider a single second-stage cutting pattern for each new intermediate order.

The Row-Generating PSP is formulated for each combination of first-stage length $L_1$ and second-stage length $L_2$, such that their ratio is feasible.

$$\begin{array}{cc}\hfill \mathrm{maximize}\sum _{i=1:{{\ell }_1}_i=L_1}^{m_1}{u}_{1i}^{★}{a}_{1i}+\sum _{k=1:{{\ell }_1}_k=L_1}^K{v}_k^{★}{\alpha }_k-{\gamma }_1{L}_1& \end{array}$$

(27)

$$\mathrm{subject} \mathrm{to}$$

$$\begin{array}{c}{\gamma }_1=w_0-\sum _{i=1:{{\ell }_1}_i=L_1}^{m_1}{w_1}_i{a_1}_i-\sum _{k=1:{{\ell }_1}_k=L_1}^K{z}_k{\alpha }_k\hfill \end{array}$$

(28)

$${\gamma }_1\ge t_{min,1}$$

(29)

$${a_1}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_1:{{\ell }_1}_i=L_1$$

(30)

$${\alpha }_k\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall k=1,\dots ,K$$

(31)

$$z_{min}\le z_k\le z_{max},\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall k=1,\dots ,K$$

(32)

where

$$\begin{array}{cc}\hfill v_k^{★}=\max \sum _{i=1:{{\ell }_2}_i=L_2}^{m_2}{u}_{2i}^{★}{a_{2k}}_i-{\gamma }_{2k}{L}_1& \end{array}$$

(33)

$$\mathrm{subject} \mathrm{to}$$

$$\begin{array}{c}{\gamma }_{2k}=z_k-\sum _{i=1:{{\ell }_2}_i=L_2}^{m_2}{w_2}_i{a_{2k}}_i\hfill \end{array}$$

(34)

$${\gamma }_{2k}\ge t_{min,2}$$

(35)

$${a_{2k}}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_2:{{\ell }_2}_i=L_2$$

(36)

$$z_{min}\le z_k\le z_{max},\mathrm{integer}$$

(37)

Here, ${\alpha }_k$ is the decision variable corresponding to the number of times the new intermediate order k is included in the first-stage cutting pattern and $z_k$ its width. ${\gamma }_1$ and ${{\gamma }_2}_k$ represent the trim losses at the first and second stages.

The new columns and rows generated are incorporated into the RSRMP’s coefficient matrix A as follows:

• ${{\mathbf{a}}_1}^{★}$ is the new column corresponding to the first-stage cutting pattern.
• ${{\mathbf{a}}_2}_k^{★}$ is the new column corresponding to the second-stage cutting pattern produced from intermediate order k.
• ${\alpha }_k^{★}$ is included to account for the number of times the intermediate order k is used in the newly created first-stage cutting pattern.
• $-{\displaystyle \frac{{{\ell }_2}_k}{L_1}}$ s the non-zero term placed at the position corresponding to the intermediate order k in the linking constraint row.

$$A=\left(\begin{array}{cccccc}{A}_{11}& {{\mathbf{a}}_1}^{★}& A_{12}& \mathbf{0}& \cdots & \mathbf{0}\\ {\mathbf{0}}^T& {\alpha }_1^{★}& {\mathbf{0}}^T& -{\displaystyle \frac{{{\ell }_2}_1}{L_1}}& \cdots & 0\\ ⋮& ⋮& ⋮& ⋮& \ddots & ⋮\\ {\mathbf{0}}^T& {\alpha }_K^{★}& {\mathbf{0}}^T& 0& \cdots & -{\displaystyle \frac{{{\ell }_2}_K}{L_1}}\\ O& \mathbf{0}& A_{22}& {{\mathbf{a}}_2}_1^{★}& \cdots & {{\mathbf{a}}_2}_K^{★}\end{array}\right)$$

(38)

Regarding the fourth challenge, although multiple intermediate rolls may need to be generated simultaneously, the problem can be simplified by generating one intermediate roll at a time. This approach, inspired by Zak’s simplification [13], reduces the computational complexity and has been shown to be effective in practice [17]. By focusing on generating a single intermediate roll per iteration, a unified mathematical model can be formulated. However, this model remains challenging to solve because it would take the form of a nonlinear integer knapsack problem due to the product terms involving z and $\alpha$ and ${a_2}_i$ and $\alpha$. As suggested in the literature [14], the problem can be further simplified by fixing the value of $\alpha$. By iterating over possible integer values of ${\alpha }^{★}$ within a feasible range, the nonlinear knapsack problem can be transformed into several linear knapsack problems, which are easier to solve. This approach significantly reduces the computational complexity and allows for an efficient exploration of potential intermediate rolls. The simplified row-generating Pricing Subproblem is formulated as follows:

$$\begin{array}{cc}\hfill \mathrm{maximize}\sum _{i=1:{{\ell }_1}_i=L_1}^{m_1}{u}_{1i}^{★}{a}_{1i}-c_1{L}_1+\sum _{i=1:{{\ell }_2}_i=L_2}^{m_2}{\displaystyle \frac{L_1}{L_2}}{\alpha }^{★}{u}_{2i}^{★}{a}_{2i}-t_{min,2}{L}_1{\alpha }^{★}& \end{array}$$

(39)

$$\mathrm{subject} \mathrm{to}$$

$$\begin{array}{c}{c}_1=w_0-\sum _{i=1:{{\ell }_1}_i=L_1}^{m_1}{w_1}_i{a_1}_i-z{\alpha }^{★}\hfill \end{array}$$

(40)

$$z=t_{min,2}+\sum _{i=1:{{\ell }_2}_i=L_2}^{m_2}{w_2}_i{a_2}_i$$

(41)

$$c_1\ge t_{min,1}$$

(42)

$${a_1}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_1$$

(43)

$${a_2}_i\ge 0,\mathrm{integer}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i=1,\dots ,m_2$$

(44)

$$z_{min}\le z\le z_{max},\mathrm{integer}$$

(45)

By focusing on a single intermediate roll, the update of the coefficient matrix A simplifies. The new intermediate roll and its associated cutting patterns are incorporated into the RSRMP’s coefficient matrix as follows:

$$A=\left(\begin{array}{cccc}{A}_{11}& {{\mathbf{a}}_1}^{★}& A_{12}& \mathbf{0}\\ {\mathbf{0}}^T& {\alpha }^{★}& {\mathbf{0}}^T& -{\displaystyle \frac{L_2}{L_1}}\\ O& \mathbf{0}& A_{22}& {{\mathbf{a}}_2}^{★}\end{array}\right)$$

(46)

For the new intermediate order generated, a value of zero is added to the demand vector: ${\mathbf{b}}_1^T={\left(\begin{array}{ccc}{b_1}_1& \dots {b_1}_{m_1}& 0\end{array}\right)}^T$. This ensures that the quantity consumed by the second-stage patterns does not exceed the quantity produced by the first-stage patterns.

5. Computational Results

In this section, the computational experiments conducted to evaluate and compare the performance of the proposed Generate-and-Solve (G&S) algorithm and the Row-and-Column Generation (R&CG) algorithm for 1.5-D TSCSP is presented. The experiments are designed to assess the algorithms on a diverse range of randomly generated instances that reflect various practical scenarios encountered in industry.

5.1. Experimental Setting

Test instances based on two types of randomly generated datasets, I1 and I2, are generated (All input data used for these test instances can be downloaded from the following GitHub repository: https://github.com/paolomarg-unisalento/1.5d-tscsp-dataset, accessed on 21 December 2024.). Each instance type comprises ten subtypes, corresponding to varying numbers of second-stage orders ($m_2$), ranging from 10 to 50. For the sake of simplicity, there are no final orders at the first stage. For each subtype, ten instances were generated, resulting in a total of 100 instances. I1 is based on the test problems used by [17]; these instances feature single length ratios and a single length for finished rolls. In contrast, I2 includes multiple lengths for finished rolls and multiple length ratios and is designed to mimic practical industrial cases, as illustrated in Figure 3. Since I2 instances enforce a minimum trim loss at the first stage, indirectly, they reduce the number of intermediate orders produced, aligning the model with realistic operational constraints.

The parameters utilized for generating these instances are presented in

Table 1. Parameters of instance generator.

Parameter	I1	I2
Stock size	10,000	10,000
Intermediate order width range	(1250; 2500)	(2000; 3000)
Length ratios	20	$\{20;30\}$
Order width	UR(300; 500)	UR(100; 500)
Order length	1	US$\{1;2;3\}$
Order amount	UR(10; 100)	UR(10; 100)
First stage min trim	0	100
Second stage min trim	50	30

. Finished roll widths and order demands were generated using integer uniform distributions over a specified range of integer values (UR), while lengths were selected from specified discrete sets with uniform probability (US). The length ratios represent the admissible ratios between the lengths of intermediate rolls and finished rolls, ensuring compatibility during the cutting process. The minimum trims at each stage are determined by practical considerations, including machine limitations and quality requirements.

All computational experiments were conducted on a computer equipped with an Intel Core i7-6700 CPU running at 3.40 GHz and 16 GB of RAM. The algorithms were implemented in C# using the .NET 8 framework. IBM ILOG CPLEX Optimizer version 22.1.1, along with CPLEX Concert Technology, was used to solve the linear and integer programming models.

For both the G&S and R&CG algorithms, an execution time limit of 600 s was imposed on the generation of patterns and intermediate orders. A separate time limit of 600 s was imposed for resolving the SRMP model. The best solution discovered up to that point was recorded.

5.2. Discussion

The performance of the algorithms was evaluated based on several metrics, including the number of patterns generated at the initial and second stages ($n_1$ and $n_2$), the average number of intermediate orders ($m_1$), the average percentage difference in the objective value ($\Delta$% Int. Obj. Value), and the average difference in the total computation time ($\Delta$ Tot. time).

Table 2. Computational results for instances I1 and I2.

Instance	${\mathit{m}}_2$	G&S			R&CG
		Avg. ${\mathbf{n}}_{\mathbf{1}}$	Avg. ${\mathbf{n}}_{\mathbf{2}}$	Avg. ${\mathbf{m}}_{\mathbf{1}}$	Avg. ${\mathbf{n}}_{\mathbf{1}}$	Avg. ${\mathbf{n}}_{\mathbf{2}}$	Avg. ${\mathbf{m}}_{\mathbf{1}}$	Avg. $\Delta \%$ Int. Obj. Value	Avg. $\Delta$ Tot. Time (s)
I1	10	27.0	21,857.4	1.0	2.0	36.1	1.0	+0.7	−5.6
I1	20	26.0	42,098.3	1.0	2.0	82.5	1.0	−0.2	−45.5
I1	30	34.0	51,636.1	1.0	2.0	113.9	1.0	−43.3	−232.0
I1	40	26.5	39,165.6	1.0	2.0	155.1	1.0	−86.1	+3.1
I1	50	25.6	39,207.0	1.0	2.0	192.2	1.0	−86.1	−64.7
I2	10	25.3	39,604.3	5.0	17.9	98.5	17.9	−59.9	−362.8
I2	20	19.9	165,498.6	5.0	18.0	236.4	18.0	−75.8	−169.0
I2	30	19.0	248,692.0	5.0	18.0	351.1	18.0	−85.8	−332.0
I2	40	23.9	343,933.2	5.0	18.0	485.3	18.0	−87.6	−443.5
I2	50	14.0	815,093.0	10.0	18.0	644.0	18.0	−82.2	−595.6

presents the computational results for instances I1 and I2.

For smaller instances of I1, which feature single length ratios and single lengths for finished rolls, both algorithms performed adequately. The G&S algorithm, however, tended to generate a significantly larger number of second-stage patterns ($n_2$) compared to the R&CG algorithm, leading to increased computational effort. Despite this, the G&S algorithm achieved comparable integer objective values, as indicated by the small average differences in the objective value ($\Delta$% Int. Obj. Value). The R&CG algorithm, with its fewer generated patterns, demonstrated greater computational efficiency, requiring less total computation time in most cases.

In bigger instances of I1 and in the more complex instances of I2, which incorporate multiple length ratios, multiple lengths for finished rolls, and enforce a minimum trim loss at the first stage, the performance gap between the two algorithms became more pronounced. The G&S algorithm continued to generate a substantially higher number of second-stage patterns, which significantly increased the computational time. For example, in instances I2 with $m_2=50$, the G&S algorithm generated an average of 815,093 s-stage patterns, whereas the R&CG algorithm generated only 644 patterns. This difference resulted in the G&S algorithm having a much longer computation time, with an average decrease in the total time of -595.6 s compared to the R&CG algorithm.

Moreover, the G&S algorithm exhibited a worse performance in terms of the solution quality for these complex instances. The average difference in the integer objective value ($\Delta$% Int. Obj. Value) was negative, indicating that the R&CG algorithm found better solutions with lower trim losses.

These results suggest that while the G&S algorithm is effective for simpler instances, it struggles with the increased complexity of industrial cases represented by I2. In contrast, the R&CG algorithm demonstrates robustness and efficiency across both simple and complex instances. The ability of the R&CG algorithm to generate fewer patterns while achieving better or comparable objective values highlights its suitability for practical applications of the 1.5-D TSCSP in industrial settings, where computational resources and time are critical factors.

6. Conclusions

In this study, the Generate-and-Solve algorithm and the Row-and-Column Generation algorithm, both of which are available in the literature for solving one-dimensional constraint satisfaction problems, were extended to solve the One-and-Half-Dimensional Two-Stage Cutting Stock Problem. These algorithms were tested on randomly generated cases of increasing complexity. The computational results demonstrate that the R&CG algorithm generally outperforms the G&S algorithm in terms of solution quality and computational efficiency, particularly in complex instances involving multiple length ratios and practical constraints such as minimum trim requirements that are typical of plastic films and paper industries.

Future research could focus on enhancing both approaches. The G&S algorithm can be improved by incorporating the ratio between the dual value and width for each order on priority calculation. Online machine learning techniques might be employed to make the lexicographic search tree for pattern generation more intelligent. Row-Generating PSP in R&CG algorithm can be generalized, as suggested in previous studies [17], enabling it to generate multiple intermediate orders simultaneously. Moreover, the problem can be extended, allowing patterns to contain at most two different lengths—enabled by duplex slitter rewinders, and including final orders at the first stage with minimum demand constraints.

Additionally, the Cutting Stock Problem exhibits significant similarities with the Bin Packing Problem (BPP). Consequently, the proposed methodologies could be generalized to address specific variations of this class of problems, including the colored BPP. In this scenario, a sequence of items arrives to be packed into bins of predetermined capacity. Each item possesses one of a predetermined set of colors, and an additional constraint is that placing two items of the same color adjacent to each other within the same bin is prohibited.