An exact algorithm for the N-sheet two dimensional single stock-size cutting stock problem

The method introduced in this paper extends the trim-loss problem or also known as 2D rectangular SLOPP to the multiple sheet situation where N same size two-dimensional sheets have to be cut optimally producing demand items that partially or totally satisfy the requirements of a given order. The cutting methodology is constrained to be of the guillotine type and rotation of pieces is allowed. Sets of patterns are generated in a sequential way. For each set found, an integer program is solved to produce a feasible or sometimes optimal solution to the N -sheet problem if possible. If a feasible solution cannot be identified, the waste acceptance tolerance is relaxed somewhat until solutions are obtained. Sets of cutting patterns consisting of N cutting patterns, one for each of the N sheets, is then analysed for optimality using criteria developed here. This process continues until an optimal solution is identified. Finally, it is indicated how a given order of demand items can be totally satisfied in an optimal way by identifying the smallest N and associated cutting patterns to minimize wastage. Empirical results are reported on a set of 120 problem instances based on well known problems from the literature. The results reported for this data set of problems suggest the feasibility of this approach to optimize the cutting stock problem over more than one same size stock sheet. The main contribution of this research shows the details of an extension of the Wang methodology to obtain and prove exact solutions for the multiple same size stock sheet case.


Introduction
Wäscher et al. [16] proposed a typology to categorise different problem formulations according to categorisation criteria.In this paper a two-dimensional cutting stock problem (2DCSP) is considered.This type of problem is normally encountered during the process of cutting a set of rectangular stock sheets like glass or wood into a set of smaller rectangular items in order to partially or fully satisfies a specified demand of the smaller items.It is accepted that guillotine type cuts are employed, that rotation of the small items is allowable and that the demand of small items cannot be satisfied by cutting only one stock sheet.An upper bound is specified on the quantity of each type of small item needed.It is also assumed that the stock sheets to be used are of the same size.This problem is referred to by Wäscher et al. [16] as the two-dimensional single stocksize cutting stock problem (2DSSSCSP).They also defined the two-dimensional multiple stock-size cutting stock problem (2DMSSCSP) where different sizes of stock sheets and in variable quantities may in general be available.A well known elementary case is to cut one stock sheet to find a single cutting pattern producing the least waste.This type of problem is generally known as the trim-loss problem or the two-dimensional rectangular single large object placement problem (2D rectangular SLOPP) indicated as 2D-SLOPP in the rest of the paper.
The concept of the 2D-SLOPP is extended to a 2D-SLOPP over N same size sheets, called the N sheet two-dimensional single stock-size cutting stock problem (NS-2DSSSCSP) in this paper.Note that this is the same as 2DSSSCSP with N specified explicitly.This is a problem posed for utilizing the N sheets optimally by cutting items from the set of pieces in an order.For N = 1, this then reduces to the 2D-SLOPP.It is generally considered to be a NP hard problem to obtain the exact solution for N > 1.
To solve the 2DSSSCSP exactly either all the possible cutting patterns must be considered to establish optimality or some proof must be given that "sufficient" cutting patterns have been considered.An exact approach is proposed in this paper to maximize the utilization of a specified number of stock sheets without generally enumerating all possible cutting patterns.In §4 it is proved that it is possible to either guarantee optimality or give an indication that more cutting patterns must be generated to improve on the current solution.Although this approach is based on exactly N sheets, it is shown that the solutions can be utilized as part of a further search strategy to solve the 2DSSSCSP exactly to satisfy the full order of items.In the latter case it is assumed that sufficient stock sheets are available to fill the order.
The proposed solution process to establish the exact solution to the NS-2DSSSCSP consists of the systematic application of the following activities using an iterative process, namely 1. generate cutting patterns, 2. build and solve integer programming models, and 3. conduct optimality tests.
The NS-2DSSSCSP definition resembles the problem type of output maximisation defined by Wäscher et al. [16] whereby N large objects are supplied, which (in general) does not allow the accommodation of all small items.This means that there is generally a selection problem regarding the small items, and all the large objects have to be used.In this sense this problem (NS-2DSSSCSP) is an extension of the 2D-SLOPP.
The above mentioned approach of output maximisation is utilized by means of a search strategy to establish the optimum number of sheets needed to fulfil the cutting of the specified demand set of all items in the order.This is explained in §5.2 of this paper.In this phase, it can be seen as an input (value) minimisation problem type (Wäscher et al. [16]) from the set of large objects.Thus, all small items are to be assigned to a selected number of large object(s) of minimal total "value" or area.
In §2 a brief literature review is given followed by §3 on notation and problem formulation.
§4 contains a theoretical discussion and proofs to support the proposed algorithms.In §5 algorithms based on the theoretical work and some ideas from the literature are discussed.Empirical work and results follow in §6.§7 gives the conclusions followed by an overview of some further research possibilities based on the results.

Background and literature
In their paper on an improved typology of cutting and packing problems, Wäscher et al. [16] categorised a list of 413 papers dated up to December 2005 that they considered relevant to their description of cutting and packing problems.In the spreadsheet (dated February 28, 2012) linked to their paper, a list of 904 references is given.There are duplicates since a paper may be categorised into more than one category and when the duplicates are removed, there are 774 references.This illustrates that the field of cutting and packing continues to attract attention from researchers and quite a number of research papers are published regularly in this (broader) area.
A considerable number of research papers in the literature report on work regarding the trim-loss problem (SLOPP) whereby one stock sheet is cut into smaller demand items in a manner to minimize the waste.The spreadsheet from Wäscher lists 74 papers related to both two-dimensional and SLOPP.There are, however, a wide variety of approaches and definitions of this problem type.Some approaches allow rotation of items while others do not.Some accept pieces to be rectangular while others do not.Some follow a constrained (or staged) cutting approach while others do not.Some employ heuristics while others try to follow a more exact approach.When these characteristics are combined, only a few papers can be linked to the approach set out in this paper.
The process of solving a SLOPP in general needs some approach of generating and evaluating cutting patterns until optimality is reached or to stop the process with the solution at hand.Classical publications by Gilmore and Gomory [6,7,8] entail a series of papers on cutting stock problems where they initially concentrated on the one-dimensional problem.Their basic idea is to employ an unconstrained knapsack type of problem by utilizing dynamic programming strategies to establish favourable cutting patterns to be used in a (integer) linear programming (ILP) model.Other researchers like Christofides and Whitlock [4] employ pattern generation strategies based on tree search approaches.Most of these approaches involve mainly heuristics while the minority are exact of nature.The handling of a SSSCSP can generally be viewed as an iterative two-step process whereby the first step is to generate patterns (SLOPP approach) followed by a step of using these patterns as part of the input to solve the SSSCSP by means of a (integer) linear programming model.
Cintra et al. [5] report on various algorithms related to work done on two-dimensional cutting stock and strip packing problems.They employ dynamic programming and column generation techniques based on different instances of the cutting stock problem.These instances include a report on the Rectangular Knapsack (RK) problem which corresponds to the 2D-SLOPP according to the typology of Wscher et al. [16].The algorithms they implemented are based on the recurrence formulas of the dynamic programming approach proposed by Beasley [3] which they combined with the discretization points of Herz [9].The application of the Cintra algorithms to test problems gave good results timewise for the various instances of the 2D-SLOPP.In the next phase Cintra et al. [5] address the 2D-SSSCSP by means of a column generation technique based on the ideas initially proposed by Gilmore and Gomory.
As an alternative approach to dynamic programming, Wang [15] proposed two algorithms to establish a cutting pattern with least waste over a single sheet, thus a SLOPP.In her algorithms Wang employs a parameter β ∈ [0, 1] as a proportion of the stock sheet area and uses it to discard patterns with waste proportion exceeding β during the process of cutting pattern generation.She generates all feasible cutting patterns by successively combining rectangles in a bottom-up implicit enumeration algorithm whilst conforming to constraints like allowable size, quantity and waste percentage specification.By increasing β from some starting value in successive iterations, the number of different patterns generated is kept as low as necessary.
Based on the work of Wang, a number of researchers like Oliveira and Ferreira [11] and Vasko [13] reported refinements to the algorithms in order to reduce computational time.
Vasko and Bartkowski [14] used a modified version of Wang's first algorithm to experiment with the initial value and step size of β to obtain optimal solutions to 265 difficult cutting stock problems.They reported a fair amount of success with a step size of 0.002 and an initial value of zero for the test problems.About all SLOPP approaches identifiy only the (one) pattern (or alternatives) associated with the minimal waste.
Amaral and Wright [1] proposed an algorithm also based on the work of Wang that enhances the process of cutting pattern generation.By noting equivalences in combining rectangles vertically and horizontally and noting the legitimate rotation of rectangles, it is possible to eliminate certain combinations early on.They combined this elimination process with ordered data structures to further reduce the combinatoric effect.An added advantage of their approach, especially for the purposes of the research reported on in this paper, is that their algorithm generates (and stores) a list of all possible cutting patterns satisfying the β specification in a very efficient manner.In §6 some empirical results will be given based on the algorithm proposed by them.
During algorithm testing, Beasley [2] generated a set of 12 problems of the 2DMSSCSP type.Each problem considers cutting a set of patterns from multiple stock size rectangles and a list of small items for which the orientations are considered to be fixed.Beasley did some empirical work and reports that the algorithms produce a relatively low amount of waste but does not establish least waste comparisons.As an illustration of the waste levels found, a waste area percentage of 5.89% for problem 12 is reported.This was achieved by using 3 stock rectangle types.This set of problems has been used during the testing of the algorithms proposed in this paper.
A 2DCSP model is first considered to address the more formal part of this research, where an adequate number of stock sheets are available and the set of small demand items to be cut is specified.If all possible cutting patterns are available whereby demand items can be cut from a single stock sheet, the following integer linear program can be defined to compute an optimal solution for this 2DCSP.The objective is to minimize the total waste.Mathematically it can be formulated as subject to x j non-negative integers, j = 1, . . ., n, where x j is the number of times pattern j is to be cut, w j is the (total) waste implied by pattern j, I ij is the number of times demand item i is cut by pattern j, I i is the quantity of demand item i specified, n is the number of all possible cutting patterns, and m is the number of demand item types in the order.
This model can be applied to the (2D)SSSCSP and adapted for the (2D)MSSCSP.In general it is time consuming and in some cases impractical to generate all possible cutting patterns even for a single stock sheet type.This is an important reason why researchers often employ heuristics or consider relaxations for the problem.If multiple stock sheet types are involved, it complicates matters further.In this research a single sheet type is considered and the following notation is adopted to address the NS-2DSSSCSP.Let N specify the number of same size stock sheets to be used.S A specify the area of the sheet, thus S A = H × L, where H and L are the dimensions of the sheet, β specify the waste proportion per sheet allowed for in the process of generating patterns according to the approach of Amaral and Wright [1] based on the initial ideas introduced by Wang [15]1 , W β = {w β j | w β j ≤ βS A and w β j is the total waste for pattern j}, and Consider a special case of the NS-2DSSSCSP where the patterns used are generated based on a β ≥ β 1 .Define a model SW (N, β) with the objective to minimize the total waste over N sheets and pattern waste based on β.Mathematically it is expressed as minimize x j non-negative integers, j = 1, . . ., n β where x j is the number of times pattern j is to be cut, w β j ∈ W β is the (total) waste implied by pattern j, I ij is the number of times demand item i is cut by pattern j, I i is the quantity of item i specified, m is the number of demand item types, N is the specified number of (same size stock) sheets to be cut, and n β is the number of all cutting patterns with (total) waste within β specifications.
The first m + 1 constraints in the model constrain the number of demand items to be cut not to exceed the demand specified and also the number of stock sheets to be used.Thus, the above model adheres to the problem type of output maximization as defined by Wäscher et al. [16].For values of β and N that render SW (N, β) feasible, such SW (N, β)'s have optimal solutions with objective function values of (say) Z * (N, β).For non-decreasing sequences of values for β, Z * (N, β) forms a non-increasing sequence of values.In practice strictly increasing values of β will be considered.If β is sufficiently large the sequence converges to the optimal objective function value Z * (N ) that exploits the N sheets optimally for the given set of demand items.There thus exists a (minimum) It should be noted that Z * (N, β) gives the optimal objective function value to SW (N, β), but often it may not be the optimal objective function value to the NS-2DSSSCSP.It will, however, be clear from the context.The problem to identify Z * (N ) is a generalization of the (single sheet) trim-loss (2D-SLOPP) problem to the N sheet trim-loss problem.(Note that for all

Theoretical discussion and proofs
One method to establish the optimum solution of the cutting stock problem described here, is to have all possible cutting patterns available and to solve the relevant integer linear program.An alternative is to utilize the current information (or patterns) to prove optimality or to indicate that more patterns are needed.These additional patterns are generated by employing a new larger β.Thus, the theorems and corollaries given in this section enable the decision maker to either establish that Z * (N ) = Z * (N, β) and optimality is reached or give an indication that the set of cutting patterns have to be extended by increasing the current value of β.For the ease of the exposition of the theory below it is assumed that the solutions mentioned exist and β has appropriate values.
Theorem 1 constitutes on the one hand optimality conditions for the specified NS-2DSSSCSP based on the current information in the form of patterns with their associated waste that were generated by utilising a certain β.If these optimality conditions do not hold, it means that the solution associated with Z * (N, β) based on the current β-value is not optimal to the NS-2DSSSCSP.Thus the β-value must be increased in order to generate additional patterns and retesting the conditions for optimality so that Z * (N, β) = Z * (N ) could ultimately be confirmed.On the other hand, if optimality to the problem is confirmed in some way, it can be claimed that these conditions must hold.Thus, this theorem forms the basis of the theoretical part of this research and plays a central role in the implementation of the algorithm developed.It can also be seen that although the theorem is stated in terms of N to correspond to the so-called NS-2DSSSCSP, the value N is a generalization and can thus be applied to r, where r ≤ N in the NS-2DSSSCSP.
Proof: Consider the if-part first and let Z * (N, β) > Z * (N ) implying that Z * (N, β) is not optimal for the NS-2DSSSCSP.Then a β > β must exist such that Z * (N, β) > Z * (N, β ).This implies that the optimal solution for SW (N, β ) must have at least one pattern associated with a "new" pattern generated by the relaxation to β (i.e. ).This proves that Z * (N, β) is not optimal.This completes the proof.
Based on the concepts in Theorem 1, the attributes of the left hand sides of the optimality criterion is considered.For a given β, these left hand sides form a non-decreasing sequence in r for the r values under consideration.The value of the following theorem lies in the fact that it is sufficient to only check whether Z * (k − 1) + βS A ≥ Z * (k, β) for a certain k to confirm or reject optimality of Z * (k).This follows from the characteristics of the sequence which is proved below.

Theorem 2
The left hand sides of the optimality criterion used in Theorem 1 for a certain value of β viz.Z * (r) + (N − r)βS A {<, ≥}Z * (N, β) for r ∈ {1, 2, . . ., N − 1}, form a sequence that is non-decreasing in r. Proof: proving that the sequence is non-decreasing.
Corollary 1 gives some further information that follows from Theorem 1 and that may be useful in the development of algorithms.

Corollary 1
When optimal solutions are produced by applying the procedure suggested in the proof of Theorem 1, a sequence of optimal solutions Z * (r, β) = Z * (r) for r ∈ {1, 2, . . ., N − 1} are produced for the rS-2DSSSCSP.
Different methods are possible to establish underestimates Z U (r) for Z * (r) with Z U (r) ≤ Z * (r) ≤ Z * (r, β) and

Agorithms
The knowledge from Theorem 1 and 2 together with Corollary 1 and 2 can be used to develop the following procedure.
5.1 An algorithm to establish Z * (N ) Algorithm 1 (NS-algorithm) has been devised to establish Z * (N ) for a specified N > 1 for the NS-2DSSSCSP without necessarily generating all possible cutting patterns.N = 1 constitutes the trim-loss case (2D-SLOPP).It is assumed that β is large enough so that Z * (s, β) exists for all s ≤ N .It is also assumed that Z * (N, β) > βS A since the alternative would imply optimality for that N .For the empirical work presented in §6, the algorithm of Amaral and Wright [1] is used to generate cutting patterns.Although not explicitly reflected in the NS-algorithm, underestimates are computed and utilized in the developed program.

Establishing an optimal number of sheets
As an application and an extension to the NS-algorithm, Algorithm 2 as an order cutting algorithm (OC-algorithm) was devised to establish the optimum (minimum) number of sheets (or the number giving the minimum total waste area) needed to satisfy the given 2DSSSCSP.The OC-algorithm identifies the optimal number of sheets (N ) by employing the NS-algorithm in a structured manner for different N -values.
Define T A as the total area of the demand items.When the NS-algorithm is applied to a N -sheet problem (with N ≥ 1) and the NS-2DSSSCSP is solved, a value T * A (N ) is obtained denoting the total area of the demand items accommodated on the N sheets plus a residual waste of Z * (N ).It thus holds that holds that N S A < T A + Z * (N ) implying that the N -value is not optimal (too low) and gives a lower bound on the optimal N .If T * A (N ) = T A , it holds that N S A = T A + Z * (N ) implying that the N -value is either optimal or too large.It gives an upper bound on the optimal N and all the demand items are accommodated on the N sheets, giving a so-called full-fit.Some of the variables being used in the OC-algorithm to solve the 2DSSSCSP are explained next: MAX N is an upper bound on the optimal number of sheets needed giving a full-fit for the 2DSSSCSP.The initial MAX N may be established by means of a heuristic approach.The OC-algorithm strives to find the minimum MAX N .MIN N = LB N − 1 where LB N is a lower bound on the optimal number of sheets needed giving a full-fit for the 2DSSSCSP.The initial LB N may be computed based on a theoretical approach, e.g.T A /S A .The OC-algorithm strives to find the maximum MIN N and thus minimizes the area of the demand items not accommodated on the 'first' MIN N sheets.MIN N < MAX N by definition.
The STOP-criterion is activated when MAX N = MIN N +1.In this case MAX N will be the least number of sheets needed to satisfy the 2DSSSCSP, giving a full-fit.If MIN N is such that for Z * (MIN N ) the demand items not included in this solution do fit onto one additional sheet, it gives the solution with the best utilization possible in terms of waste regarding the first MIN N sheets and thus maximizes the unused area on the last sheet.
The implementation of the OC-algorithm employs a binary search approach to establish the optimal values for MAX N and MIN N .

Empirical work
In this section results are given that empirically evaluate the performance of the algorithms reported on in this paper.The data set used is a set of 12 problems (indicated by B1 to B12) as defined by Beasley [2].For each of these

System tested on the trim-loss problem
The first phase of the experimental work was to implement the algorithm of Amaral and Wright [1].A program was developed and tested [12] and compared to the results reported by Amaral and Wright for the same data set.Table 1 compares the results for problem B12 as a trim-loss problem from the test bed for the CSA and EWA algorithms as reported by Amaral and Wright [1] and the TSA-algorithm as implemented for this research.Remarks: • The time reported in Table 1 indicates only the time needed by the algorithms for producing the optimal pattern.The performance of the TSA-algorithm in terms of time seems to be good when compared to the time measurements as indicated by Amaral and Wright.• The waste generated by TSA for problem B12 3 for the optimal (trim-loss) pattern differs from the waste as reported by Amaral and Wright.The waste of 1476 reported by TSA corresponds with a legitimate pattern and it (TSA) also generated a pattern with the same waste of 2310 (as its second best pattern).It is unclear why Amaral and Wright did not find the optimal solution.

Feasibility of generating all cutting patterns
The next phase was to test the use of the TSA-algorithm on the whole set of 120 problems to generate cutting patterns.For each problem the algorithm starts with β = 0.0 and increases β with intervals of 0.01.The patterns generated are saved in a text file to be used in later experimentation.Although generally a time limit of two hours is set to generate the cutting patterns, extra time was allowed in some cases.Table 2 gives results regarding each of the problems.The first row in each triplet (Beta) contains the maximum value for β reached to generate cutting patterns within the allowable time; the second row (Time) indicates the total time (in seconds) needed to generate patterns from β = 0.0 up to the reported β (when stopped) and the third row (#Patt) indicates the number of patterns generated for the last β reported for the given problem.The TSA-algorithm generated all patterns (up to β = 1.0) for 87 of the 120 problems in the time allowed.From these 87 problems, 65 took less than 10 minutes.Only 5 of the remaining 22 took more than an hour.There are thus 33 problems for which not all (up to β = 1.0) cutting patterns could be generated in the time allowed.

Empirical work with the NS-algorithm
The main objective of the experiments here is to establish the feasibility of finding Z * (N ) by solving the model SW (N, β) for a given NS-2DSSSCSP and thus implementing the NSalgorithm.A procedure that calls CPLEX [10] in order to solve the model SW (N, β) was developed in the programming language C# to determine Z * (N ) given the set of demand items, the stock sheet dimensions and N.In solving a mixed integer program, CPLEX uses a tolerance option, epgap, with a default value of 0.0 which specifies the stop criterion for the relative tolerance on the gap between the objective of the best current feasible solution and a lower bound for the optimal solution.This gap is traditionally called the integrality gap.In cases where CPLEX cannot solve the model easily, it is necessary to manage this gap specification.Therefore, the time limit option, tilim, that determines the amount of time in seconds that CPLEX will devote to solve a problem, is set to 5 (i.e. 5 seconds).Whenever CPLEX finds a feasible solution to SW (N, β), but cannot establish optimality within the given time limit, epgap is increased by 0.001, and the process is repeated with the new gap tolerance.
Table 3 illustrates and summarizes the results for the model SW (N = 387, β) and the problem B12 3. The third column (Time for β) indicates the time taken by the TSAalgorithm to generate the patterns for the β indicated.
The total time taken by the NS-algorithm to compute Z * (N = 387) = 2360147 is 58.17 seconds and a β-value of 0.49 is sufficient to prove optimality.Similar experimentation was performed for different values of N on all the problems in the problem set.See §6.4 for further demonstration.

Empirical work with the OC-algorithm
As an extension to the NS-algorithm, the OC-algorithm was devised and developed as described in §5.2 to establish the optimal number of sheets to fulfill an order of demand items using same size sheets.This was applied to problem B12 3 and the results are shown in  Table 4 summarizes the results comparable to those in Table 3 for each N value in the order required by the OC-algorithm, thus sequentially from N = 387 to N = 439 when the stop criterion is reached.In the first row (Result) an entry of "Optimal" means that the NS-algorithm was able to prove utilization optimality for the N requested and an entry of "F.Fit" means that a full-fit was established for the specific N value.In the second and third rows (MIN N and MAX N ) the numbers indicate the values related to the resulting lower and upper bounds respectively after the application of the NS-algorithm.A minimum of 440 sheets are needed to fulfill the order of demand items.By inspecting the cutting patterns associated with Z * (N = 439), computations show that the remaining demand items correspond to a feasible cutting pattern for one sheet.It can therefore be concluded that by optimizing over N = 439 sheets, the area not utilized on the 440 th sheet is maximized.The fourth row in the table (Time) demonstrates the performance of the process in terms of time needed to solve the problem.The maximum β-value required to solve the problem is 0.51.
In order to further explore the wider applicability of the NS-algorithm and its extension, the OC-algorithm was applied to all 120 problems in the problem set.Table 2 indicates that for 33 of these problems the TSA-algorithm could not generate all the patterns up to β = 1.0 within the time limit.These 33 problems were investigated further and can be divided into two sets, i.e. a set of 12 problems with sufficient β-values (and patterns) to prove optimality by means of the OC-algorithm and a set of 21 problems requiring larger β-values (and patterns).to prove optimality.The second last column (#N ) indicates the number of times the OC-algorithm called the NS-algorithm with a specified N .The last column (Time for OC-algorithm) indicates the time needed for the OC-algorithm.Only problem B11 10 took more than 2 hours and the others took less than 1 hour each.It shows that even for problems for which it is time consuming to generate cutting patterns, the "readily" available patterns are often sufficient to prove optimality and in this case brings the total of 'solved' problems to 99 out of the 120.
The set of 21 problems not solved to optimality by means of the OC-algorithm, was analyzed further.The main objective was to get an indication as to "how far" one can get with the readily available patterns.In order to do this, the NS-algorithm was employed in a structured way with different values for N for each problem to establish the results as reported in Table 6.The  LB), calculated by (Column 5 + Column 8), serves as a measure of success by utilizing the available patterns.The gap seems to be useful since 16 of the problems have a gap of 3.85% or less with 6 of these with a gap of even less than 1%.These results suggest that the NS-algorithm may be valuable in heuristic search techniques like greedy search approaches.

Conclusions
The TSA-algorithm based on the work of Amaral and Wright [1] is given to enable the empirical research with efficient code.As a test bed, the problems as reported by Beasley [2] were adapted to give a total of 120 2DSSSCSP's.This implementation of the TSAalgorithm enabled the generation of all possible cutting patterns for 87 of the 120 test problems within the time allowed and is thus regarded as useful.
Table 3 illustrates the application of the NS-algorithm to solve the problem B12 3 exactly for a specified number of N = 387 sheets.It took 58.17 seconds with a maximum β value of 0.49 sufficient to prove optimality.Thus, in this case, the number of cutting patterns generated could be limited.The NS-algorithm was extensively tested on all 120 problems with a range of values specified for N according to the requirements of the OC-algorithm.
The OC-algorithm utilizes the NS-algorithm to solve the problem of finding the optimal number of sheets for cutting the total order.Table 4 illustrates the OC-algorithm applied to problem B12 3. The optimal number of sheets needed for this problem is N = 440 and it is also established that the area not used on the last, i.e. the 440 th sheet, is maximized.The time needed for each specified N (the NS-algorithm) does not exceed 72 seconds showing that the process is feasible for this problem.The lowest β value sufficient to solve the problem to optimality is 0.51.
For 82.5% of the 120 test problems the application of the OC-algorithm results in the optimal number of sheets (and cutting patterns) and in that sense demonstrates the generalization of the trim-loss problem for a single sheet to N sheets (without necessarily βS A < waste of new pattern ≤ β .S A ). Let there be (N − r) such new patterns.The other r patterns in the solution have associated waste ≤ βS A .It can be argued that, for the solution associated with β , Z * (N, β) > Z * (N, β ) = waste of r patterns with waste ≤ βS A + waste of (N − r) new patterns with βS A < waste ≤ β S A ≥ Z * (r) + waste of (N − r) new patterns with βS A < waste ≤ β S A > Z * (r) + (N − r)βS A This proves that an r exists such that the condition does not hold.Consider the only-if-part next and say that an r ∈ {1, 2, . . ., N −1} with N ≥ 2 exists such that Z * (r)+(N −r)βS A < Z * (N, β).Adjust the model SW (N, β) by removing the number of demand items in the model that are included in the patterns used in the solution that gives Z * (r) and thus adjusting the upperbounds specified on those demand items.Solve the adjusted model SW a (N − r, β) and find the objective function value Z a (N − r, β).The combination of patterns that form the solutions giving the objective function values Z * (r) and Z a (N − r, β), is a feasible solution to the original model SW (N, β) and thus one can argue that Z * (N, β) > Z * (r) + (N − r)βS A ≥ Z * (r) + Z a (N − r, β an underestimate for Z * (r) for situations where Z * (r−k) and Z * (k) (or good underestimates of them) are known.Utilizing this may save considerable computational time.Formally, the following corollary follows directly from Theorem 1.Corollary 2If Z U (r) + (N − r)βS A ≥ Z * (N , β) for all r-values with r ∈ {1, . . ., N − 1} and N ∈ {2, . . ., N }, one can conclude that Z * (N , β) = Z * (N ).

Algorithm 2 : 5 if 6 MAX N = N 7 else 8 MIN N = N 9 N 2 10
OC-algorithm: An order cutting algorithm 1 Input: The 2DSSSCSP and initial values for MAX N and MIN N , 2 N = (MAX N + MIN N )/2 3 while MAX N > MIN N + 1 do 4 Execute the NS-algorithm to establish Z * (N ) STOP reason = "Full Fit" then = (MAX N + MIN N )/Output: The optimal MAX N and MIN N .
first and second columns (Initial LB and Initial UB) correspond to the (initial) LB and (initial) MAX N respectively as discussed earlier.As another lower bound the fifth column (Max N Opt) gives the maximum N for which optimality of utilization is proved using the available patterns.The sixth column (Max β N Opt) indicates the maximum β with associated patterns sufficient to prove optimality for the corresponding Max β N Opt value.The fourth column (Min N F.Fit) indicates the minimum N for which a full-fit is established by the NS-algorithm.For only two problems, B6 2 and B6 8, it was not possible to establish a full-fit utilizing the available patterns.The seventh column (% not utilized) gives the percentage of the area of demand items not included as part of the Max N Opt sheets while the eighth column (N not placed) gives a theoretical lower bound on the number of sheets still needed to cut these demand items.The last column (%Gap) is calculated by ((Column 4 -Column 9)/ Column 4)×100.Column 9 (Final 12problems a set of 10 stock sheet sizes is available.Beasley considered the 2DMSSCSP type of problem and did empirical work on these 12 problems.The research in this paper focuses on the 2DSSSCSP type of problem and for experimental purposes each of these 12 problems is specified as a range of 10 2DSSSCSP's by considering the set of demand items as specified for each of the stock sheet sizes separately.The first 2DMSSCSP, B1, is thus associated with 10 2DSSSCSP's named B1 1, . . ., B1 10 and similarly for B2, B3, . . ., B12.Finally, the resulting 120 problems are indicated by B1 1; . . .; B1 10; B2 1; . . .; B12 1; . . .; B12 10.The code developed to test the algorithms and approaches, were written in the programming language C# (Microsoft Visual Studio 2008) and implemented on a HP Notebook computer with 2 Gb RAM and a 2.40 GHz Intel R core TM 2 Duo CPU.

Table 1 :
A comparison of the results by Amaral & Wright and this research.

Table 4 .
The initial value (319) for MIN N is computed theoretically by using the total area of the demand items and the sheet size.The initial value (455) for MAX N is computed by means of an available glass cutting program based on heuristic approaches.

Table 2 :
[2]ummary of the TSA results for the data set from Beasley[2]

Table 5
gives the results of the 12 problems.The sixth column (TSA Max β) gives the largest β-value for which patterns were generated in the allotted time.The seventh column (OC-alg Max β) gives the final β-value employed by the OC-algorithm to prove optimality while the eighth column (Time for β sufficient) gives the time needed by the TSA-algorithm to generate patterns up to the β-value sufficient

Table 4 :
A summary of the results for the OC-algorithm applied to problem B12 3.

Table 5 :
The OC-algorithm applied to the set of 12 problems (with β < 1.0) not solved to optimality.