One-dimensional cutting stock problem for a paper tube industry∗ Kazuki Matsumoto†

Shunji Umetani‡

Hiroshi Nagamochi§

Abstract The one-dimensional cutting stock problem (1D-CSP) is one of the representative combinatorial optimization problems, which arises in many industrial applications. Although the primary objective of 1D-CSP is to minimize the total length of used stock rolls, efficiency of cutting process has become more important to be considered in recent years. The crucial bottleneck of cutting process often occurs at handling operations in semiautomated manufactures such as a paper tube industry. To reduce interruptions and errors at handling operations in a paper tube industry, we consider a variant of 1D-CSP that minimizes the total length of used stock rolls while constraining (C1) the number of setups of each stock roll type, (C2) the combination of piece lengths occurred in open stacks simultaneously, and (C3) the number of open stacks. For this problem, we propose a generalization of the cutting pattern called the “cutting group,” each of which is a sequence of cutting patterns that satisfies the given upper bounds of setups of each stock roll type and open stacks. To generate good cutting groups, we decompose the 1D-CSP into a number of auxiliary bin packing problems. We develop a tabu search algorithm based on a shift neighborhood that solves the auxiliary bin packing problems by the first-fit decreasing heuristic algorithm. Experimental results show that our algorithm improves the quality of solutions compared to the existing algorithm used in a paper tube factory.

Keywords: one-dimensional cutting stock problem, paper tube industry, open stack, local search, tabu search.

1

Introduction

The one-dimensional cutting stock problem (1D-CSP) is one of the representative combinatorial problems, which is known to be NP-hard Garey and Johnson (1979), and it arises in many industries such as steel, paper, wood, glass and fiber. This problem is often formulated as an integer programming (IP) problem with a strong linear programming (LP) relaxation problem. In this model, a cutting plan (or solution) is described in terms of variables associated with cutting patterns, where a cutting pattern (or pattern) is a set of pieces that can be cut from one stock roll. Since the number of all feasible cutting patterns is huge in practice, Gilmore and Gomory (1961, 1963) proposed an ingenious column generation method, which generates necessary cutting patterns to improve the incumbent solution of its linear programming (LP) relaxation by solving an associated bounded knapsack problem. Based on this, a number of branch-and-price algorithms have been developed with certain computational success Belov and Scheithauer (2006); Degraeve and Schrage (1999); Degraeve and Peeters (2003); Vance (1998); Vanderbeck (1999). Although the primary objective of 1D-CSP is to minimize the total length of used stock rolls, improving the efficiency of cutting process has become a more dominant factor in recent applications, in particular, reducing interruptions of cutting process plays a crucial role in designing cutting plans. One of the common bottlenecks of cutting process is frequent setups due to many ∗

The final publication is available at Springer via DOI: 10.1007/s10951-010-0164-2. Graduate School of Informatics, Kyoto University, Kyoto 606-8501, Japan ‡ Graduate School of Information Science and Technology, Osaka University, Suita 565-0871, Japan § Graduate School of Informatics, Kyoto University, Kyoto 606-8501, Japan †

1

different cutting patterns used in a cutting plan. To reduce the number of different cutting patterns, several types of algorithms have been developed Belov and Scheithauer (2003); Foerster and W¨ascher (2000); Haessler (1971, 1975); Umetani et al. (2003, 2006). Another common bottleneck is to manage many open stacks. In some applications such as the glass industry, open stacks of cut pieces occupy some space near the cutting machine until they are completed and shipped, while the available space is rather limited. Hence, several algorithms have been developed to reduce the maximum number of open stacks by sequencing cutting patterns appropriately Becceneri et al. (2004); Fink and Voß (1999); Foerster and W¨ ascher (1998); Madsen (1988); Yanasse (1997); Yanasse and Lamosa (2007); Yuen (1991, 1995); Yuen and Richardson (1995). Furthermore, Belov and Scheithauer (2007) developed an integrated heuristic algorithm to reduce the numbers of different cutting patterns and open stacks simultaneously. In semiautomated manufactures such as a paper tube industry, the crucial bottleneck of cutting process often occurs at handling operations. The paper tube is used in a wide variety of goods such as rolled fax paper, toilet paper and plastic wraps. For a given cutting plan, the cutting process of a paper tube factory proceeds as follows: (i) stock rolls are set up into a cutting machine by a human operator, where the human operator has to stop the machine to set up new stock rolls whenever stock roll types change; (ii) stock rolls are cut into pieces by the cutting machine, which can change the position of cutter knives automatically according to the given cutting plan; (iii) the cut pieces are assorted into their piece types and stacked on a worktable by the human operator. In a cutting process, changing stock roll types and assorting cut pieces into their piece types are done by a human operator, while changing positions of cutter knives are fully automated. To reduce interruptions and errors at handling operations, we consider a variant of 1D-CSP that minimizes the total length of used stock rolls while constraining (C1) the number of setups of each stock roll type, (C2) the combination of piece lengths occurred in open stacks simultaneously, and (C3) the number of open stacks. For this problem, we propose a generalization of the cutting pattern called the “cutting group,” which is a sequence of cutting patterns that satisfies the given upper bounds of setups of each stock roll type and open stacks. To generate good cutting groups, we decompose the 1D-CSP into a number of auxiliary bin packing problems. We develop a tabu search algorithm based on a shift neighborhood that solves the auxiliary bin packing problems by the first-fit decreasing (FFD) heuristic algorithm. This paper is organized as follows. We first formulate 1D-CSP for the paper tube industry called the paper tube cutting stock problem (PTCSP) in Section 2. We then propose the cutting group approach and reformulate PTCSP as the cutting group based PTCSP (CG-PTCSP) in Section 3. We explain our tabu search algorithm for CG-PTCSP in Section 4. Finally, we report experimental results in Section 5 and make concluding remarks in Section 6.

2

Formulation

In the standard 1D-CSP, we are given n stock roll types N = {1, 2, . . . , n} and m piece types M = {1, 2, . . . , m}, where each stock roll type h has its length Lh and is assumed to be sufficiently supplied, and each piece type i has its length li and demand di . A cutting pattern is described as pj = (a1j , a2j , . . . , amj , wj ), where aij ∈ Z+ (the set of nonnegative integers) is the number of pieces of type i to be cut from cutting pattern pj and wj ∈ N is the index of stock roll type to be used for pj . A cutting pattern pj is feasible if it satisfies X aij li ≤ Lwj . (1) i∈M

Let S denote the set of all feasible cutting patterns. A solution for the standard 1D-CSP consists of a set of cutting patterns P = {p1 , p2 , . . . , p|P | } ⊆ S and their frequencies (i.e., the number of applications) X = {x1 , x2 , . . . , x|P | }. The primary objective is to minimize the total length of used 2

stock rolls, and the standard 1D-CSP is formulated as follows. X (CSP) minimize Lwj xj pj ∈P

subject to

X

aij xj = di

(i ∈ M ),

(2)

pj ∈P

P ⊆ S, xj ∈ Z+

(pj ∈ P ).

In the paper tube industry, as explained in Section 1, we need to consider a different situation from the standard 1D-CSP. Cut pieces of the same type on a worktable are bundled into lots, which will be shipped from the workroom. For each piece type i, a lot size bi is prescribed, and hence ddi /bi e lots of type i pieces will be shipped in a cutting plan. During a cutting process, cut pieces are assorted into their piece types, and are stacked on a worktable until the number of stacked pieces of type i reaches its lot size bi . These stacks of uncompleted lots are called the open stacks. If stock roll types change many times in a cutting plan, the human operator needs much time for setup and may set wrong stock rolls in the machine. Similarly, if many types of cut pieces occur on the worktable simultaneously, the human operator needs much time for assortment and may make wrong stacks. Similar lengths of different piece types are also confusing when they occur on the worktable simultaneously. Hence, we consider the following constraints in the 1D-CSP of the paper tube industry. (C1) Setups of each stock roll type should be at most once. (C2) The minimum difference of piece lengths of different types occurred on the worktable simultaneously should be greater than or equal to a given bound ∆LB . (C3) The maximum number of open stacks should be less than or equal to a given bound ρUB . Based on this, we now consider an extension of the standard 1D-CSP. The 1D-CSP of the paper tube industry requires to minimize the total length of used stock rolls while satisfying the constraints (C1), (C2) and (C3), which we call the paper tube cutting stock problem (PTCSP). A solution of PTCSP is given by a tuple (P, X, Π) of a set P of cutting patterns, a set X of frequencies of cutting patterns in P , and a sequence Π = (π1 , π2 , . . . , π|P | ) of cutting patterns in P , where πk denotes the k-th pattern in Π. We denote the number of setups of stock roll type h by δh (P, X, Π), the minimum difference of piece lengths of different types occurred on the worktable simultaneously by ∆(P, X, Π), and the maximum number of open stacks by ρ(P, X, Π), respectively. Then, PTCSP is formulated as follows. X (PTCSP) minimize f (P, X) = Lwj xj pj ∈P

subject to

X

aij xj = di

(i ∈ M ),

pj ∈P

P ⊆ S, δh (P, X, Π) ≤ 1 (h ∈ N ), ∆(P, X, Π) ≥ ∆LB , ρ(P, X, Π) ≤ ρUB , xj ∈ Z+ (pj ∈ P ).

(3)

Figure 1 illustrates an instance of PTCSP (in this example the maximum number of open stacks is three). The constraints (C1), (C2) and (C3) introduce new decision variables Π = (π1 , π2 , . . . , π|P | ) into the standard 1D-CSP. We note that combining pattern generation and sequencing patterns makes PTCSP much harder than the standard 1D-CSP. 3

stock rolls

piece orders

cutting plan

3 4 2 1

L1

L2

1

2

1

2

1

3 di 4 4 6 6 bi 2 2 2 3

2

1 4 4

#open stacks

3

3

3

3

4

1

3

44 1

3

2

4

4 4

2 2

1 3

4

1

44 worktable (open stacks)

Figure 1: An instance of PTCSP.

3

Cutting group approach

Since customer orders occur many times in a day in a paper tube factory, it is necessary to solve many instances of PTCSP quickly. We accordingly develop a fast heuristic algorithm to solve PTCSP within a few minutes. For this purpose, we propose an extension of the cutting pattern called the cutting group and reformulated PTCSP by the cutting group. A cutting group is a set of pieces to be cut from a number of stock rolls of the same type, and is described as p˜j = (˜ a1j , a ˜2j , . . . , a ˜mj , w ˜j , λj ), where a ˜ij ∈ Z+ is the number of pieces of type i to be cut from p˜j , w ˜j ∈ N is the index of a stock roll type used for p˜j , and λj ∈ Z+ is the number of stock rolls of type w ˜j used in p˜j . A set Aj of the numbers a ˜ij of pieces of type i, i ∈ M is called feasible if it satisfies |li1 − li2 | ≥ ∆LB X

a ˜ij

= k · bi

cij

≤ ρUB ,

(i1 6= i2 , a ˜i1 j > 0, a ˜i2 j > 0),

(4)

(0 ≤ k ≤ si , k, si ∈ Z+ ),

(5) (6)

i∈M

where si = ddi /bi e (i.e., the number of lots of piece type i), and cij = 1 if a ˜ij > 0 holds and cij = 0 otherwise. Figure 2 shows a cutting plan in terms of cutting groups for an instance of PTCSP (in this example the maximum number of open stacks is two). A cutting group p˜j = (˜ a1j , a ˜2j , . . . , a ˜mj , w ˜j , λj ) is feasible if the set Aj = {˜ aij | i ∈ M } is feasible j j j and there is a sequence Πj of λj feasible cutting patterns (α1k , α2k , . . . , αmk , w ˜j ), k = 1, 2, . . . , λj P j j such that 1≤k≤λj αik =a ˜ij , i ∈ M , where αik denotes the number of type i pieces cut from the k-th stock roll. Given a feasible set Aj = {˜ aij | i ∈ M } and a stock roll type w ˜j , the problem of finding the minimum λj that admits a feasible cutting group p˜j is defined by the following bin

4

stock rolls

L2

L1

piece orders

group 1

3 4 2 1

1

di 4 4 6 6 bi 2 2 2 3

1 3

#open stacks

group 2

3

2 2

1

3

4 2 4 4 4 2 4 4

1 3

<ρUB

group 3

0

<ρUB

3 3

0

<ρUB

Figure 2: A cutting plan in terms of cutting groups.

packing problem (BPP): (BPP) λj = minimize

q X

yk

k=1

subject to

q X k=1 X

j =a ˜ij αik j li αik

(i ∈ M ),

≤ Lw˜j yk

(7) (k = 1, 2, . . . , q),

i∈M

yk ∈ {0, 1} (k = 1, 2, . . . , q), j ∈ Z+ (i ∈ M ; k = 1, 2, . . . , q), αik P where q is set to i∈M a ˜ij as a trivial upper bound on the minimum λj , and yk = 1 if the k-th stock roll is used and yk = 0 otherwise. The best cutting group p˜j for a given feasible set Aj can be found by solving the above BPP for every stock roll type w ˜j ∈ N and selecting the best candidate that minimizes the total length of used stock rolls Lw˜j λj . Since BPP is known to be NP-hard Garey and Johnson (1979), we construct a cutting group p˜j by a well-known heuristic algorithm called the first-fit decreasing algorithm (FFD) for BPP. The FFD first sorts all pieces of the cutting group p˜j in the descending order of their lengths. It then sequentially assigns all pieces in this order, in which each piece is assigned to the stock roll of the lowest index with sufficient residual stock length. The procedure of FFD is described as follows. Algorithm FFD Input: A feasible set Aj = {˜ aij | i ∈ M } of numbers of pieces, and a stock roll type w ˜j ∈ N . j Output: The number λj of stock roll and the number of pieces αik of each type i cut from the k-th stock roll (if λj > 0 holds).

Step 1: If the cutting group p˜j is empty (i.e., a ˜ij = 0 for all i ∈ M ), then output λj = 0 and halt. Step 2: Sort all piece types i in the descending order of their lengths li , where σ(r) denotes the r-th piece type in this order. Set r ← 1. Step 3: If r > m then go to Step 5; otherwise set v ← a ˜σ(r)j and k ← 0; Step 4: If v = 0 then set r ← r + 1 and return to Step 3; otherwise set k ← k + 1, P j j j ασ(r)k ← b(Lw˜j − 1≤r0 ≤r−1 ασ(r 0 )k lσ(r 0 ) )/lσ(r) c, v ← v − ασ(r)k , and return to Step 4. 5

j j j Step 5: Halt outputting (α1k , α2k , . . . , αmk ) for k = 1, 2, . . . , λj , where λj is the maximum k such j that αik > 0 for some i ∈ M .

The main idea in this paper is to construct a cutting plan as a sequence of feasible cutting groups. Note that all open stacks are cleared at the end of every cutting group by (5). Hence any such cutting plan satisfies the constraints (C2) and (C3), since the increase of open stacks is constrained within ρUB by (6) and the minimum difference of piece lengths of different types is not less than ∆LB by (4). The constraint (C1) is also satisfied as long as the cutting groups using the same stock roll type appear consecutively in the sequence. Using feasible cutting groups, we reformulate PTCSP as a 0-1 integer linear programming problem (0-1IP), which we call the cutting group based paper tube cutting stock problem (CGe = {˜ PTCSP), where Se denotes the set of all feasible cutting groups and X x1 , x ˜2 , . . . , x ˜|S| e } denotes the application of cutting groups. X e = Lw˜j λj x ˜j (CG-PTCSP) minimize f (X) e p˜j ∈S

X

subject to

a ˜ij x ˜j = di

(i ∈ M ),

(8)

e p˜j ∈S

e x ˜j ∈ {0, 1} (˜ pj ∈ S). We note that CG-PTCSP is a restricted problem of the original PTCSP, and the optimal value of CG-PTCSP would be worse than that of PTCSP in most cases. However, constructing feasible solutions to CG-PTCSP is considerably easier than that to the original PTCSP.

4

Tabu search algorithm

Since the number of all feasible cutting groups grows exponentially compared with the number of piece types, a 0-1IP formulation of CG-PTCSP has an enormous number of variables in general. For finding a solution to CG-PTCSP, we propose a variant of local search called tabu search. Local search (LS) starts from an initial feasible solution and iteratively replaces it with a better solution in its neighborhood until it reaches a local optimal solution; i.e., no better solution is contained in the neighborhood. It is often the case that LS alone may not attain a sufficiently good solution. To improve the situation, many variants have been developed, and their framework is called metaheuristics. Since we need to solve PTCSP within a little computation time in the paper tube industry while sophisticated metaheuristic approaches need much computation time, we introduce a simple modification of LS called tabu search (TS), which continues to replace the current solution with its best neighbor even after attaining local optimality. To avoid visiting the same set of solutions cyclically, TS maintains a tabu list which stores a set of solutions including those recently visited, and chooses the best solution among the candidates not contained in the tabu list. e that is, In our TS, a solution is given by a set of m cutting groups Pe = {˜ p1 , p˜2 , . . . , p˜m } ⊆ S, e x ˜j = 1 if p˜j ∈ P holds and x ˜j = 0 otherwise. In the rest of this paper, we consider CG-PTCSP with the following form. X (CG-PTCSP) minimize f (Pe) = Lw˜j λj p˜j ∈Pe

subject to

X

a ˜ij = di

(i ∈ M ),

(9)

p˜j ∈Pe

e Pe ⊆ S. Our TS first generates an initial feasible solution such that the j-th cutting group p˜j includes dj pieces of type j (Figure 3). It is obvious that such a cutting group p˜j satisfies constraints (4), (5) 6

group 1 1

group m

group 2 1

2

2

2

2

m

m

m

m

m

1 2

#open stacks

<ρUB

0

<ρUB

0

0

<ρUB

Figure 3: An initial feasible solution of CG-PTCSP.

and (6). Our TS repeats replacing the current set of cutting groups Pe with the best set of cutting groups Pe0 in its neighborhood N B(Pe) except for the current solution Pe and solutions prohibited by the tabu list T . The procedure of our TS is described as follows. Algorithm Tabu Search Input: A set of stock roll types N = {1, 2, . . . , n} with their lengths Lh , and a set of piece types M = {1, 2, . . . , m} with their lengths li , demands di and lot sizes bi . The parameters ∆LB and ρUB specifying the constraints (C2) and (C3), respectively. Output: A set of cutting groups Pe∗ = {˜ p∗1 , p˜∗2 , . . . , p˜∗m }. Step 1: Construct an initial solution Pe and initialize the tabu list T . Set Pe∗ ← Pe. Step 2: Select the solution Pe0 ∈ N B(Pe) \ ({Pe} ∪ T ) with the minimum total length of used stock rolls f (Pe0 ). Set Pe ← Pe0 . If f (Pe) < f (Pe∗ ) holds, then set Pe∗ ← Pe. Step 3: If the time limit is reached, then output Pe∗ and halt; otherwise update the tabu list T and return to Step 2. A natural definition of neighborhood for the current set of cutting groups Pe would be the set of all solutions obtained by replacing one cutting group p˜j ∈ Pe with another feasible cutting group e grows exponentially with the p˜0j ∈ Se \ Pe. However, the number of all feasible cutting groups |S| number of piece types m, and most of them may not lead to improvement. To overcome this, we use only similar cutting groups to those in the current set Pe in the search, and we propose the shift neighborhood N Bshift defined as follows: N Bshift (Pe) = {Pe ∪ {˜ p1 (k1 , k2 , i0 ), p˜2 (k1 , k2 , i0 )} \ {˜ pk1 , p˜k2 } | p˜k1 , p˜k2 ∈ Pe, i0 ∈ M }, where p˜1 (k1 , k2 , i0 ) and p˜2 (k1 , k2 , i0 ) are the cutting groups generated by applying the shift operation that moves bi0 pieces of a type i0 from p˜k1 to p˜k2 . Given two cutting groups p˜k1 = (˜ a1k1 , a ˜2k1 , . . . , a ˜mk1 , w ˜k1 , λk1 ) and p˜k2 = (˜ a1k2 , a ˜2k2 , . . . , a ˜mk2 , 0 e w ˜k2 , λk2 ) ∈ P and a piece type i with a ˜i0 k1 ≥ bi0 , the shift operation first moves bi0 pieces of the type i0 from p˜k1 to p˜k2 if the cutting group p˜k2 satisfies the constraints (4) and (6) after moving the pieces. It then generates candidates of the new cutting groups p˜1 (k1 , k2 , i0 ) = (˜ a01k1 , a ˜02k1 , . . . , a ˜0mk1 , w ˜k0 1 , λ0k1 ) and p˜2 (k1 , k2 , i0 ) = (˜ a01k2 , a ˜02k2 , . . . , a ˜0mk2 , w ˜k0 2 , λ0k2 ) by applying FFD to the cutting groups p˜k1 and p˜k2 for all stock roll lengths L1 , L2 , . . . , Ln and selects the best candidates that minimize the total lengths of used stock rolls λ0k1 Lw˜k0 and λ0k2 Lw˜k0 , respectively. The procedure of the shift operation 1 2 is described as follows, where c0ij = 1 if a ˜0ij > 0 holds and c0ij = 0 otherwise. 7

Procedure Shift Operation Input: A pair of cutting groups p˜k1 = (˜ a1k1 , a ˜2k1 , . . . , a ˜mk1 , w ˜k1 , λk1 ) and p˜k2 = (˜ a1k2 , a ˜2k2 , . . . , a ˜mk2 , 0 e w ˜k2 , λk2 ) ∈ P , a piece type i and an integer bi0 with a ˜i0 k1 ≥ bi0 ≥ 1. Output: A pair of new cutting groups p˜1 (k1 , k2 , i0 ) = (˜ a01k1 , a ˜02k1 , . . . , a ˜0mk1 , w ˜k0 1 , λ0k1 ) and p˜2 (k1 , k2 , i0 ) = (˜ a01k2 , a ˜02k2 , . . . , a ˜0mk2 , w ˜k0 2 , λ0k2 ), or ’failure’. ˜0ik1 ← a ˜ik1 and a ˜0ik2 ← a ˜ik2 for all ˜0i0 k2 ← a ˜i0 k2 + bi0 , and set a Step 1: Set a ˜0i0 k1 ← P a ˜i0 k1 − bi0 , a 0 0 0 0 ˜i1 k2 > 0, a ˜i2 k2 > 0} < ∆LB holds, i ∈ M \ {i }. If i∈M cik1 > ρUB or min{|li1 − li2 | | i1 6= i2 , a then output ’failure’ and halt. Step 2: Apply FFD to the new cutting groups p˜1 (k1 , k2 , i0 ) and p˜2 (k1 , k2 , i0 ) for all stock roll lengths L1 , L2 , . . . , Ln to compute the minimum total lengths of used stock rolls λ0k1 Lw˜k0 1 and λ0k2 Lw˜k0 , respectively. Output new cutting groups p˜1 (k1 , k2 , i0 ) and p˜2 (k1 , k2 , i0 ) and the 2 numbers of stock rolls λ0k1 and λ0k2 , and halt. The aim of introducing a tabu list T is to prevent cycling over a small set of solutions and to attain a short diversification of the search. A straightforward realization of a tabu list T is to keep explicitly all the solutions to be excluded from serving as candidates. We adopt a more popular one that defines T implicitly by prohibiting the reverse moves of those moves which were executed recently. To be precise, in each iteration of our TS, we prepare only a list H that keeps the attributes of the last m moves, which defines T as the set of solutions obtained from the current solution Pe by the moves that use some attributes in H. In our TS, an element (i, j) in a list H means that there was a shift of pieces of a type i to a cutting group p˜j among the last m moves, and the tabu list T is described as follows: T = {Pe ∪ {˜ p1 (k1 , k2 , i0 ), p˜2 (k1 , k2 , i0 )} \ {˜ pk1 , p˜k2 } | (i0 , k2 ) ∈ H}.

5

Experimental results

We conducted computational experiment for two types of instances: random instances generated by a modification of CUTGEN Gau and W¨ascher (1995) and instances taken from real application in a paper tube factory in Japan, which are available online Umetani (2009). We compared our tabu search algorithm based on the cutting group approach (TS-CG) with the following two algorithms: a standard column generation algorithm for multiple stock lengths (CGM) Gilmore and Gomory (1961, 1963) for the standard 1D-CSP and a heuristic algorithm used in the paper tube factory, called the pattern generation heuristic (PGH). The PGH sequentially constructs a cutting plan by preferably selecting such patterns that result in a small trim loss (i.e., waste of stock roll) on long stock rolls. This is similar to the sequential heuristic procedure (SHP) proposed by Haessler (1971, 1975). We note that PGH does not necessarily construct a feasible cutting plan for PTCSP. We also note that CGM is applied to a continuous version of the standard 1D-CSP; i.e., CGM solved the relaxed PTCSP without the constraints (C1), (C2), (C3) and integrality on variables. All algorithms were coded in C language and run on IBM personal computer (Intel Core2 Duo 1.8GHz, 2GB memory). The CGM utilizes a general LP solver GLPK 4.9 (GNU Linear Programming Kit) Makhorin (2000). We first conducted computational experiment for the random instances generated by a modification of CUTGEN Gau and W¨ ascher (1995) dealing with multiple stock lengths and lot sizes of piece types. We generated 48 random instances, which are defined by combining different values of parameters n, m, Lmin , Lmax , ν1 , ν2 , bmin , bmax , smin , smax . The minimum and maximum stock lengths are Lmin and Lmax , and other stock lengths are random integer variables taken from interval [Lmin , Lmax ]. The piece lengths li are random integer variables taken from [ν1 Lmin , ν2 Lmax ]. The lot sizes bi and the number of lots si are random integer variables taken from [bmin , bmax ] and [smin , smax ], 8

Ratio (%) of the total trim loss

8.5 8 7.5 7 6.5 6 5.5 5 4.5 4 0

500

1000

1500 2000 Iteration

2500

3000

3500

Figure 4: The ratio (%) of the total trim loss of the current solution at every iteration of TS-CG on instance F6.

respectively, and demand di of each piece type i is set by di = bi si . In our experiment, n was set to 1 and 4, m was set to 10, 30 and 50, (Lmin , Lmax ) was set to (1000, 1000) and (1000, 3000), (ν1 , ν2 ) was set to (0.01, 0.2) and (0.2, 0.8), (bmin , bmax ) was set to (1, 10) and (5, 10), and (smin , smax ) was set to (1, 5) and (5, 10). Table 1 summarizes the information of the random instances, where d¯ denotes the average of demands (d1 , d2 , . . . , dm ). We compared TS-CG with CGM and PGH for the random instances, where we set the time limit of TS-CG to 180 seconds, ∆LB = 50 and ρUB = 4. Table 2 illustrates the computational results and CPU time in seconds of CGM, PGH and TS-CG, where #sc is the number of changes of stock roll types, vs is the ratio (%) of used stock rolls violating the constraint (C2) to all used stock rolls, #os is the maximum number of open stacks, and tloss is the ratio (%) of the total trim loss: P  P d l 100 L λ − ˜j j i∈M i i p˜j ∈Pe w P tloss = . (10) L ˜j λj p˜j ∈Pe w We note that CPU time of TS-CG is the time spent to find the best solution in the run. We also note that we did not test PGH for large instances (m = 50) because of limit on the input size of the program. From Table 2, we first observed that PGH and TS-CG attained small trim loss close to that of CGM for most instances. However, PGH often violated the constraints (C1), (C2) and (C3) for instances in which the ratio of piece lengths li to the stock lengths [Lmin , Lmax ] is relatively small. The TS-CG satisfied all constraints for all instances using small numbers of additional stock rolls. We next conducted computational experiment for the real-world instances provided by a paper tube factory in Japan. There are six instances with n ranging from 1 to 4, m ranging from 14 to 17, Lh ranging from 1300 to 2100, bi ranging from 5 to 12, di ranging from 10 to 420, and li ranging from 66 to 1058. Table 3 summarizes the information of the real-world instances, where d¯ denotes the average of demands (d1 , d2 , . . . , dm ), and lmin and lmax denote the minimum and maximum piece lengths, respectively. We compared TS-CG with CGM and PGH for the real-world instances, where we set the time limit of TS-CG to 180 seconds and ∆LB = 50 and ρUB = 4. Table 4 illustrates the computational results and CPU time in seconds of CGM, PGH and TS-CG, where CPU time of TS-CG is the time spent to find the best solution in the run. From Table 4, we first observed that PGH and TS-CG attained small trim loss. However, PGH violated the constraints (C1), (C2) and (C3) for some instances while TS-CG satisfied all of them. Figure 4 illustrates the ratio (%) of the total trim loss of the current solution at every iteration of TS-CG on instance F6. For this instance, TS-CG generated 486,411 cutting groups and moved 9

the current solution 3420 times within the time limit (180 seconds). We observed that TS-CG first attained a good solution within a little CPU time and explored better solutions with most of CPU time. Our TS-CG has been employed in the planning system in the paper factory in Japan. Human operators in the factory complete their cutting processes according to new cutting plans generated by TS-CG more quickly than those generated by PGH. To be specific, a new cutting plan generated by TS-CG reduced setup time by 17 minutes per day on average and saved 140,000 yen a year in costs for each production line.

6

Conclusion

In this paper, to reduce interruptions and errors at handling operations in a paper tube industry, we consider a variant of 1D-CSP called the paper tube cutting stock problem (PTCSP) that minimizes the total length of used stock rolls while constraining (C1) the number of setups of each stock roll type, (C2) the combination of piece lengths occurred in open stacks simultaneously, and (C3) the number of open stacks. For this problem, we propose a generalization of the cutting pattern called the cutting group to decompose PTCSP into a number of auxiliary bin packing problems (BPP) that naturally satisfy the given bounds of setups of each stock roll type and open stacks. We then consider a reformulation of PTCSP through the cutting groups approach, called the cutting group based PTCSP (CG-PTCSP). We develop a tabu search algorithm based on a shift neighborhood that solves the auxiliary BPP by the first-fit decreasing (FFD) heuristic algorithm. We conducted computational experiments for random instances and real-world instances in a paper tube factory, and observed that our algorithm TS-CG attained comparable trim loss to the existing algorithms while satisfying all constraints of PTCSP.

Acknowledgments This research was partially supported by Grant-in-Aid for Scientific Research from the Ministry of Education, Culture, Sports, Science and Technology of Japan.

References Becceneri, J. C., Yanasse, H. H., Soma, N. Y., 2004. A method for solving the minimization of the maximum number of open stacks problem within a cutting process. Computers and Operations Research 31, 2315–2332. Belov, G., Scheithauer, G., 2003. The number of setups (different patterns) in one-dimensional stock cutting. Technical Report, Institute of Numerical Mathematics, Technishe Universit¨at Dresden. Belov, G., Scheithauer, G., 2006. A branch-and-cut-and-price algorithm for one-dimensional stock cutting and two-dimensional stock cutting and two-dimensional two-stage cutting. European Journal of Operational Research 171, 85–106. Belov, G., Scheithauer, G., 2007. Setup and open-stacks minimization in one-dimensional stock cutting. INFORMS Journal on Computing 19, 27–35. Degraeve, Z., Schrage, L., 1999. Optimal integer solutions to industrial cutting stock problems. INFORMS Journal on Computing 11, 406–419. Degraeve, Z., Peeters, M., 2003. Optimal integer solutions to industrial cutting-stock problems: Part 2, benchmark results. INFORMS Journal on Computing 15, 58–81.

10

Fink, A., Voß, S., 1999. Applications of modern heuristic search methods to pattern sequencing problems. Computers and Operations Research 26, 17–34. Foerster, H., W¨ ascher, G., 1998. Simulated annealing for order spread minimization in sequencing cutting patterns. European Journal of Operational Research 110, 272–281. Foerster, H., W¨ ascher, G., 2000. Pattern reduction in one-dimensional cutting stock problems. International Journal of Production Research 38, 1657–1676. Garey, M. R., Johnson, D. S., 1979. Computers and Intractability: A Guide to the Theory of NP-Completeness, W. H. Freeman and Company, New York. Gau, T., W¨ ascher, G., 1995. CUTGEN1: A problem generator for the standard one-dimensional cutting stock problem. European Journal of Operational Research 84, 572–579. Gilmore, P. C., Gomory, R. E., 1961. A linear programming approach to the cutting-stock problem. Operations Research 9, 849–859. Gilmore, P. C., Gomory, R. E., 1963. A linear programming approach to the cutting-stock problem — part 2. Operations Research 11, 863–888. Haessler, R. E., 1971. A heuristic programming solution to a nonlinear cutting stock problem. Management Science 17, 793–802. Haessler, R. E., 1975. Controlling cutting pattern changes in one-dimensional trim problems. Operations Research 23, 483–493. Madsen, O. B. G., 1988. An application of travelling-salesman routines to solve pattern-allocation problems in the glass industry. Journal of the Operational Research Society 39, 249–256. Makhorin, A., 2000. GLPK (GNU Linear Programming Kit). http://www.gnu.org/software/ glpk/. Umetani, S., Yagiura, M., Ibaraki, T., 2003. One-dimensional cutting stock problem to minimize the number of different patterns. European Journal of Operational Research 146, 388–402. Umetani, S., Yagiura, M., Ibaraki, T., 2006. One-dimensional cutting stock problem with a given number of setups: A hybrid approach of metaheuristics and linear programming. Journal of Mathematical Modeling and Algorithms 5, 43–64. Umetani, S., 2009. Test instances for the paper tube cutting stock problem. http://www-sys.ist. osaka-u.ac.jp/~umetani/index-e.html. Vance, P. H., 1998. Branch-and-price algorithms for the one-dimensional cutting stock problem. Computational Optimization and Applications 9, 211–228. Vanderbeck, F., 1999. Computational study of a column generation algorithm for bin packing and cutting stock problems. Mathematical Programming A86, 565–594. Yanasse, H. H., 1997. On a pattern sequencing problem to minimize the maximum number of open stacks. European Journal of Operational Research 100, 454–463. Yanasse, H. H., Lamosa, M. J. P., 2007. An integrated cutting stock and sequencing problem. European Journal of Operational Research 183, 1353–1370. Yuen, B. J., 1991. Heuristics for sequencing cutting patterns. European Journal of Operational Research 55, 183–190.

11

Yuen, B. J., 1995. Improved heuristics for sequencing cutting patterns. European Journal of Operational Research 87, 57–64. Yuen, B. J., Richardson, K. V., 1995. Establishing the optimality of sequencing heuristics for cutting stock problems. European Journal of Operational Research 84, 590–598.

12

Table 1: The random instances of PTCSP. Instance R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R30 R31 R32 R33 R34 R35 R36 R37 R38 R39 R40 R41 R42 R43 R44 R45 R46 R47 R48

n 1 1 1 1 1 1 1 1 1 1 1 1 4 4 4 4 4 4 4 4 4 4 4 4 1 1 1 1 1 1 1 1 1 1 1 1 4 4 4 4 4 4 4 4 4 4 4 4

m 10 10 10 10 30 30 30 30 50 50 50 50 10 10 10 10 30 30 30 30 50 50 50 50 10 10 10 10 30 30 30 30 50 50 50 50 10 10 10 10 30 30 30 30 50 50 50 50

Lmin 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000

Lmax 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000 3000

ν1 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2 0.01 0.01 0.2 0.2

13

ν2 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8 0.2 0.2 0.8 0.8

bmin 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5

bmax 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10

smin 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5 1 5

smax 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10 5 10

d¯ 11.3 38.4 11.3 38.4 11.1 35.0 11.1 35.0 11.6 35.0 11.6 35.0 9.4 26.0 9.4 26.0 11.7 31.3 11.7 31.3 13.3 37.1 13.3 37.1 15.1 48.7 15.1 48.7 15.5 47.8 15.5 47.8 16.5 48.9 16.5 48.9 19.2 51.2 19.2 51.2 18.3 51.7 18.3 51.7 18.2 50.8 18.2 50.8

Table 2: Computational results and CPU time in seconds of CGM, PGH and TS-CG for the random instances. Instance R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R30 R31 R32 R33 R34 R35 R36 R37 R38 R39 R40 R41 R42 R43 R44 R45 R46 R47 R48

CGM tloss time 0.0 0.13 0.0 0.06 6.9 0.02 10.8 0.05 0.0 0.66 0.0 0.92 10.2 0.34 13.0 0.23 0.0 1.34 0.0 2.13 10.7 1.34 9.5 1.19 0.0 0.38 0.0 0.31 6.3 0.09 5.7 0.11 0.0 1.98 0.0 1.70 4.8 1.05 1.9 1.80 0.0 6.86 0.0 6.16 1.2 6.49 0.8 4.77 0.0 0.05 0.0 0.06 6.3 0.02 10.3 0.05 0.0 0.70 0.0 0.83 12.1 0.28 13.6 0.19 0.0 1.97 0.0 1.30 9.9 1.50 8.5 1.17 0.0 0.27 0.0 0.33 1.3 0.17 0.9 0.25 0.0 1.39 0.0 1.25 1.6 1.48 1.4 1.28 0.0 6.00 0.0 5.66 0.9 6.25 0.6 6.11

#sc 0 0 0 0 0 0 0 0 – – – – 2 4 8 7 1 2 6 6 – – – – 0 0 0 0 0 0 0 0 – – – – 1 1 3 6 2 2 6 13 – – – –

vs 92.9 65.0 0.0 0.0 97.4 94.3 0.5 0.0 – – – – 90.9 60.0 0.0 0.0 86.1 73.4 0.0 3.0 – – – – 81.3 69.8 0.0 0.0 94.5 93.5 0.0 0.1 – – – – 80.0 66.7 28.1 27.3 73.9 70.5 17.4 18.3 – – – –

PGH #os tloss 6 5.7 6 0.4 3 7.2 2 10.9 10 2.0 8 0.2 3 10.2 3 13.0 – – – – – – – – 7 3.4 6 1.3 3 7.8 3 7.0 12 0.2 16 0.3 5 5.6 5 2.1 – – – – – – – – 6 4.2 6 1.9 3 6.3 2 10.3 12 0.6 11 0.5 4 12.1 3 13.6 – – – – – – – – 6 0.2 7 0.8 6 1.6 4 1.3 13 0.3 14 0.5 7 1.6 5 1.5 – – – – – – – –

14

time 0.42 0.34 0.44 1.41 0.63 0.84 2.53 9.11 – – – – 0.39 0.34 0.28 0.64 0.47 0.64 1.55 2.19 – – – – 0.19 0.25 0.55 0.95 0.48 0.75 2.86 9.77 – – – – 0.23 0.25 0.30 0.49 0.39 0.61 1.14 2.52 – – – –

#sc 0 0 0 0 0 0 0 0 0 0 0 0 3 3 3 3 3 3 3 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 3 3 3 3 3 3 3 3 3 3 3 3

vs 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

TS-CG #os tloss 2 10.8 2 2.8 2 8.8 2 11.7 3 2.0 2 2.5 2 11.1 2 13.0 3 2.6 3 2.2 2 11.2 2 10.3 2 1.8 2 0.7 2 8.2 2 7.0 3 1.2 4 1.0 3 6.8 3 4.3 2 1.3 3 1.5 3 3.4 2 3.8 2 9.8 2 3.7 2 9.8 2 10.3 3 2.4 3 2.2 2 13.0 2 14.9 3 2.7 3 2.1 2 10.5 2 10.6 3 1.4 3 0.8 3 2.9 3 3.7 3 1.4 3 1.6 3 3.1 3 3.6 3 1.5 3 1.3 3 2.9 3 5.1

time 0.01 4.23 3.88 0.42 7.16 3.66 3.27 5.81 42.39 26.72 168.06 39.66 0.11 32.34 0.13 1.08 64.50 52.53 11.72 38.42 25.74 99.69 115.83 167.27 0.02 2.06 0.22 0.95 8.02 25.19 1.31 8.08 8.11 95.30 94.09 92.99 2.16 108.61 3.53 14.77 13.16 33.70 33.86 151.69 115.38 123.78 146.34 178.86

Table 3: The real-world instances of PTCSP taken from a paper tube factory Instance F1 F2 F3 F4 F5 F6

n 3 1 2 3 4 4

m 14 15 16 17 15 17

Lmin 1300 1800 1700 1350 1350 1350

Lmax 1800 1800 1900 1800 2100 2100

bmin 5 10 5 5 10 5

bmax 10 10 12 5 10 5

d¯ 87.1 100.0 67.1 60.3 52.0 60.3

lmin 66 88 114 642 608 642

lmax 544 411 550 1057 1058 1057

Table 4: Computational results and CPU time in seconds of CGM, PGH and TS-CG for the real-world instances. Instance F1 F2 F3 F4 F5 F6

CGM tloss time 0.0 0.17 0.0 0.09 0.0 0.28 0.0 0.34 2.5 0.11 2.0 0.20

#sc 5 0 1 10 6 8

vs 23.8 54.3 21.5 11.0 13.2 4.3

PGH #os tloss 7 0.5 10 0.4 8 0.5 2 2.5 2 3.0 2 3.9

15

time 0.94 0.67 0.60 2.50 1.80 3.20

#sc 2 0 1 2 3 3

TS-CG vs #os 0.0 3 0.0 2 0.0 3 0.0 2 0.0 2 0.0 2

tloss 1.0 1.2 1.5 2.5 3.4 4.4

time 100.17 26.59 158.61 10.17 76.83 148.45