Heuristic for the rectangular two-dimensional single stock size cutting stock problem with two-staged patterns

Highlights

• We propose a recursion for packing rectangular items into strips.

• We propose a recursion for placing strips on the plate.

• The cutting plan is obtained from solving a sequence of residual problems.

• Solve more than 75% of the benchmark instances to optimality.

• Achieve better solution quality than a commercial stock cutting software package.

Abstract

Two-staged patterns are often used in manufacturing industries to divide stock plates into rectangular items. A heuristic algorithm is presented to solve the rectangular two-dimensional single stock size cutting stock problem with two-staged patterns. It uses the column-generation method to solve the residual problems repeatedly, until the demands of all items are satisfied. Each pattern is generated using a procedure for the constrained single large object placement problem to guarantee the convergence of the algorithm. The computational results of benchmark and practical instances indicate the following: (1) the algorithm can solve most instances to optimality, with the gap to optimality being at most one plate for those solutions whose optimality is not proven and (2) for the instances tested, the algorithm is more efficient (on average) in reducing the number of plates used than a published algorithm and a commercial stock cutting software package.

Introduction

The Two-Dimensional single stock size Cutting Stock problem (TDCS) appears in several industries, where stock plates of the same size are divided into rectangular items. The stock may be metal plate, plate glass, or wood panel. In Wäscher et al. (2007), the TDCS is formally referred to as the two-dimensional SSSCSP (single stock size cutting stock problem), in which m types of rectangular items with specified demands are completely produced from plates of the same size L ⊗ W (length ⊗ width), such that the input (number of plates used, simply “plate count”) is minimized. The item types are characterized by lengths (l₁, … , l_m), widths (w₁, … , w_m) and demands (d₁, … , d_m). A solution of the TDCS is a cutting plan that contains a set of different cutting patterns, each of which has specified layout and frequency. The solution can be obtained from solving the following integer programming (IP) model:

$$\min \left\{\left.{\displaystyle \sum _{j=1}^M}{x}_j\right|{\displaystyle \sum _{j=1}^M}{a}_{\mathit{ij}}{x}_j⩾d_i\text{,}i=1\text{,}\dots \text{,}m\text{;}{x}_j\in \mathbf{N}\text{,}j=1\text{,}\dots \text{,}M\right\}\text{,}$$

where M is the number of possible cutting patterns. Each pattern can be obtained from solving a two-dimensional SLOPP (Single Large Object Placement Problem; see Wäscher et al. (2007)), x_j the frequency of pattern j (decision variable), j = 1, … , M, a_ij the frequency of type-i items in pattern j, i = 1, … , m and j = 1, … , M and N is the set of non-negative integers.

The solution value is the plate count and must be minimized, subject to the constraints that the demands must be satisfied and the pattern frequencies should be integers.

Solving the IP model exactly is time consuming because of the vast set of possible patterns. Actually it may be impossible to enumerate all the patterns. Gilmore and Gomory (1961) proposed the column-generation (CG) approach that solves the following linear programming (LP) model:

$$\min \left\{\left.{\displaystyle \sum _{j=1}^m}{x}_j\right|{\displaystyle \sum _{j=1}^m}{a}_{\mathit{ij}}{x}_j⩾d_i\text{,}i=1\text{,}\dots \text{,}m\text{;}{x}_j⩾0\text{,}j=1\text{,}\dots \text{,}m\right\}\text{.}$$

Starting from a feasible solution that contains m patterns, the CG solves the LP model iteratively. In each iteration, it generates a pattern P from solving the following two-dimensional SLOPP:

$$\max \left\{\left.z_P={\displaystyle \sum _{i=1}^m}{c}_i{p}_i\right|P\text{is a feasible pattern;}{p}_i\in \mathbf{N}\text{,}i=1\text{,}\dots \text{,}m\right\}\text{,}$$

where z_P is the value of the pattern, c_i the value of a type-i item, obtained from the current dual LP-solution, and p_i is the frequency of type-i items in the pattern.

The pattern is used to replace an existing one to update the solution. The iteration is terminated when the value of the new pattern is not larger than 1, then the current LP-solution becomes optimal. The pattern frequencies may be fractional in the optimal LP-solution. A procedure should be used to round them to integers to obtain a feasible solution to the IP model. A residual problem may be generated if the pattern frequencies are simply rounded down as (⌊x₁⌋, … , ⌊x_m⌋), where the (remaining) demands are $r_i=d_i-{\sum }_{j=1}^m{a}_{\mathit{ij}}\lfloor x_j\rfloor \text{,}i=1\text{,}\dots \text{,}m$. It must be solved to complete the solution.

Guillotine cuts are often required to divide the plates into items. Two-staged (2STG) patterns are among the simplest guillotine pattern types that are used in the cutting process, where the cuts in the first stage split the plate into strips, and those in the second stage divide the strips into items. The cuts in the same stage are in the same direction, and the cut directions of the two stages are perpendicular to each other. The items can be orientated or non-orientated. In the later case an item can be placed on the plate with its length orientation being either horizontal or vertical. This paper concerns the TDCS with 2STG patterns (TDCS_2STG). The TDCS_2STG is denoted as TDCS_2STGO for the orientated case and as TDCS_2STGR for the case of allowing rotation (non-orientated). The TDCS_2STGR is the focus of this paper.

The proposed algorithm is denoted as the RCCG (repeated constrained column-generation), where R (repeated) means that the complete solution (the complete cutting plan) is obtained from repeatedly solving the residual problems until the demands are satisfied, C (constrained) indicates that the patterns are generated mainly using a procedure for the constrained two-dimensional SLOPP (C_SLOPP), and CG means that each residual problem is solved by the CG approach. Each run of the CG fulfills some portion of the remaining demands. More precisely, the master problem solved in each run of the CG can be formulated as follows, where r_i = d_i for the first run:

$$\min \left\{{\displaystyle \sum _{j=1}^m}{x}_j\left|{\displaystyle \sum _{j=1}^m}{a}_{\mathit{ij}}{x}_j=r_i\text{,}i=1\text{,}\dots \text{,}m\text{;}{x}_j⩾0\text{,}j=1\text{,}\dots \text{,}m\right.\right\}\text{.}$$

Let A = [a_ij]_m×m, R = [r_i]_m×1 and X = [x_j]_m×1. The problem can also be written as:

$$\min \left\{{\displaystyle \sum _{j=1}^m}{x}_j|\mathbf{AX}=\mathbf{R}\text{;}\mathbf{X}⩾\mathbf{0}\right\}\text{.}$$

The sub-problem solved for generating the patterns in the first run is the unconstrained SLOPP (U_SLOPP):

$$\max \left\{z_P={\displaystyle \sum _{i=1}^m}{c}_i{p}_i|P\text{is a 2STGR pattern;}{p}_i\in \mathbf{N}\right\}\text{.}$$

The U_SLOPP is naturally constrained despite the absence of explicit constraints on the demand per piece type, because p_i ⩽ ⌊(LW)/(l_iw_i)⌋ must be hold for any feasible pattern. The patterns in the subsequent runs are generated from solving the following sub-problem (C_SLOPP):

$$\max \left\{z_P={\displaystyle \sum _{i=1}^m}{c}_i{p}_i|P\text{is a 2STGR pattern;}(p_i\in \mathbf{N})\cap {(p_i⩽r)}_i\text{,}i=1\text{,}\dots \text{,}m\right\}\text{.}$$

As later demonstrated in the computational test, the RCCG is powerful in input minimization. It can solve most benchmark instances to optimality. For those solutions whose optimality is not proven, the gap to optimality is at most one plate. For the instances tested, the RCCG is more effective in input minimization than a published algorithm and a commercial stock cutting software package.

The remaining contents are organized as follows. The literature is reviewed in Section 2. The C_SLOPP procedure for 2STGR patterns is described in Section 3, followed by the presentation of the RCCG algorithm in Section 4. The computational results are reported in Section 5 and the conclusions are given in Section 6.