#*
*
#
Faculty of Organisational Sciences, University of Maribor,
4000 Kranj, Prešernova ulica 11, Slovenia
* Faculty of Economics,University of Ljubljana,
1000 Ljubljana, Kardeljeva ploščad 17, Slovenia
Abstract
The paper deals with the problem of evaluation and comparison of different one-dimensional stock cutting algorithms regarding trim loss. Three possible types of problems are identified. Evaluation method is developed which enables a comparison of solutions of all three types of problems. A practical example of method implementation for comparison of two algorithms is presented.
Povzetek
Članek obravnava problem vrednotenja in primerjave različnih algoritmov enodimenzionalnega razreza glede na ostanke. Opredeljeni so trije možni tipi problemov. Razvita je bila metoda vrednotenja, ki omogoča primerjavo rešitev vseh treh tipov problemov. Podan je tudi praktičen primer uporabe te metode za primerjavo dveh algoritmov.
Keywords: Cutting; Heuristics; Optimisation; Evaluation
1. Introduction
The problem of one-dimensional stock cutting occurs in many industrial processes [3,7,8,11,12] and during the past few years it has attracted an increasing attention of researchers from all over the world [1,13]. Most standard problems related to one-dimensional stock cutting are known to be NP-complete. However, in many cases the problems can be modelled by means of mathematical programming and a solution can be found by using approximate methods and heuristics.
The cutting problems can be classified according to Dyckhoff

2

. He developed a classification scheme for cutting stock problems through a large variety of applications reported in the literature. He classified problems using four characteristics: Dimensionality , Kind of assignment , Assortment of large objects and
Assortment of small items .
Dyckhoff classifies the solution of cutting stock problems into two groups: item-oriented and pattern oriented approach. Item-oriented approach is characterised by individual treatment of every item to be cut. In the pattern-oriented approach, at first, order lengths are combined into cutting patterns, for which - in a succeeding step - the frequencies are determined that are necessary to satisfy the demands. In pattern-oriented approach the classic LP-based Gilmore and Gomory’s “delayed pattern generation” [5,6] or any other LP-

based Method (LPM) is mostly used [14,15,16]. LPM is possible only when the stock is of the same length

5
 or of few groups of standard lengths which means that all objects within the same group are identical

6

. In cases when all stock lengths are different frequencies can not be determined and therefore only an itemoriented solution can be found [8,9]. That means that in cases when the stock is of different lengths there are two different situations and two different solution approaches. One if there are few groups of standard lengths and other when all stock lengths are different. This important distinction is not taken into account by the
Dyckhoff’s classification scheme since the distinguishes Assortment of large objects only three possibilities:
(O) One large object.
(I) Many identical large objects.
(V) Different large objects.
Therefore we suggest additional possibility:
(G) Few groups of identical large objects.
The enlarged Dyckhoff’s classification scheme is as follows:
1. Dimensionality
(N) Number of dimensions
2. Kind of assignment
(B) All large objects and a selection of small items.
(V) A selection of large objects and all small items.
3. Assortment of large objects
(O) One large object.
(I) Many identical large objects.
(G) Few groups of identical large objects.
(V) Different large objects.
4 . Assortment of small items
(F) Few items of different dimensions.
(M) Many items of many different dimensions.
(R ) Many items of relatively few dimensions.
(C) Many identical items.
In both approaches the pattern-oriented and item-oriented one there are many algorithms and methods for one dimensional stock cutting with different factors which are taken into account. Therefore the general comparison between them is very difficult if not impossible. But if we assume that the trim loss is the most important common factor we can overcome this problem by limiting the comparison only on trim loss. We decided to develop the evaluation method for one-dimensional stock cutting algorithms regarding trim loss. In the literature a description of such a method hasn’t been found so far. In 
4

is described the problem generator which only enables a comparison between pattern-oriented methods.
In the article a definition of trim loss in different approaches and different types of cutting stock problem is given. Problem parameters are identified. The evaluation method that takes into account those parameters is developed. At the end practical implementation of the method is presented.
2. Trim loss definition

In different cutting stock problems and in different approaches to them the trim loss is defined differently.
If we want to compare different solution methods regarding trim loss we must first introduce the trim loss definition which will be the same for all types of problems. Such a general definition of trim loss is possible when we introduce General One-Dimensional Cutting Stock Problem (G1D-CSP). (G1D-CSP) is defined as follows:
For every customer order a sufficiently large stock of material is available with any assortment (O or I or G or V). It is necessary to cut a certain number of order lengths into required number of pieces. If there is shortage of material it is always possible, automatically or manually, to adapt the required number of pieces of some order lengths to the available amount of material

9

. We consider the lengths as integers. If they are not originally integers we assume that it is always possible to multiply them with a factor and transform them to integers. The following notation is used: l i
order lengths; i

1,..., n , d
U i
required number of pieces of order length l j
stock lengths; j

1,..., m , i
, p ij
number of pieces of order length l i having been cut from stock length j .
The following integer programming model can be formulated

9

: m
(1) min
 t j
j

1
(minimise trim loss which is smaller or equal than max l i
) s.t. n
(2) U j

 i

1
m
 l i
 p ij
  j
 j (knapsack constraints)
(3)
 p ij
 d i
 i (demand constraints - order lengths are cut in exactly demanded number of pieces) j

1 m
(4)
 w j

1 (maximum number of residual lengths which are larger than max l i
) j

1 p ij

0, integer
 i, j t j j

0

j

0, integer

j , where the following functions are used:

0 if p
  ij

0
 i z j

1 otherwise to indicate whether stock length j is used in the cutting plan,

1 if z j

1
 w j

0 otherwise
 j

max l i
  to indicate whether the trim loss relating to stock length j is greater than the longest order length,
  j if z j

1
  j

max l i

t j
 

0 otherwise. t j
indicates the extent of the trim loss relating to stock length j .
Upper bound ( UB ) for the trim loss can be set between 0 and max l i
(condition (4)). Max l i is chosen as UB to ensure that all residual stock lengths as a result of condition (3) are taken into account in optimisation.
Residual stock length that is larger than max l i
could be used furthers and is not considered as waste. If there are more residual stock lengths larger than max l i
it is always possible to recombine the pieces of order lengths in such a way that only one residual stock length is left larger than max l i
[Gradisar 1,2]. To ensure this the condition (4) has to be set. Without a condition (4), in case of sufficiently large stock, there will be cutting plans with "no trim loss" but ever growing stocks [8].
To solve G1D-CSP we need the item-oriented method because all stock lengths can be different. There are two possibilities: exact methods (branch and bound, dynamic programming) or approximation algorithms in form of Sequential Heuristic Procedure (SHP). SHP seems to be better regarding robustness and potential usefulness in a wide range of cases.
If the stock is of the same length or of a few groups of standard lengths, we get the Standard One-
Dimensional Cutting Stock Problem (S1D-CSP) where the pattern oriented approach is possible [4,10]. S1D-
CSP can be described as follows: l i
order lengths; i

1,..., n , d
L i
required number of pieces of order length l i
, k
stock lengths; k

1,..., p , where p is the number of different standard stock lengths in a sufficiently large stock.
The cutting plan consists of cutting patterns having been cut from different stock lengths and of the corresponding frequencies necessary to satisfy all orders. Cutting pattern c, having been cut from standard stock length k, may be expressed by a vector
( a
1ck
, a
2ck
, a
3ck
,..., a nck
) (5) that satisfies n
 l i i

1
 a ick

L k
, (6) a ick

0 and integer, (7) in which a ick
represents the number of times order length l i
appears in this particular pattern. Let’s denote: x ck
frequency of cutting pattern c having been cut from stock length k , t k
total number of cutting patterns (5) having been cut from stock length k satisfying (6) and (7).
The following integer programming model can be formulated:
p t k min
  x k

1 c

1 ck

L k
(minimise sum of stock lengths to be cut) (8)
p t k

s.t.
  a k

1 c
 ick
 x ck
 d i i = 1,..., n (number of pieces can be greater than demanded) (9)
1 x ck

0 and integer, c = 1,..., t k
; k = 1,..., p . (10)
S1D-CSP can be solved using the classic LP-based Gilmore and Gomory’s “delayed pattern generation” or any other LP-based Method (LPM).
In pattern oriented methods the object of optimisation is not the trim loss but the sum of stock lengths to be cut (8). That means that there are two differences regarding trim loss between G1D-CSP and S1D-CSP:
1.
In G1D-CSP order lengths are cut in exactly required number of pieces. In S1D-CSP this number can be greater than demanded (condition 9).
2.
The last stock length in G1D-CSP is in general not cut to the end. The result is residual length that could be used later. In S1D-CSP all used stock lengths are cut to the end.
Because of those two differences the direct comparison between G1D-CSP and S1D-CSP regarding trim loss is not possible. In order to overcome them we must change either G1D-CSP or S1D-CSP. The differences can be seen also as a result of the limitation of LPM, which is the most frequently used solution method for
S1D-CSP. If G1D-CSP is changed then LPM in general still can’t be used because all stock lengths can be different. Therefore we decided to change S1D-CSP. If we introduce both differences as additional constraints in S1D-CSP we get the new type of problem which can’t be solved with pure pattern-oriented approach but with some combination of item- and pattern-oriented approach. Therefore this new problem can be named
Hybrid 1-Dimensional Cutting Stock Problem (H1D-CSP). The purpose of introducing H1D-CSP is not only a definition of trim loss which enables comparison with G1D-CSP, but also a new quality which we get with its solution:
1.
ability to cut order lengths in exactly required number of pieces
2.
ability to cumulate consecutive residual lengths in one piece which could be used later
3.
ability to use non -standard stock lengths.
We believe that these additional characteristics can be useful in many practical situations. An example of a method based on hybrid approach for solution of H1D-CSP is described in

10

.
3. Method
In literature we don’t find a method for evaluation G1D-CSP or H1D-CSP. Gau and Waesher 
4

have developed a problem generator for S1D-CSP with I-type of assortment of large objects . They identify five problem parameters: m - problem size
L - standard stock length v1,v2 - lower and upper bound for order lengths đ
- average demand per order length.
Our goal is to generalise their method for any type of problem regarding assortment of large objects .
Therefore we need five more problem parameters which will enable us to determine also different standard and non-standard stock lengths. They are presented in Table 1:

n number of different order lengths v
1
, v
2
lower and upper bound for order lengths, i.e. v
1

l i

v
2
( i

1,..., n ) average demand per order length p number of standard stock lengths s
1
, s
2
lower and upper bound for standard stock length, i.e. s
1

L k

s
2
( k

1,..., p ) m number of non-standard stock length u
1
, u
2
lower and upper bound for non-standard stock length, i.e. u
1

U j

u
2
( j

1,..., m )
5.
Table 1: Problem descriptors for the G1D-CSP
The method has the following main steps:
1.
Test problems are generated:
 determination of order lengths and demands
 determination of standard stock lengths
 determination of non-standard stock lengths
2.
If the algorithm is the solution of S1D-CSP then it needs to be transformed to H1D-CSP

10


S1D-CSP’s are solved applying LPM
 frequencies of the patterns with order lengths cut in more pieces than demanded are reduced by one
 the missing number of pieces is then cut from the rest of the stock applying SHP else
 test problems are solved
3.
Results are analysed.
3.1 Generation of test problems
The testing of algorithms requires input data which can be generated according to problem descriptors as random sample of one or more test problems. In our case a single test problem is possible to describe as a
2 n + p + m –dimensional random variable
( l
1
,…, l n
, d
1
,…, d n
, L
1
,…, L p
, U
1
,…, U m
). (11)
Random variables are generated through uniform random number generator. With permission we used pseudorandom number generator, described in

4

because of its properties which are beside simplicity and randomness also portability and reproducibility. The seed of generator is not fixed in advance. Therefore, in testing algorithms the results must always contain information on the seed which was used in a particular test case enabling others to reproduce the test data.
All lengths (order, standard and non-standard) which are integers are determined through the following two step procedure:
generating a realisation y i
of random variable Y uniformly distributed on ( b
1
, b
2
+1) where b
1
represents lower and b
2
upper bound: y i
= b
1
+ ( b
2
- b
1
)

rand i
(0, 1) + rand i
(0, 1), (12)

and rounding it down to the next integer.
If two identical order lengths are generated then the second order length is deleted after demand of it is summed up to the demand of the first one.
Demands d i for the different order lengths l i
( i =1,…, n ) are determined in the way that the total demand D = n

is uniformly distributed between order lengths according to the following rules
 
: d i
= max

1,

đ’ i
+ 0.5
 
, (13) đ’ i
rand i
(0, 1)
= —————— ∙ D i

1,..., n – 1, (14)
n
Σ rand k
(0, 1) k =1 d n
= max
n -1

1, D – Σ d i

. (15)
k =1
The demands đ’ i
except the demand đ’ n
are corrected by adding 0.5 in order to prevent systematically under-estimation of demands d i
except d n
. Otherwise the residual demand d n
would be systematically overestimated.
4. Practical example
As a practical example of proposed method and using a problem generator a comparison of two cutting algorithms is made. With a problem generator it is possible to generate test data for all three types of onedimensional cutting problems. As we have seen in previous sections the comparison between various methods regarding trim loss is possible only if the problem is defined as G1D-CSP or H1D-CSP. If the problem is defined as S1D-CSP then it must be transformed to H1D-CSP. Therefore we decided to compare two itemoriented solutions of G1D-CSP. First one is named COLA and is specialised for use in clothing industry

8

.
The second one is CUT

9

and is a generalised and improved version of COLA.
Test problems have been generated with following values of parameters:
determination of order lengths and demands:
By assigning different values to the problem parameters n ( n = 5, 10, 15), v
1
and v
2
( v
1
= 100 and v
2
=
200, v
1
= 200 and v
2
= 600, v
1
= 300 and v
2
= 900) and đ ( đ = 10, 20, 30) and combining them with each other 27 problems have been generated.
determination of standard stock lengths:
In our case there have been no standard stock lengths and all three parameters p , s
1
and s
2
have been
determination of non-standard stock lengths:
Number of non-standard stock lengths m is varying from 10 to 90, lower bound s
1 from 500 to
1500 and upper bound s
2
from 1500 to 4500.

The details about generation of problem descriptors and determination of seed for sequences of test problems are shown in the dynamic programming scheme of the procedure PROGEN .
Procedure PROGEN:
for i

1 to 3 do
for j

1 to 3 do for k

1 to 3 do n

i

5 v
1 v
2

j

100

j

300 s
1 s
2

0

0

0

k

10 u u r
1

i

j

10
 seed seed seed seed seed
j

1



500
2

j

1500
n

seed + v
1

100000

seed + v
2

seed + đ

seed + m

1000

100
call PGEN (n, v
1
, v
2
, p, s
1
, s
2
, đ, m, u
1
, u
2
, seed, r)
endfor
endfor
endfor
Parameter r in procedure PGEN determines how many times generation of test problems should repeat. In our case r was set to 1 because we want to compare both solutions of each single problem.
The data of the first and the last test problem of 27 generated with procedure PGEN called from PROGEN is in the table 2.
TEST 1

ORDER LENGTHS
No Length Demand
1 261 13
2 211 2
3 169 9
4 128 14
5 115 12
UNSTANDARD STOCK LENGTHS
No Length
1 1420
2
3
4
10
1330
1156
1056
5 980
6 896
7 859
8 816
9 777
698
TEST 27
ORDER LENGTHS
No. Length Demand No. Length Demand No. Length Demand
1 898 36
2 861 45
3 801 3
4 748 24
5 733 46
6 658 16
7 641 23
8 570 23
9 548 39
10 498 16
11 492 39
12 471 21
13 414 47
14 327 40
15 303 32
UNSTANDARD STOCK LENGTHS
No. Length No. Length No. Length No. Length No. Length No. Length
2 4445
3 4441
4 4398
5 4396
6 4365
7 4347
8 4335
9 4332
10 4330
11 4280
12 4265
13 4259
14 4245
15 4232
17 4227
18 4212
19 4207
20 4171
21 4166
22 4153
23 4144
24 4066
25 4056
26 4028
27 3959
28 3917
29 3880
30 3835
31 3783
32 3721
33 3643
34 3601
35 3600
36 3578
37 3439
38 3379
39 3370
40 3314
41 3300
42 3299
43 3212
44 3204
45 3175
46 3166
47 3161
48 3141
49 3118
50 3008
51 2982
52 2963
53 2948
54 2926
55 2898
56 2867
57 2811
58 2807
59 2797
60 2785
61 2777
62 2767
63 2717
64 2468
65 2447
66 2402
67 2364
68 2348
69 2348
70 2320
71 2309
72 2278
73 2275
74 2254
75 2237
76 2231
77 2226
78 2210
79 2175
80 2115
81 2059
82 1939
83 1909
84 1882
85 1675
86 1602
87 1578
88 1552
89 1537
90 1520
Table 2: Two test problems generated with PGEN

The results of comparing both algorithms are presented in table 3. n,, v
1
, v
2
, đ, m, u
1
, u
2 and seed are in columns (1)-(8). Seed is generated in procedure PROGEN . All lengths are expressed in cm. Columns (9), (10) contain planned overall trim loss as a result of algorithm COLA and columns (11), (12) as a result of algorithm
CUT. In columns (9), (11) trim loss is expressed in cm and in columns (10), (12) in percentage. Despite of the same overall trim loss we got with COLA and CUT expressed in cm in the first case (36 cm), the values expressed in percentage are different. The reasons for that are different stock lengths used in both cases. With both programs in 19 out of 27 cases the overall trim loss was lower than the shortest generated order length. In case 24 the shortest order length was 221 cm. This means that we have certainly found an optimal
Overall trim loss n v
1 v
2 đ m u
1
u
2
seed (cm)
COLA CUT
(%) (cm) (%)
No. (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12)
1 5 100 300 10 10 500 1500 510301010 36 0.4158004 36 0.3875135
2 5 100 300 20 10 500 1500 510302010 34 0.3382075 9 0.0895255
3 5 100 300 30 10 500 1500 510303010 61 0.7232630 61 0.7232630
4 5 200 600 10 20 1000 3000 520601020 161 0.9202104 161 0.9202104
5 5 200 600 20 20 1000 3000 520602020 302 0.8522166 322 0.8981869
6 5 200 600 30 20 1000 3000 520603020 353 0.8407364 244 0.5811322
7 5 300 900 10 30 1500 4500 530901030 7 0.0323593 3 0.0136668
8 5 300 900 20 30 1500 4500 530902030 277 0.5168200 277 0.5168200
9 5 300 900 30 30 1500 4500 530903030 739 1.0310860 408 0.6125298
10 10 100 300 10 20 500 1500 1010301020 9 0.0491051 10 0.0543242
11 10 100 300 20 20 500 1500 1010302020 26 0.1305876 18 0.0904068
12 10 100 300 30 20 500 1500 1010303020 22 0.1051123 20 0.0955566
13 10 200 600 10 40 1000 3000 1020601040 8 0.0245126 14 0.0417374
14 10 200 600 20 40 1000 3000 1020602040 771 1.1070910 847 1.2452770
15 10 200 600 30 40 1000 3000 1020603040 120 0.1547389 128 0.1650548
16 10 300 900 10 60 1500 4500 1030901060 6 0.0115826 7 0.0128414
17 10 300 900 20 60 1500 4500 1030902060 1292 0.9982693 422 0.3266734
18 10 300 900 30 60 1500 4500 1030903060 1881 1.1487160 1516 0.9231125
19 15 100 300 10 30 500 1500 1510301030 43 0.1671136 75 0.2955083
20 15 100 300 20 30 500 1500 1510302030 10 0.0337860 12 0.0405432
21 15 100 300 30 30 500 1500 1510303030 9 0.0284126 8 0.0252557
22 15 200 600 10 60 1000 3000 1520601060 35 0.0545239 12 0.0190669
23 15 200 600 20 60 1000 3000 1520602060 320 0.2910784 271 0.243766
24 15 200 600 30 60 1000 3000 1520603060 110 0.0888565 203 0.1639808
25 15 300 900 10 90 1500 4500 1530901090 2 0.0027623 14 0.0194820
26 15 300 900 20 90 1500 4500 1530902090 847 0.4018217 433 0.2066826
27 15 300 900 30 90 1500 4500 1530903090 219 0.0876708 176 0.0705244
Sum 7700 5707
Table 3: Comparison of COLA and CUT solution. But other characteristics of both programs are different. The worst case of COLA was 1881 cm
(1.1487160 %) and of the CUT 1516 cm (0.9231125 %). The average overall trim loss of COLA was 285.19 cm and of CUT 211.37 cm. The sum of all 27 overall trim losses was in case of CUT by 1993 cm lower than in

case of COLA. According to those results of generated test problems program CUT can be evaluated as being better than COLA. But from the viewpoint of speed the program COLA is approximately 30 % faster. Program
CUT spends 15 s on a personal computer (Pentium II, 233 MHz) for solution of all 27 problems and COLA only 10 s.
5. Conclusion
The article examines the evaluation method for one-dimensional stock cutting algorithms. There are many algorithms and methods for one-dimensional stock cutting with different factors that are taken into account.
But the most important common factor is the trim loss. We decided to develop the method for comparisons of different algorithms for one-dimensional stock cutting regarding trim loss. In different types of problems the trim loss is differently defined. According to assortment of large objects we identified three types of problems.
Beside S1D-CSP and H1D-CSP, which are known from the literature, also G1D-CSP is introduced. The evaluation method is proposed which enables the comparison of solutions of all three possible types of problems. A problem generator for the G1D-CSP is developed. An example of comparison of two itemoriented algorithms COLA and CUT is presented.
References
[1] Bishoff E. E, Waesher G., “Cutting and Packing”, European Journal of Operational Research 84
(1995) 503-505.
[2] Dyckhoff H., “A typology of cutting and packing problems”, European Journal of Operational
Research 44 (1990) 145-159.
[3] Ferreira J. S., Neves M. A. and Fonseca P., “A two-phase roll cutting problem”, European Journal of
Operational Research 44 (1990) 185-196.
[4] Gau T., Waesher G., “CUTGEN1: A problem generator for the Standard One-dimensional Cutting Stock
Problem”, European Journal of Operational Research 84 (1995) 572-579.
[5] Gilmore P. C. and Gomory R. E., “A linear programming approach to the cutting stock problem”,
Operations Research 9 (1961) 849-859.
[6] Gilmore P. C. and Gomory R. E., “A linear programming approach to the cutting stock problem, Part
II”, Operations Research 11 (1963) 863-888.
[7] Goulimis C., “ Optimal solutions for the cutting stock problem”, European Journal of Operational
Research 44 (1990) 197-208.
[8] Gradišar M., Jesenko J., Resinovič G., “Optimization of roll cutting in clothing industry”, Computers
& Operations Research 24 (1997) 945-953 .
[9] Gradišar M., Resinovič G., Jesenko J., Kljajić M.: “An algorithm for optimization of one-
dimensional cutting”, European Journal of Operational Research 114 (1999) 557-568.
[10] Gradišar M., Kljajić M., Resinovič G.: “A hybrid approach for optimization of one dimensional
cutting”, European Journal of Operational Research 119 (1999) 165-174.
[11] Haessler R. W., Vonderembse M. A., “A procedure for solving the master slab cutting stock problem
in the steel industry”, AIIE Transactions 11 (1979) 160-165.
[12] Stadtler H., “A one-dimensional cutting stock problem in the aluminium industry and its solution”,
European Journal of Operational Research 44 (1990) 209-223.
[13] Sweeney P. E. and Paternoster E. R., “Cutting and packing problems: A Categorised, Application-
Orientated Research Bibliography”, Journal of the Operational Research Society 43 (1992) 691-706.
[14] Vance P.H., “Branch-and-Price Algorithms for the One-Dimensional Cutting Stock Problem”,

Computational Optimization and Applications 9 (1998) 211-228.
[15] Vanderbeck F., “Computational Study of a Column Generation Algorithm for Bin Packing and
Cutting Stock Problems”, Research Papers in Management Studies, No 14, University of
Cambridge, 1996.
[16] Waesher G., Gau T., “Generating Almost Optimal Solutions for the Integer One-dimensional Cutting
Stock Problem”, Working Paper No. 94/06, Institut fur Wirtschaftswissenshaften, Technische
Universität Braunschweig, 1994.