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

European Journal of Operational Research 231 (2013) 288–298

Contents lists available at SciVerse ScienceDirect

European Journal of Operational Research journal homepage: www.elsevier.com/locate/ejor

Discrete Optimization

Heuristic for the rectangular two-dimensional single stock size cutting stock problem with two-staged patterns Yaodong Cui, Zhigang Zhao ⇑ School of Computer, Electronics and Information, Guangxi University, Nanning 530004, China

a r t i c l e

i n f o

Article history: Received 27 October 2012 Accepted 26 May 2013 Available online 6 June 2013 Keywords: Cutting Two-dimensional cutting stock Two-staged patterns Column generation

a b s t r a c t 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. Ó 2013 Elsevier B.V. All rights reserved.

1. 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 (l1, . . . , lm), widths (w1, . . . , wm) and demands (d1, . . . , dm). 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:

 ( ) X M M X  min xj  aij xj P di ; i ¼ 1; . . . ; m; xj 2 N; j ¼ 1; . . . ; M ;  j¼1 j¼1 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)), xj the frequency of pattern j (decision variable), j = 1, . . . , M, aij 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. ⇑ Corresponding author. Tel.: +86 13005927846. E-mail addresses: [email protected] (Y. Cui), [email protected] (Z. Zhao). 0377-2217/$ - see front matter Ó 2013 Elsevier B.V. All rights reserved. http://dx.doi.org/10.1016/j.ejor.2013.05.042

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

 ( ) X m m X  xj  aij xj P di ; i ¼ 1; . . . ; m; xj P 0; j ¼ 1; . . . ; m :  j¼1 j¼1

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:

 )  m X  max zP ¼ ci pi P is a feasible pattern; pi 2 N; i ¼ 1; . . . ; m ;  i¼1 (

where zP is the value of the pattern, ci the value of a type-i item, obtained from the current dual LP-solution, and pi 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 (bx1c, . . . , bxmc), where the (remaining) demands are

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

Pm

r i ¼ di  j¼1 aij bxj c; i ¼ 1; . . . ; 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 ri = di for the first run:

min

 ( ) X m m X  xj  aij xj ¼ r i ; i ¼ 1; . . . ; m; xj P 0; j ¼ 1; . . . ; m :  j¼1 j¼1

Let A = [aij]mm, R = [ri]m1 and X = [xj]m1. The problem can also be written as:

( ) m X min xj jAX ¼ R; X P 0 :

ð1Þ

j¼1

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

(

) m X max zP ¼ ci pi jP is a 2STGR pattern; pi 2 N : i¼1

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

( max zP ¼

m X

) ci pi jP is a 2STGR pattern; ðpi 2 NÞ \ ðpi 6 rÞi ; i ¼ 1; . . . ;m :

i¼1

ð2Þ 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.

289

2. Literature review 2.1. Approaches for the TDCS The solution of the TDCS is a cutting plan that contains a set of different cutting patterns, where both the frequency and items layout of each pattern are specified. There are at least three approaches for the TDCS. The first is the integer programming (IP) approach that is exact, where the decision variables are the pattern frequencies that must be non-negative integers. IP models for the TDCS_2STGO have been presented in Lodi et al. (2004) and Silva et al. (2010). The later authors used the C callable library of the ILOG Cplex 11.0 solver for the optimization of the proposed model. They tested both their model and that of Lodi et al. (2004), using a 1.87 gigahertz Intel Core Duo processor with 2 gigabyte of RAM memory, where the time limit was set to be 7200 seconds for each instance. For the 20 benchmark instances (ATP instances 30–49), the model of Silva et al. (2010) solved 12 of them to proven optimality, and that of Lodi et al. (2004) solved 4 of them to proven optimality. This indicates that exact algorithms are not appropriate for solving large-scale TDCS_2STGO instances. Considering that the solution space of the TDCS_2STGR is much larger than that of the TDCS_2STGO, it may be not wise to try IP models. Macedo et al. (2010) presented an IP arc-flow model for the TDCS_2STG (both TDCS_2STGO and TDCS_2STGR). The model was also solved with ILOG Cplex 11.0 solver. Two sets of real instances from the wood industry were used in the computational test. The second approach is the sequential heuristic procedure (SHP). It generates a pattern using the remaining items to satisfy some portion of the demands, and repeats until all demands are satisfied. The SHP has been used widely in solving the one-dimensional cutting stock problem (Belov and Scheithauer, 2007; Cui and Liu, 2011). Suliman (2006) presented an SHP-based approach for the TDCS, where the patterns are not 2STG ones. The third is the CG approach. It solves the linear relaxation of the IP model to obtain the optimal LP-solution, in which the pattern frequencies may be fractional and must be rounded to integers to make the cutting plan feasible. Each pattern is obtained from solving the related U_SLOPP. In rounding the solution, shortage of the items is not allowed, but surplus may be generated and is taken as waste. The approach usually yields good solutions when the average pattern frequency is large. Sophisticated rounding procedures may be required when the average demand of the item types is small, because then the average pattern frequency is also small, subsequently simple rounding procedure may lead to large errors. Most CG-based algorithms do not restricted the patterns to be 2STG ones (Alvarez-Valdes et al., 2002; Cui and Yang, 2012). The CG approach in Alvarez-Valdes et al. (2002) solves the U_SLOPP by several methods, including dynamic programming, GRASP and tabu search. Three different strategies are used in rounding the solutions. The CG approach in Cui and Yang (2012) solves the U_SLOPP by dynamic programming to generate extended block patterns. A simple rounding procedure is used in geting integer solutions. Cintra et al. (2008) presented a special CG approach, where the TDCS is solved in two phases, and both non-staged and staged patterns are considered, including the 2STG (both 2STGO and 2STGR) patterns. The patterns are generated using dynamic programming. The CG algorithm is executed several times in the first phase. The input of the first execution is the original problem. The fractional frequencies in the LP solution of the current execution are simply rounded down to integers, producing a residual problem that is taken as the input of the next execution. The first phase is terminated

290

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

when the rounding procedure produces zero frequencies for all patterns. Then a heuristic strategy is used in the second phase to solve the last residual problem. The RCCG in this paper is also a special CG approach. It differs from the general CG approach in the following aspects. (1) The general CG approach only runs once to obtain the solution. The RCCG solves the residual problems successively until all demands are satisfied. (2) The general CG approach uses an U_SLOPP procedure to generate the patterns, whereas the RCCG mainly uses a C_SLOPP procedure. Both the RCCG and the approach in Cintra et al. (2008) solve the residual problems repeatedly. The former uses a C_SLOPP procedure in pattern-generation to guarantee the convergence of the algorithm. The later calls a U_SLOPP procedure to generate the patterns and a heuristic in the second phase to solve the final residual problem if necessary to complete the solution. It should be noted that an approach similar to the RCCG is presented in Poldi and Arenales (2009) to solve the one-dimensional cutting stock problem of multiple stock lengths, where a onedimensional bounded knapsack problem is solved to generate the patterns, and several rounding procedures are used to obtain integer solutions. The approach is the same as the RCCG in the sense that residual problems are successively solved by the CG approach until all demands are satisfied, and the patterns are obtained from solving a C_SLOPP.

2.2. Approaches for the C_SLOPP with two-staged patterns The RCCG uses a C_SLOPP procedure to generate 2STGR patterns. The time efficiency of the C_SLOPP procedure is vital because a large number of patterns must be generated before the complete cutting plan is determined. Several exact and heuristic algorithms for the 2STGO patterns have been reported, such as the bottom-up approach (Hifi and M’Hallah, 2005), the strip generation algorithms (Hifi and M’Hallah, 2006), the beam search algorithm (Hifi et al., 2008), and the parallel beam search algorithm (Hifi and Saadi, 2012). There are still other algorithms for the 2STGO. A more detailed review is available in Hifi and Saadi (2012). Algorithms dealing with the 2STGR have been rarely reported. Lodi and Monaci (2003) presented an exact approach for the 2STGR. 17 small benchmark instances were solved in the computational test. The computation time is too long for middle- and largescale 2STGR instances. The C_SLOPP procedure in this paper is a fast and easy to code heuristic for generating 2STGR patterns. It uses two simple recursions, one for packing the items into strips, and the other for placing the strips on the plate. The computational results indicate that the procedure is adequate for being used under the RCCG frame to solve the TDCS_2STGR. It should be noted that some existing C_SLOPP procedures for 2STGO patterns, such as those in Hifi and M’Hallah (2006) and Hifi et al. (2008), may also be adapted to generate 2STGR patterns.

3. C_SLOPP procedure for two-staged patterns 3.1. Two-staged patterns Fig. 1 shows two 2STG patterns, where the numbers denote the item types. They have obvious strip structure. The left is an X-pattern in which the strips are horizontal, and the right is a Y-pattern where the strips are vertical. A 2STG pattern can be divided into items within two stages. The plate is divided into strips at the first stage, and the strips into items at the second stage. The first-stage cuts are horizontal for an X-pattern. They are vertical for a Ypattern. 3.2. Strip-generation procedure The C_SLOPP procedure solves approximately model (2) to obtain the current pattern. It first calls a strip-generation procedure to pack the items into strips and then places the strips on the plate. It is sufficient only to generate horizontal strips. Vertical strips can be obtained from rotating the horizontal ones by 90°. It is assumed that L P W. The assumption is reasonable because swapping the length and width of the plate does not affect the solution when the items are non-orientated and both X- and Y-patterns are considered. Blank types are introduced to facilitate presentation. Type-i item is related with blank types i and m + i, i = 1, . . . , m. There are 2m blank types. The size of type i is li  wi and that of type (m + i) is wi  li. The number of strip types to be considered is also 2m. Each strip type is related with a blank type and vice versa, where the strip width is the same as that of the blank type. The following paragraphs first introduce the necessary notations and then give the recursion for determining the strip types. The explanation follows afterwards. The following notations are used, where j = 1, . . . , 2m:

ej jj Wj Lj U

m(j, x) g(j, x, i) n(j, i)

Blank type to which type-j strip is related Item type to which type-j strip is related. jj = ej when ej 6 m; jj = ej  m when m < ej 6 2m Width of type-j strip, W1 6    6 W2m Length of the blank type related with type-j strip U = {u1, . . . , um}. ui is the upper bound of type-i items that can be used in generating the strips Value of strip x  Wj Frequency of type-i items in strip x  Wj, i = 1, . . . , m Frequency of type-i items in strip L  Wj, n(j, i) = g(j, L, i), i = 1, . . . , m

Initially let W0 = 0; m(0, x) = 0 and g(0, x, i) = 0, x = 0, . . . , L and i = 1, . . . , m. Let i = jj for type-j strip; then Wj = wi and Lj = li when ej 6 m; Wj = li and Lj = wi when m < ej 6 2m. The following recursion determines the solution to type-j (j = 1, . . . , 2m) strip:

Fig. 1. Two-staged patterns. (a) X-pattern. (b) Y-pattern.

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298



291



mðj; xÞ ¼ max mðj  1; xÞ; ci þ mðj; x  Lj ÞjLj 6 x; gðj; x  Lj ; iÞ < ui : ð3Þ The strip types are arranged in ascending order of their widths (W1 6    6 W2m). Their solutions are also obtained in the same order. The solution m(j, x) of type-j strip is initialized as that of type (j  1). This is feasible because Wj P Wj1. Then blank type j is considered to improve the solution. The solution m(j, x) may be obtained from horizontally building a piece of blank type j (item type i) at the right edge of strip (x  Lj)  Wj that has value m(j, x  Lj) and contains g(j, x  Lj, i) type-i pieces. g(j, x  Lj, i) < ui should hold because a type-i piece is being added. The strip-generation procedure is based on the recursion. It is greedy in nature. Considering that g(j, x, i) should be determined for j = 1, . . . , 2m, x = 0, . . . , L and i = 1, . . . , m, the complexity of the strip-generation procedure is O(2m2L). 3.3. Contents of the C_SLOPP procedure The C_SLOPP procedure will be described for X-patterns. It can also be used for Y-patterns when the length and width of the plate is swapped. The recursion for determining the X-pattern, its explanation, and the contents of the C_SLOPP procedure are given in the next paragraphs. Let N(y, i) be the frequency of type-i items in segment L  y, y = 0, . . . , W and i = 1, . . . , m. G strip sets generated by the strip-generation procedure will be used to obtain the solution, where each set is generated using specified upper bounds of the items. The method for determining the upper bounds will be described later. Let F(g, y) be the value of segment L  y when the first g sets of strips have been used, y = 0, . . . , W and g = 1, . . . , G. The value of the X-pattern is F(G, W). Initially let F(0, y) = 0 and N(y, i) = 0, i = 1, . . . , m and y = 0, . . . , W. The following recursion determines the solution to segment L  y, where j = 1, . . . , 2m and y = 0, . . . , W:

zji ¼ 0 if y < W j ; zji ¼ minfr i ; nðj; iÞ þ Nðy  W j ; iÞg otherwise; i ¼ 1; . . . ; m; ( Fðg; yÞ ¼ max Fðg  1; yÞ; V j jV j ¼

) m X ci zji ; j ¼ 1; . . . ; 2m :

ð4Þ

i¼1

The solution of F(g, y) is initialized to F(g  1, y), that is, the solution to segment L  (y  1). Then 2m branches are considered to improve the solution. The jth branch is related with placing strip L  Wj on top of segment L  (y  Wj). It contains zji copies of type-i items. zji is at most n(j, i) + N(y  Wj, i), where n(j, i) is the number of type-i items in strip L  Wj, and N(y  Wj, i) is that in segment L  (y  Wj). zji should not exceed the residual demand ri. This means that surplus is taken as waste when n(j, i) + N(y  Wj, i) > ri. P The value of the branch is V j ¼ m i¼1 c i zji . For a specified g, the complexity of the recursion is O(2m2W). This is true because F(g, y) should be determined for y = 1, . . . , W, and for each specified y, O(2m2) operations are required to obtain all Vj, j = 1, . . . , 2m. When G = 1, only one set of strips are used and the items in the current residual problem are all used in generating them. Let h = bW/(G  1)c when G > 1. The upper bounds of the items used for generating the gth set of strips is determined as ui = ri  N((g  1)h, i), i = 1, . . . , m. It means that when the first g  1 strip sets have been used to improve the solution, the upper bounds are updated by deleting the items that are included in segment L  ((g  1)h), and then used in generating the gth set of strips. For illustrative purposes, assume that W = 201 and G = 3; then h = bW/(G  1)c = 100. When g = 1, ui = ri  N(0, i) = ri. This means that the upper bounds are equal to the demands (in the residual problem) for the first strip set. Then the strips are used in solving recursion (4) to obtain F(1, y), meanwhile N(y, i) is also determined,

Fig. 2. Strip sets. (a) g = 2. (b) g = 3.

y = 0, . . . , W and i = 1, . . . , m. Fig. 2a shows the case of g = 2, where ui = ri  N(100, i). It indicates that the upper bounds are determined by removing the items included in the current solution to segment L  100 (the hatched area in the figure), that is, the solution related with F(1, 100). This set of strips is used in solving recursion (4) to obtain F(2, y) and update N(y, i). The case for the last strip set (g = 3) is shown in Fig. 2b, where ui = ri  N(200, i). The upper bounds are determined by removing the items included in the current solution to segment L  200, namely the solution related with F(2, 100). Then the strips are used in solving recursion (4) to obtain F(3, y) = F(G, y). The value of the X-pattern is F(G, W) = F(3, 201). The C_SLOPP procedure is based on recursion (4). Its contents are shown in Fig. 3. The complexity is O(2m2GL) + O(2m2GW) = O[2m2G(L + W)], where O(2m2GL) denotes the complexity for solving recursion (3) G times, and O(2m2GW) denotes that for solving recursion (4) G times. 3.4. Normal sizes It is sufficient to consider normal sizes in solving the C_SLOPP (Hifi and M’Hallah, 2006; Cui and Yang, 2011). When the items are non-orientated, normal sizes are the combinations of the lengths and widths of the item types. The RCCG considers the following normal lengths in solving recursion (3): n o X ðai li þ bi wi Þ 6 L; ai 2 f0;1;.. .;bL=li cg; bi 2 f0;1;. ..;bL=wi cg : xjx ¼ It considers the following normal widths in solving recursion (4): n o X yjy ¼ ðai li þ bi wi Þ 6 W; ai 2 f0; 1;. . . ; bW=li cg; bi 2 f0; 1;. . . ; bW=wi cg :

4. Algorithm RCCG The RCCG consists of the following steps, where the terms CGC, CGU and ROUND will be explained later: Step 1. Solve the original problem using the CGU and call the ROUND to obtain the related partial cutting plan and the residual problem. Go to Step 4 if the residual problem is null. Step 2. Solve the current residual problem using the CGC and call the ROUND to obtain the related partial cutting plan and the residual problem. Go to Step 4 if the residual problem is null. Step 3. Go to Step 2 with the new residual problem just generated. Step 4. Combine all partial cutting plans to form the complete cutting plan. The CGC in Step 2 denotes that the CG is used to solve the TDCS problem, where a C_SLOPP procedure is used to generate each

292

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

Fig. 3. C_SLOPP procedure.

pattern. Recall that in each run of the CGC, the following residual problem is solved:

 !  m X  min xj AX ¼ R; X P 0 :  j¼1 The CGC is implemented according to the following steps: Step 1: Construct the initial LP-solution by setting A equal to the unit matrix. It means that the initial solution is X = R. Each pattern contains only one item because aii = 1, aij = 0 when i – j, where i, j = 1, . . . , m. Step 2: Determine the current values of the items as [c1, . . . , cm] = [1, . . . , 1]A1. Step 3: Call the C_SLOPP procedure to obtain the current pattern P. Go to Step 5 if the pattern value is not larger than 1. Step 4: Replace the kth column of matrix A with P and go to Step 2, where k is determined according to the following formula:

xk =pk ¼ minfxi =pi jpi > 0; i ¼ 1; . . . ; mg: Step 5: Output the LP-solution to the ROUND for further processing. The CGU differs from the CGC only in Step 3, where the U_SLOPP procedure should be called to generate the pattern. In solving each residual problem using the CGC, parameter G (the number of strip sets) for the C_SLOPP procedure is set to be 1 at the early stage until no improvement of the LP-solution can be achieved, then it is set to be 15. This is useful to reduce the computation time, because the pattern generation time increases with G. Both X-patterns and Y-patterns are considered in calling the C_SLOPP procedure. The CGU in Step 1 denotes that the CG is used to solve the TDCS problem, where a U_SLOPP procedure is used to generate each pattern. The U_SLOPP procedure is based on the approach in Section 2.3 of Hifi (2001). If the first residual problem is set to be the original problem, then Step 1 can be omitted. Step 1 is useful to reduce the computation time because U_SLOPP procedures are much faster than C_SLOPP ones in generating patterns. The partial cutting plan generated in Step 1 may be null when the average demand of the item types is very small. The ROUND denotes a procedure that rounds the optimal LP solution to obtain the related partial cutting plan and the residual problem. Let the optimal LP-solution to the current residual problem be X = (x1, . . . , xK), where the patterns have been arranged in descending order of their material utilizations. The material utilization of a pattern is the ratio between the total area of the included items and the plate area. The ROUND consists of the following steps. Step 1. Let X = (bx1c, . . . , bxK c). Get the residual items. Let k = 1. Step 2. Determine Dxk, an integer that represents the possible maximum incremental frequency of the kth pattern, without producing surplus. If Dxk > 0 then let xk = xk + Dxk and update the residual items.

Step 3. If k < K and the number of residual items is not null then let k = k + 1 and go to Step 2; otherwise stop with the partial cutting plan and a new residual problem. Steps 2 and 3 are necessary for the RCCG because of the following reason. If the LP solution is obtained from using the CGC, then there is at least one pattern whose frequency is not zero after calling the ROUND, because the frequency of each item type in a pattern is not larger than the demand. This guarantees the convergence of the RCCG. 5. Computational results Although the RCCG is presented for the non-oriented case, it can be adapted to deal with the oriented case. This section contains four subsections. The RCCG is compared with the heuristic algorithm of Cintra et al. (2008) in Section 5.1, with the exact algorithm of Silva et al. (2010) in Section 5.2, and with a commercial stock cutting software package in Section 5.3. The effect of the G value is explained in Section 5.4. Four sets of instances are used. The first set is obtained from Cintra et al. (2008), the second and third from Silva et al. (2010), and the fourth from practice. The RCCG and the commercial stock cutting software package were executed on a personal computer (Intel Core 2 Quad CPU Q9400 2.66 gigahertz, RAM 3.37 gigabytes). The computer used in Cintra et al. (2008) has processor Intel Pentium IV, clock of 1.8 gigahertz and memory of 512 megabits, and that used in Silva et al. (2010) has processor Intel Core Duo, clock of 1.87 gigahertz and memory of 2 gigabytes). It seems that the algorithms in Cintra et al. (2008) and Silva et al. (2010) consider only X-patterns in which the first-stage cuts are horizontal. Subsequently the RCCG generates only X-patterns in Sections 5.1 and 5.2 to make the comparisons fair. Both X- and Y-patterns are considered in Section 5.3. The following notations are used in the sub-sections: ZLB

ZRCCG D

Lower bound of the integer solution. It can be obtained for the LP solution to the original problem (see Step 1 of the RCCG) Solution value (pattern count) of the RCCG Denoting that the solution value is equal to the lower bound ZLB

In interpreting the computation results, it should be noted that the RCCG solution (the solution obtained by the RCCG) is optimal if ZRCCG = ZLB. When ZRCCG > ZLB, the optimality of the RCCG solution remains an open issue. In fact, if ZLB is not a tight bound, the RCCG solution may indeed be optimal. 5.1. Comparing the RCCG with the algorithm (CGRp) in Cintra et al. (2008) The 12 instances in Set 1 are used. The demand of an item type is in [1, 100]. The other features of the instances are given in Table 1.

293

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298 Table 1 Features of the instances in Set 1. ID

m

LW

li-range

wi-range

Gcut1dr Gcut2dr Gcut3dr Gcut4dr Gcut5dr Gcut6dr Gcut7dr Gcut8dr Gcut9dr Gcut10dr Gcut11dr Gcut12dr

10 20 30 50 10 20 30 50 10 20 30 50

250  250 250  250 250  250 250  250 500  500 500  500 500  500 500  500 1000  1000 1000  1000 1000  1000 1000  1000

[66, 167] [18, 168] [63, 176] [62, 184] [132, 364] [132, 355] [129, 365] [131, 362] [292, 673] [269, 730] [266, 674] [254, 746]

[86, 184] [68, 186] [71, 186] [63, 179] [145, 356] [134, 372] [147, 374] [127, 374] [341, 688] [260, 742] [274, 745] [269, 723]

Table 2 Computational results of the instances in the Set 1. ID

Gcut1dr Gcut2dr Gcut3dr Gcut4dr Gcut5dr Gcut6dr Gcut7dr Gcut8dr Gcut9dr Gcut10dr Gcut11dr Gcut12dr

Orientated

Non-orientated

ZLB

ZRCCG

ZCGRp

ZLB

ZRCCG

ZCGRp

295 345 342 845 207 375 600 720 135 315 349 675

D D D 846 D D D 721 D D D 676

D D 343 D D D D D D D D 676

291 282 316 836 175 302 542 650 125 270 299 601

D D 317 D D D 543 651 D D D D

D 283 317 837 D D 543 D 126 271 300 602

Table 2 lists the computational results, where ZCGRp denotes the solution value of the CGRp. The ZLB and ZCGRp values are copied from Table 8 in Cintra et al. (2008) for the orientated case, and from Table 10 in Cintra et al. (2008) for the non-orientated case. For the orientated case, the number of instances solved to proven optimality is 9 for the RCCG and 10 for the CGRp. Compared with the CGRp, the solution of the RCCG is better in 1 instance (Gcut3dr), the same in 9 instances, and worse in 2 instances (Gcut4dr and Gcut8dr). This indicates that the solution quality of the RCCG is slightly lower than that of the CGRp for the orientated case. The average computation time of an instance is 0.04 seconds for the RCCG. It is 1.6 seconds for the CGRp. The former is about 2.5% of the later. The RCCG may be faster than the CGRp, although the later used a different computer. For the non-orientated case, the number of instances solved to proven optimality is 9 for the RCCG and 4 for the CGRp. Compared with the CGRp, the solution of the RCCG is better in 6 instances, the same in 5 instances, and worse in 1 instance (Gcut8dr). This indicates that the solution quality of the RCCG is obviously higher than that of the CGRp for the non-orientated case. The average computation time of an instance is 0.073 seconds for the RCCG. It is 4.924 seconds for the CGRp. The former is only about 1.5% of the later. The RCCG solution to Gcut9dr is shown in Fig. A1 in Appendix A. The solution is optimal. Its plate count (125) is smaller than that of the CGRp solution by one. From the computational results in this sub-section, it can be said that the average solution quality of the RCCG is better than that of the CGRp, and the RCCG may be faster than the CGRp. The statement is true at least for this set of instances. 5.2. Comparing the RCCG with the exact algorithm in Silva et al. (2010) The exact algorithm in Silva et al. (2010) is denoted as SILVA. Two sets (Sets 2 and 3) of benchmark instances are used. The items

are oriented because the computational results of the SILVA for the non-oriented case are not available. Set 2 contains 30 small instances. Their features are available from Table 3 in the e-appendix of Silva et al. (2010). Table 3 shows the computational results, where ZSILVA denotes the solution value of the SILVA and is copied from Table 9 of the e-appendix in Silva et al. (2010). The SILVA solved all instances to optimality. The RCCG solved 25 of them to optimality. For the 5 instances (A2, CHL1, CW2, Hchl4s and 3) not solved to optimality, the gap to optimality is only one plate. The average computation time of an instance is 0.19 seconds for the RCCG. It is 8.6 seconds for the SILVA. The former is only about 2.2% of the later. The RCCG may be faster than the SILVA, although the later used a different computer. Set 3 contains 20 medium-scale instances. Table 4 shows the instance features and the computational results, where lavg denotes the average item length, wavg the average width, and davg the average demand. The ZLB and ZSILVA values are copied from Table 9 of the e-appendix in Silva et al. (2010). Although the SILVA is an exact algorithm, it did not solve some instances to proven optimality because the computation time limit of 7200 seconds for each instance. The number of instances solved to proven optimality is 14 for the RCCG and 12 for the SILVA. Compared with the SILVA, the solution of the RCCG is better in 3 instances (ATP31, ATP42 and ATP43), the same in 16, and worse in 1 (ATP49). This indicates that the average solution quality of the RCCG is better than that of

Table 3 Computational results of the instances in Set 2. ID

ZLB

ZRCCG

ZSILVA

ID

ZLB

ZRCCG

ZSILVA

A1 A2 A3 A4 A5 CHL1 CHL2 CHL5 CHL6 CHL7 CU1 CU2 CW1 CW2 CW3

23 12 8 5 5 6 3 4 6 6 12 15 10 12 16

D 13 D D D 7 D D D D D D D 13 D

D D D D D D D D D D D D D D D

Hchl2 Hchl3s Hchl4s Hchl6s Hchl7s Hchl8s Hchl9 HH OF1 OF2 STS2 STS4 W 2 3

6 3 2 5 7 2 10 2 4 5 12 5 24 2 23

D D 3 D D D D D D D D D D D 24

D D D D D D D D D D D D D D D

Table 4 Features and computational results of the instances in Set 3. ID

m

LW

lavg

wavg

davg

ZLB

ZRCCG

ZSILVA

ATP30 ATP31 ATP32 ATP33 ATP34 ATP35 ATP36 ATP37 ATP38 ATP39 ATP40 ATP41 ATP42 ATP43 ATP44 ATP45 ATP46 ATP47 ATP48 ATP49

38 51 56 44 27 29 28 43 40 33 56 36 59 49 39 33 42 43 34 25

927  152 856  964 307  124 241  983 795  456 960  649 537  244 440  881 731  358 538  501 683  138 837  367 167  291 362  917 223  496 188  578 416  514 393  554 931  254 759  449

214 187 69 57 166 219 107 99 174 137 147 206 32 79 45 38 90 90 195 151

27 217 25 217 78 132 57 194 70 127 32 90 66 196 108 135 125 140 58 93

5.1 5.1 4.4 5.1 4.8 5.3 5.5 5.2 5.0 4.9 5.2 4.9 5.5 5.3 5.0 4.7 4.7 4.7 4.9 4.8

9 14 13 12 6 8 8 12 11 11 15 12 15 13 9 8 11 13 8 5

D D D 13 D D D D D 12 16 D D D D D 12 D 9 6

D 15 D 13 D D D D D 12 16 D 16 14 D D 12 D 9 D

294

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

the SILVA. The average computation time of an instance is 9.5 seconds for the RCCG and 3643 seconds for the SILVA. The former is only about 2.6% of the later. The RCCG may be faster than the SILVA. The RCCG solution to instance ATP42 is shown in Fig. A2 in Appendix A. It is optimal and the plater count (15) is smaller than that of the SILVA solution by one. From the computational results in this sub-section, it can be said that when the scale of the instances is large, the average solution quality of the RCCG may be better than that of the exact algorithm SILVA if the computation time is limited, and the RCCG may be faster than the SILVA. The statement is true at least for the instances in Set 2. This also indicates that the exact algorithm is not adequate when the instance-scale is large because of the unaffordable long computation time. 5.3. Comparing the RCCG with a commercial software package This subsection compares the RCCG with the Plus2D, a commercial stock cutting software package that can be obtained from http://www.nirvanatec.com (Plus 2D Metal Demo Version 9.11), using the three sets of instances in the previous two sub-sections and a set (Set 4) of practical instances. The Plus2D can generate two-staged, three-staged and more complex patterns. It is restricted to generate only two-staged patterns here. Both X- and Y-patterns are considered. The lower bound ZLB for the solution value of an instance is obtained in Step 1 of the RCCG (before rounding the fractional freP quencies) and is equal to d xk e, where xk denotes the frequency of the kth pattern. Table 5 lists the computational results for Set 1, where ZPlus2D is the solution value of the Plus2D. The number of instances solved to proven optimality is 10 for the RCCG and 8 for the Plus2D. Compared with the Plus2D, the RCCG yielded better solution in 4 instances (Gcut3dr, Gcut8dr, Gcut11dr and Gcut12dr) and the same in others.

Table 6 shows the computational results for Set 2. The number of instances solved to proven optimality is 28 for the RCCG and 26 for the Plus2D. Compared with the Plus2D, the RCCG yielded better solution in 2 instances (A4 and CHL6) and the same in others. Table 7 shows the computational results for Set 3. The number of instances solved to proven optimality is 16 for the RCCG and 12 for the Plus2D. Compared with the Plus2D, the RCCG yielded better solution in 4 instances (ATP32, ATP33, ATP37 and ATP40) and the same in others. Table 7 Computational results for Set 3. ID

ZLB

ZRCCG

ZPlus2D

ID

ZLB

ZRCCG

ZPlus2D

ATP30 ATP31 ATP32 ATP33 ATP34 ATP35 ATP36 ATP37 ATP38 ATP39

8 14 12 12 6 7 8 11 10 11

9 D D D D 8 D D D D

9 D 13 13 D 8 D 12 D D

ATP40 ATP41 ATP42 ATP43 ATP44 ATP45 ATP46 ATP47 ATP48 ATP49

15 12 15 12 9 8 11 12 8 5

D D D 13 D D D 13 D D

16 D D 13 D D D 13 D D

Table 8 Results for the practical instances. ZLB 2000  1830 2440  2000 3050  2440 3660  2440 4200  2900

ZRCCG

348 254 163 135 98

Area (m2) Gap (%)

ZPlus2D 356 264 171 140 103

D D D D D

6125

6125 0

6369 3.98

Table 9 Effect of parameter G. Table 5 Results for the instances in Set 1. ID

ZLB

ZRCCG

ZPlus2D

ID

ZLB

ZRCCG

ZPlus2D

Gcut1dr Gcut2dr Gcut3dr Gcut4dr Gcut5dr Gcut6dr

291 282 316 836 175 302

D D 317 D D D

D D 318 D D D

Gcut7dr Gcut8dr Gcut9dr Gcut10dr Gcut11dr Gcut12dr

542 650 125 270 299 601

D 651 D D D D

D 653 D D 300 603

Table 6 Computational results for Set 2. ID

ZLB

ZRCCG

ZPlus2D

ID

ZLB

ZRCCG

ZPlus2D

A1 A2 A3 A4 A5 CHL1 CHL2 CHL5 CHL6 CHL7 CU1 CU2 CW1 CW2 CW3

17 11 7 4 4 5 3 3 5 6 11 14 9 12 15

D D D D D 6 D D D D D D D D D

D D D 5 D 6 D D 6 D D D D D D

Hchl2 Hchl3s Hchl4s Hchl6s Hchl7s Hchl8s Hchl9 HH OF1 OF2 STS2 STS4 W 2 3

6 3 2 5 7 1 10 2 3 4 12 5 18 2 18

D D D D D 2 D D D D D D D D D

D D D D D 2 D D D D D D D D D

ID

ZLB

G=1

G=5

G = 10

G = 15

G = 30

A1 A2 A3 A4 A5 CHL1 CHL2 CHL5 CHL6 CHL7 CU1 CU2 CW1 CW2 CW3 Hchl2 Hchl3s Hchl4s Hchl6s Hchl7s Hchl8s Hchl9 HH OF1 OF2 STS2 STS4 W 2 3 Total

23 12 8 5 5 6 3 4 6 6 12 15 10 12 16 6 3 2 5 7 2 10 2 4 5 12 5 24 2 23 255

24 13 D D D 7 D 5 D 7 13 16 11 14 17 7 4 3 6 8 D 11 3 D D 13 7 D 3 24 278

D 13 D D D 7 D D D D 13 D D 14 D D D 3 6 D D D D D D D D D 3 24 264

23 13 8 5 5 6 3 4 6 6 12 15 10 13 17 7 3 3 5 8 2 10 2 4 5 12 5 24 2 24 262

D 13 D D D 7 D D D D D D D 13 D D D 3 D D D D D D D D D D D 24 260

D 13 D D D 7 D D D D D D D 13 D D D 3 D D D D D D D D D D D 24 260

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

295

Fig. A1. Cutting plan of the Gcut9dr for the non-orientated case.

The average computation time of the RCCG for an instance is 0.08 seconds for Set 1, 0.56 seconds for Set 2, and 20.82 seconds for Set 3. The average computation time of the Plus2D is longer than two times of that of the RCCG. Table 8 shows the computational results for 5 practical instances (Set 4), where the items data (see Appendix B) are the same for all instances, and the plate sizes are different. The items data were obtained from the practical cutting process of plate glass. The plate sizes are common in the glass industry of China. The total plate area and gap are listed in the bottom rows. The RCCG solved all instances to optimality. Its solutions are all better than those of the Plus2D. The material utilization of the RCCG is higher than that of the Plus2D by 3.98%. The average computation time of an instance is 22 seconds for the RCCG and 69 seconds for the Plus2D. 5.4. Effect of the G value Recall that parameter G (the number of strip sets) for the C_SLOPP procedure has default value 15. The effect of the G value

on the solution value of the RCCG is summarized in Table 9, using the instances in Set 2 and assuming oriented items. The total number (N) of plates used for each G value is listed in the last row. It is seen that the N value is the largest when G = 1 and smallest when G = 15 and G = 30. Other sets of instances were also tested. The results show that the N value usually decreases with the increase in G, and the smallest N value appears between G = 5 and G = 15. As a result, G 2 [5, 15] may be adequate.

6. Conclusions The algorithm RCCG in this paper solves the two-dimensional single stock size cutting stock problem with two-staged patterns and rotation of items. It calls the column-generation approach repeatedly to solve the residual problems until all demands are satisfied. The convergence of the algorithm is guaranteed by solving the constrained single large object placement problem to generate the cutting patterns.

296

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

Fig. A2. RCCG solution to instance ATP42.

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

297

Fig. A2 (continued)

Table B1 Items data of the practical instances. 1749, 524, 8 1659, 594, 4 1614, 524, 10 1177, 924, 24 1121, 524, 156 1104, 524, 8 934, 614, 8 788, 989, 160 765, 1259, 16 718, 948, 4 524, 1589, 48 507, 789, 8

488, 1319, 32 400, 1273, 16 1704, 594, 8 1659, 524, 16 1384, 524, 12 1167, 924, 24 1114, 514, 16 1084, 524, 10 934, 514, 8 788, 1319, 16 778, 989, 16 765, 989, 48

519, 1589, 48 490, 1273, 32 488, 989, 328 1704, 524, 96 1659, 474, 16 1121, 594, 16 1104, 724, 8 1074, 596, 2 874, 596, 4 788, 1259, 32 765, 1319, 8 743, 989, 20

Two-staged patterns are simple to cut than most pattern types, and are widely used in practice. The algorithm can generate the cutting plans quickly, and solve most instances to optimality. The comparisons among the approaches indicate that the algorithm is

628, 939, 8 507, 989, 56 490, 973, 32 478, 989, 36 368, 948, 4 400, 973, 16 1284, 514, 28 575, 973, 56 1273, 575, 60 1359, 514, 16 612, 973, 32 1359, 614, 16

612, 1273,32 1184, 514, 4 525, 973, 8 1273, 525, 4 1214, 614, 4 540, 1273, 8 1214, 514, 4 540, 973, 8 810, 989, 16 628, 989, 16

effective in reducing the number of plates used (the statement is true at least for the instances tested). Future research work may include the use of the RCCG frame to solve the two-dimensional cutting stock problem with other types

298

Y. Cui, Z. Zhao / European Journal of Operational Research 231 (2013) 288–298

of cutting patterns, such as T-shape patterns (Cui and Huang, 2013), three-staged patterns (Cui and Huang, 2012), and general guillotine patterns (Armas et al., 2012). Acknowledgment This research is part of Project 61063031 supported by National Natural Science Foundation of China. Appendix A. RCCG solutions to 2 benchmark instances The RCCG solution to Gcut9dr is shown in Fig. A1. Its plate count (125) is smaller than that of the CGRp (Cintra et al., 2008) solution by one. The frequencies of the 11 patterns are respectively 17, 10, 6, 9, 7, 3, 15, 11, 20, 26 and 1. The RCCG solution to instance ATP42 is shown in Fig. A2. Its plate count (15) is smaller than that of the SILVA (Silva et al., 2010) solution by one. The frequencies of the 15 patterns are all 1. Appendix B. Items data of the practical instances The items data are the same for the five practical instances. There are 58 item types. The three numbers in each group denote the length, width and demand of an item type (see Table B1). References Alvarez-Valdes, R., Parajon, A., Tamarit, J.M., 2002. A computational study of LPbased heuristic algorithms for two-dimensional guillotine cutting stock problems. OR Spectrum 24, 179–192. Armas, J., Miranda, G., Leon, C., 2012. Improving the efficiency of a best-first bottom-up approach for the constrained 2D cutting problem. European Journal of Operational Research 219, 201–213. Belov, G., Scheithauer, G., 2007. Setup and open stacks minimization in onedimensional stock cutting. INFORMS Journal on Computing 19, 27–35. Cintra, G.F., Miyazawa, F.K., Wakabayashi, Y., Xavier, E.C., 2008. Algorithms for twodimensional cutting stock and strip packing problems using dynamic programming and column generation. European Journal of Operational Research 191, 61–85.

Cui, Y., Huang, B., 2012. Reducing the number of cuts in generating three-staged cutting patterns. European Journal of Operational Research 218, 358–365. Cui, Y., Huang, B., 2013. Heuristic for constrained T-shape cutting patterns of rectangular pieces. Computers and Operations Research 39, 3031–3039. Cui, Y., Liu, Z., 2011. C-Sets-based sequential heuristic procedure for the onedimensional cutting stock problem with pattern reduction. Optimization Methods and Software 26, 155–167. Cui, Y., Yang, Y., 2011. A recursive branch-and-bound algorithm for constrained homogenous T-shape cutting patterns. Mathematical and Computer Modelling 54, 1320–1333. Cui, Y., Yang, Y., 2012. Extended block patterns for the two-dimensional cutting stock problem. Engineering Optimization 44, 657–672. Gilmore, P., Gomory, R., 1961. A linear programming approach to the cutting stock problem. Operations Research 9, 849–859. Hifi, M., 2001. Exact algorithms for large-scale unconstrained two and three staged cutting problems. Computational Optimization and Applications 18, 63–88. Hifi, M., M’Hallah, R., 2005. An exact algorithm for constrained two-dimensional two-staged cutting problems. Operations Research 53, 140–150. Hifi, M., M’Hallah, R., 2006. Strip generation algorithms for constrained twodimensional two-staged cutting problems. European Journal of Operational Research 172, 515–527. Hifi, M., M’Hallah, R., Saadi, T., 2008. Algorithms for the constrained two-staged two-dimensional cutting problem. INFORMS Journal on Computing 20, 212– 221. Hifi, M., Saadi, T., 2012. A parallel algorithm for two-staged two-dimensional fixedorientation cutting problems. Computational Optimization and Applications 51, 783–807. Lodi, A., Monaci, M., 2003. Integer linear programming models for 2-staged twodimensional knapsack problems. Mathematical Programming 94, 257–278. Lodi, A., Martello, S., Vigo, D., 2004. Models and bounds for two-dimensional level packing problems. Journal of Combinatorial Optimization 8, 363–379. Macedo, R., Alves, C., Valério de Carvalho, J.M., 2010. Arc-flow model for the twodimensional guillotine cutting stock problem. Computers and Operations Research 37, 991–1001. Poldi, K.C., Arenales, M.N., 2009. Heuristics for the one-dimensional cutting stock problem with limited multiple stock lengths. Computers and Operations Research 36, 2074–2081. Silva, E., Alvelos, F., Valério de Carvalho, J.M., 2010. An integer programming model for two- and three-stage two-dimensional cutting stock problems. European Journal of Operational Research 205, 699–708. Suliman, S.M.A., 2006. A sequential heuristic procedure for the two-dimensional cutting-stock problem. International Journal of Production Economics 99, 177– 185. Wäscher, G., Haußner, H., Schumann, H., 2007. An improved typology of cutting and packing problems. European Journal of Operational Research 183, 1109–1130.