An efficient GRASP algorithm for disassembly sequence planning ...

OR Spectrum 29: 535–549 (2007) DOI 10.1007/s00291-005-0028-x

REGULAR A RT ICLE

Belarmino Adenso-Díaz . Santiago García-Carbajal . Sebastián Lozano

An efficient GRASP algorithm for disassembly sequence planning Published online: 12 January 2006 © Springer-Verlag 2006

Abstract One of the steps in a reverse supply chain is to disassemble the recovered products. The design of such disassembly operations is more complex than that of classical assembly lines. A new GRASP algorithm is presented in this paper for solving Disassembly Sequence Planning, i.e. the determination of the sequence for disassembling component parts. The problem has a combinatorial structure and a large number of constraints. Moreover, checking the feasibility of each solution element is time consuming. The proposed approach is successfully tested against previous best known solutions for a set of public benchmark problems. Keywords Reverse logistics . Disassembly sequence . GRASP 1 Introduction Reverse logistics may be defined as the process of effectively planning and efficiently implementing and controlling the material flow (and associated information flow) from consumers to processing plants with the aim of recovering value or providing an adequate end-of-life destination. Of the five steps in a reverse supply chain (Guide and van Wassenhove 2002) (namely product acquisition, return logistics, inspection and disposition, reconditioning, and distribution and sales), this paper will focus on the last but one, which includes all the operations required by the product (disassembly, cleaning, etc) to reach the pursued end-of-life goal. In particular, the problem we will tackle is that of planning the disassembly process. B. Adenso-Díaz (*) . S. García-Carbajal Escuela Politécnica Superior de Ingeniería, Universidad de Oviedo, Campus de Gijón, 33204 Gijón, Spain E-mail: [email protected]; [email protected] S. Lozano Escuela Técnica Superior de Ingeniería Informática, Universidad de Sevilla, Avda. Reina Mercedes, s/n, 41012 Sevilla, Spain E-mail: [email protected]

536

B. Adenso-Díaz et al.

Disassembly is a fairly common need in order to recover materials with a high degree of purity, reuse components or subassemblies or simply remove toxic materials. For economic, environmental as well as legal reasons, disassembly operations are becoming more widespread. With the grow of its economic impact there has been a justified increase in research. Two phases may be considered in a disassembly process (Güngör and Gupta 1997): a. Disassembly planning. This phase includes the Disassembly Levelling Problem (i.e. determining down to which level of the disassembly product structure to disassemble) as well as Disassembly Sequence Planning (a.k.a. Disassembly Process Planning, i.e. determining the order in which to dismount joints and remove parts). b. Disassembly scheduling. This phase consists in determining the time and the amounts to process in the actual disassembly operations, on the basis of demand and minimizing costs. This paper will address the Disassembly Sequence Planning Problem. Section 2 presents a review of existing approaches. The problem will be formulated in Section 3. A metaheuristic solution method (namely a GRASP algorithm) is proposed in Section 4. Extensive computational experiences on benchmark problems are reported in Section 5. Finally, Section 6 presents our conclusions and possible lines for further research. 2 Literature review As mentioned above, the Disassembly Sequence Planning Problem (DSPP) consists in deciding the order in which the different parts of a given product should be disassembled and the desired components extracted. One of the first steps that must be taken is to choose an adequate way to represent the solutions, i.e. the different disassembly plans. Although both Liaison graphs (Bourjault 1984) as well as Digraphs (Park and Chung 1993) have been proposed, the most commonly used representation is that of AND/OR graphs (Homem de Mello and Sanderson 1991). Each disassembly step is represented in an AND/OR graph by a number of arcs from a node representing the subassembly to the nodes representing its constituent parts or subassemblies. These graphs simultaneously show all the alternative ways of disassembling the product and may thus be considered a reasonably compact representation of the solution space. The number of alternative solutions grows exponentially with the number of components. Initial attempts to evaluate all feasible solutions (Baldwin et al. 1991) quickly become impractical due to the combinatorial explosion of alternatives. In Lambert (2003), existing approaches are classified in two broad categories: a. Mathematical programming. These approaches require adequate modelling of the problem, which makes it difficult for them to include too much detail. These approaches are often used as an exploratory tool. Some approaches use Mixed Integer Linear Programming (MILP) methods. Thus, Spengler et al. (1997) presents two MILP models for solving two different

GRASP algorithm for disassembly sequence planning

537

real life recycling planning problems (Kanehara et al. 1993). Transforms an AND/OR graph into a Petri net using MILP. A number of basic concepts (such as the transition matrix) were introduced in the aforementioned paper. Subsequently Lambert (1999a) presented a simplified LP model adding the possibility of grouping the components in clusters (Kang et al. 2001). Proposed a modification of Kanehara et al. (1993) in order to consider sequencedependent disassembly costs. Additionally, the possibility of incorporating multiple criteria has been discussed in Lambert (1999b). Other approaches use Dynamic Programming. For instance Penev and De Ron (1996) applied Bellman’s principle to a small AND/OR graph. A similar approach, using Dynamic Linear Programming, was applied in O’Shea et al. (1999) for tool selection and also in Hoshino et al. (1995) for the analysis of a simple recycling line. b. Approximate methods. These approaches are favoured in practice as they can handle more detailed (e.g. CAD) data than exact methods. Within this category, we may find heuristics, Artificial Intelligence methods, and metaheuristics. Among the heuristic approaches, Pu (1992) proposed a number of techniques for learning to reuse the knowledge about assembly sequences. Veerakamolmal and Gupta (2002) use similar techniques to study the disassembly of modular electronic equipment. In Swaminathan and Barber (1996), a similar approach is proposed, decomposing problems into simpler ones and keeping a solutions library for reuse. Swaminathan and Barber (1996) represents the disassembly process using three graphs: a connection diagram, a joints direction diagram and an obstacle direction diagram. Güngör and Gupta (1997) also use these diagrams and develop a heuristic which they apply to the disassembly of a personal computer. Kuo et al. (2000) use a heuristic procedure to identify subassemblies in order to establish precedence relationships and thus simplify the determination of the disassembly sequence. Erdos and Kis (2001) proposed an algorithm to generate the disassembly graph based on the connection diagram and a set of precedence constraints. Once the disassembly graph is obtained, the disassembly sequence is computed using a shortest path algorithm. Martínez et al. (1997) use a multi-agent systems approach to generate the disassembly sequence from the disassembly graph. Huang et al. (2000) use a Hopfield–Tank neural network, relaxing all precedence constraints and introducing corresponding penalties in the energy function. Scholz-Reiter et al. (1999) solve the problem using a Bayesian Network approach trained with existing data. Among the metaheuristic approaches, the most common are evolutionary algorithms (e.g. Abe et al. 1999; Caccia and Pozzetti 1999; De Lit et al. 2001; Dini et al. 1999; Murayama et al. 1994; Seo et al. 2001), although Ant Colonies (Failli and Dini 2001), Tabu Search (Adenso-Díaz et al. 2002) and Scatter Search (González and Adenso-Díaz 2006) have also been applied. 3 Problem formulation Consider a product formed by a set of components C={C1, C2,..., Cn} joined by a set of joints J={J1, J2,..., Jm}. The optimum Disassembly Sequence Planning Problem consists in determining the order in which these joints are to be broken and the components removed so as to minimize the costs incurred. Thus, a solution

B. Adenso-Díaz et al.

538

to the problem is a permutation of the union of the components set and the joints set. However, although a solution is a permutation of C∪J, not all such permutations are valid sequences, since, for example, a component cannot be removed before all the joints that affect that component have been released or if the component cannot be accessed. Likewise, a joint cannot be broken before all the components that obstruct access to that joint have been removed. To illustrate this, consider Fig. 1, which shows a product with three components and three joints. The sequence 〈J1, J3, J2, C3, C1, C2〉 is infeasible for two reasons: – Joint J3 cannot be broken before component C1 (which obstructs access to that joint) is disassembled – Component C3 cannot be removed before components C1 and C2 Let Ji be the set of joints that join component Ci with any other component. Let a solution be represented as a sequence S ¼hXi ;:::Xnþm i where Xj 2 C [ J for j ¼ 1; 2;:::; m þ n . Let SR(Xj)⊂S be the subsequence of S to the right of component or joint Xj. This subsequence includes all the components not removed and all the joints not released before the processing of Xj. We may thus express the feasibility constraints as: F1. To remove any component Ci: F1.1. 1.1. No joint involving Ci can remain in SR(Ci), i.e. all joints involving Ci F must have been previously released F1.2. 1.2. Ci cannot be completely obstructed by the elements in SR(Ci), i.e. some F access direction to Ci must be free F2. To break any joint Ji: no component in SR(Ji) must obstruct the release of joint Ji In order to be able to check whether a given permutation S is feasible, it is necessary to have the information on the interferences between joints and components and among the components themselves. Generally, this information can be generated from the CAD data of the product to disassemble. A number of alternative ways to represent this information so that feasibility checking may be easily (uli) C1 C2 C3 J1 0 0 0 J2 0 0 0 1 0 0 J3

C1

J3

J2 C3

J1

C2

y

(cij) C1 C2 C3

C1 0 (0010)=2 (1110)=14

C2 (0001)=1 0 (1101)=13

C3 (1101)=13 (1110)=14 0

x Fig. 1 Example of a 2D product with three components and three joints, and its corresponding Joints Accessibility (uli) and Disassembly Precedence (cij) matrices (z dimension is omitted in the Precedence matrix)

GRASP algorithm for disassembly sequence planning

539

performed have been proposed in Huang and Huang (2002). We will use the method proposed in González and Adenso-Díaz (2006), which only requires two matrices: – Joints accessibility matrix. The elements uli of this matrix are binary and indicate whether accessing joint Jl in order to break it is impeded by the presence of component Ci – Disassembly precedence matrix. The elements cij of this matrix indicate, for each component Ci, which access directions are obstructed by component Cj. For the sake of simplicity, the possible access directions usually considered are those along the Cartesian axes. Thus, assuming that the product is fixed on a horizontal table or on the floor, we can consider five possible access directions (±x, ±y, +z). Thus, each entry cij in this matrix can be expressed as five bits, each one corresponding to each of the five access directions. A bit value of one means that that access direction to Ci is obstructed by Cj. In the 2D example shown in Fig. 1 and considering only four possible access directions, i.e. (+x, −x, +y, −y), entry c31 in the matrix, which corresponds to the access directions for which component C1 obstructs removal of component C3, would be the binary vector (1,1,1,0) or its equivalent decimal value 14. Hence, using the above notation, solving the DSPP requires:

 – Exploring all permutations S ¼ Xj with Xj 2 C [ J; j ¼ 1; 2;:::; m þ n – Discarding all those permutations that do not verify any of the conditions F1. and F2. This can be done using the information provided by matrices uli and cij. Figure 2 shows the pseudocodes used to check the feasibility constraints. – Evaluating the cost of each feasible solution and saving the most cost-effective F1.1.feasible=false For each component Ci not yet disassembled If all joints Jl∈Ji have been broken then feasibility constraint F1.1.feasible=true for component Ci Endfor

F1.2.feasible=false For each component Ci not yet disassembled For each possible access direction d If the d-th component of the binary vector cij for every component Cj not yet disassembled is 0 then feasibility constraint (Cj≠Ci) F1.2.feasible=true for component Ci Endfor Endfor

F2.feasible=false For each joint Jl not yet broken If uli=0 for all components Ci not yet disassembled then F2.feasible=true for joint Jl Endfor Fig. 2 Pseudocode of feasibility constraints F1 and F2

540

B. Adenso-Díaz et al.

A surrogate for the costs incurred is the total disassembly time, i.e. the sum of time taken in all disassembly steps including the delays due to tool changes, product rotations and other changes in the work direction. The evaluation of these delays also requires CAD information on the product. Note also that we have considered the most difficult scenario, i.e. a complete disassembly of the product is required. This is not always the case since recycling companies often only need to disassemble some of the component part (namely those that are reusable and those that contain toxic or hazardous materials), shredding the rest. However, it may be expected that, in the future, ‘deeper’ disassemblies will be more frequent. 4 Proposed solution algorithm In order to solve DSPP we have designed a Greedy Randomized Adaptive Search Procedure (GRASP) algorithm. GRASP (Feo and Resende 1995) is a well known metaheuristic algorithm that has been successfully applied to a large number of combinatorial optimisation problems (Festa and Resende 2002; Pitsoulis and Resende 2002; Resende 2001). GRASP generates multiple solutions through a two-step process. In the first step a solution is generated using a greedy, nondeterministic mechanism. In the second step, the generated solution is improved through local search. The program code is available from the authors upon request. Before describing the solution generation mechanism, let us consider the fact that although a disassembly sequence specifies the order of disassembly of both components and joints, the latter may be computed given the components sequence only. Given a certain component to be extracted and in accordance with constraints F1.1, some joints may need to be broken. However, since their number is usually small, the most cost-effective order of breaking them (taking into account the necessary tool changes, directions, etc) can generally be computed by simply evaluating all the possible permutations of these joints not yet broken. Although this may seem a source of inefficiency, it is actually a better alternative than exploring the solution space of permutations of order n+m associated with the complete sequence of components and joints. Thus, for the simple example shown in Fig. 1, by considering components only, the number of permutations reduces from ð3 þ 3Þ! ¼ 720 to 3! ¼ 6 of which only four satisfy F1.2. Similarly, for the joints, we also have 3!=6 possible sequences in principle although, since according to F2, J3 cannot be broken prior to breaking J2 which reduces the number of feasible sequences for the joints to three (J2J3J1; J2J1J3; J1J2J3). Now, all these three joints sequences have to be merged with the four sequences for the components, subjected to F1.1. For instance, merging 〈C1, C2,C3〉 with the sequence of joints potentially gives a large number of global sequences. However, J3 has to be removed prior to C2 and after C1, thus its position is fixed. Moreover, J2 has to be removed prior to C1, and J1 prior to C2. Hence, after merging those predefined sequences the only four possible sequences to check costs are 〈J2C1J3J1C2C3〉; 〈J2C1J1J3C2C3〉, 〈J2J1C1J3C2C3〉; 〈J1J2C1J3C2C3〉.

GRASP algorithm for disassembly sequence planning

541

Therefore, in order to generate a solution, what we have to decide primarily is the order in which to disassemble the n components. This will be done starting from scratch and inserting one component at a time in the sequence. The process of generating a solution thus takes exactly n steps. In each step, only components that are compatible with constraints F1 after feasibly releasing all the necessary joints are considered. These components form the so-called Candidate List (CL). An index is computed for each of these components that reflects how interesting is disassembling that component in that position. The smaller this index is, the more interesting it is to select that component to be disassembled in that position of the sequence. The index associated with each component Ci is composed of two terms (Adenso-Díaz et al. 2005): – Oi measures the reduction in the obstruction level of the remaining components that occurs if Ci is removed. This can be easily computed from the corresponding row cij of the disassembly precedence matrix as the number of components Cj not yet disassembled that were somehow obstructed by Ci: Oi=card{Cj: Cj not removed yet ∧ Cj≠Ci ∧ Cj≠(0,..,0)} – Ui measures the number of remaining joints that are obstructed by Ci and whose release is therefore facilitated if Ci is removed. This can also be easily computed from the corresponding column uli of the joints accessibility matrix: Ui=card{Jl : Jl not broken yet ∧ uli =1} Normalizing and adding these two terms, we can compute the index: Indexi ¼ 1
½0:5  ðOi =O
½0:5  ðUi =UÞ

(1)

where O=max{Oi} and U=max{Ui} are the maximum values of Oi and Ui respectively for all components i that remain to be disassembled. These normalization factors guarantee that the index always take values in the interval [0,1]. Note that the index gives the same weight to both terms. Also note that both terms appear with a minus sign. This is because for both of them the larger the term, the more interesting it is to select Ci from the Candidate List CL. Once the corresponding index of all the components in CL have been computed, a so-called Restricted Candidate List (RCL) is formed containing the more promising candidates. To that end, a threshold T can be computed with the minimum and maximum values of Indexi and a fixed parameter α∈[0,1] T ¼ min ind þ
 ðmax ind
min ind Þ

(2)

so that the RCL is formed by those components whose corresponding Indexi is below (or equal) to T. The component to insert in the sequence in each step is randomly selected among those in its corresponding RCL. Therefore, parameter α controls the randomness of the algorithm. A value α=0 means that only the component with the best (i.e. lowest) index value is included in the RCL and the solution generation method is deterministic. Conversely, for α=1, all components in the CL are also in the RCL and the generated solutions are completely random. Once all the components have been inserted in the sequence, the generated solution is improved using a local search algorithm. The neighbourhood definition used consists in selecting a component and changing its position to the right (i.e. to

B. Adenso-Díaz et al.

542

window C1

C2

C3

C4

C5

C6

C7 ... C100

C5

C6

C7 ... C100

window C1

C2

C3

C4

Fig. 3 Examples of moves during the local search phase for a window size W=3

be disassembled later) a number of positions (Fig. 3). For example, given the sequence 〈1,2,3,4,5〉, changing the position of each component in order would produce tentative neighbours. By changing component 1 (underscored) we can explore the following neighbours: 〈2,1,3,4,5〉, 〈2,3,1,4,5〉, etc. Of course, not all neighbours thus generated are feasible, i.e. only those changes compatible with constraints F1 and F2 are valid. An advantage of this neighbourhood definition is that the subsequence to the left of the component to displace as well as the subsequence to the right of the new position remain unaltered by the change and therefore do not intervene in the computation of the movement value, i.e. the impact of the change on the solution cost. On the other hand, the size of this neighbourhood (and the computational expense to explore it completely) is relatively large (O(n2)), which led us to establish a limit to the number of positions that each component may be displaced. We call this a window. The larger the window size W, the more expensive the search, though potentially the better the solution obtained, since more solutions are explored. Note that although the index in GRASP is usually directly related to the objective function, that does need not be necessarily the case. In our case, since in our problem accessibility constraints play a prominent role, we should be more concerned with avoiding the situation of having an empty candidate list at some point of the constructive process. Thus, we have designed the index to maximize the likelihood of getting a feasible solution, leaving to the local search the task of improving its cost. Finally, note that the proposed GRASP algorithm may be used also in the case of partial disassembly. In that case, the parts to be disassembled and the joints to be released would be a subset of the components and joints respectively. 5 Computational experiments In order to benchmark and validate the proposed GRASP algorithm, we will use a set of 48 test problems from the literature for which the best known solution is kept up-to-date on line (http://coruxa.epsig.uniovi.es/~adenso/file_d.html). The test problems (of size n=25, 50, 75 and 100) were generated using the GEN-PRODIS tool (Adenso-Díaz et al. 2002), which is able to generate an unlimited number of random test cases with specified characteristics (number of components and degree

GRASP algorithm for disassembly sequence planning

543

Table 1 Objective function value of previous best solution (González and Adenso-Díaz 2006) for each product in the testbed, and of the solution given by the proposed GRASP algorithm (the window size with which the solution was found is shown in the last column) Number of Product compact/ Product Id. components, n disperse in the testbed 25

50

75

D C C C C C C C D D D D D C C C C C C C D D D D D C C C C C C C D D D D

Previous best Solution found W known solution (s) by GRASP (s)

100-025-005-05 2,680.35 101-025-009-20 2,237.90 102-025-012-40 2,806.32 200-025-025-40 2,671.58 201-025-037-40 2,748.66 202-025-050-40 2,475.84 800-025-005-40 3,346.81 301-025-009-20 2,416.61 302-025-012-05 2,403.28 400-025-025-05 2,246.03 401-025-037-05 2,347.49 402-025-050-05 2,199.36 103-050-010-05 5,612.23 104-050-017-20 6,287.85 105-050-025-40 6,264.67 203-050-050-40 5,794.95 204-050-075-40 5,866.47 905-050-100-40 6,035.14 303-050-010-40 6,535.13 304-050-017-20 5,677.01 305-050-025-05 4,797.79 403-050-050-05 4,759.34 404-050-075-05 4,634.32 405-050-100-05 5,021.48 106-075-015-05 8,349.43 107-075-025-20 8,513.75 108-075-037-40 8,998.58 206-075-075-40 9,152.21 807-075-115-40 9,233.54 708-075-150-40 9,061.98 706-075-015-40 10,241.85 307-075-025-20 8,897.22 308-075-037-05 7,384.23 406-075-075-05 7,416.56 407-075-115-05 8,081.81 408-075-150-05 7,692.02

2,660.65 2,229.75 2,729.70 2,589.92 2,618.28 2,370.66 3,247.13 2,416.54 2,381.00 2,245.26 2,347.49 2,199.36 5,518.84 6,157.29 6,042.06 5,646.08 5,646.05 5,728.53 6,250.78 5,480.14 4,735.24 4,691.25 4,549.34 4,854.78 8,162.10 8,482.35 8,348.36 8,780.03 8,952.31 8,636.93 9,860.06 8,673.36 7,271.83 7,225.36 7,696.30 7,438.65

0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.5 0.6 0.6 0.6 0.6 0.6 0.5 0.6 0.6 0.5 0.6 0.6 0.6 0.5 0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.6 0.5 0.6 0.6 0.6

B. Adenso-Díaz et al.

544

Table1 (continued) Number of Product compact/ Product Id. components, n disperse in the testbed

Previous best Solution found W known solution (s) by GRASP (s)

100

10,814.52 12,009.52 13,498.39 12,680.53 12,352.61 12,376.75 14,255.20 12,037.92 10,616.02 10,860.06 10556.30 10,673.40

D C C C C C C C D D D D

109-100-020-05 110-100-033-20 111-100-050-40 509-100-100-40 210-100-150-40 711-100-200-40 809-100-020-40 310-100-033-20 311-100-050-05 409-100-100-05 410-100-150-05 411-100-200-05

10,559.90 11,603.90 12,653.80 12,196.60 11,537.90 11,619.30 13,382.10 11,761.50 10,228.70 10,426.50 10,244.00 10,165.90

0.6 0.6 0.6 0.6 0.6 0.6 0.5 0.5 0.6 0.6 0.6 0.6

of compactness). All components are right-angled parallelepipeds, a component may not be involved in more than eight joints and the total number of disassembly tools was set to five. As for the values of the parameters of the GRASP algorithm, a value α=0.75 was used in order to have enough candidates in the RCL, and the total number of GRASP trials was set to N=200. Several values of the neighbourhood window size for the local search were considered, namely W∈{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6}, as a percentage of the size n of the product. Larger values of the window size W may require an excessive amount of computing time. Note also that W=0 corresponds to not carrying out the local search but only the greedy, constructive phase. The algorithm was coded in C++ and all experiments were run on a Sun Fire 15 K, at 1.2 Ghz. For these parameters, the best results obtained for each instant of the testbed are shown in Table 1. It can be seen that the best known solution to date for these

Average cost ratio

1.05 1.04 1.03 1.02 1.01 1 0.99 0%

10%

20%

30%

40%

50%

60%

WINDOW SIZE,W n=25

n=50

n=75

n=100

Fig. 4 Average value of the ratio best_solution_known/solution_GRASP, for different product sizes n, and different window sizes W

GRASP algorithm for disassembly sequence planning

545

3000

comp. time (s)

2500 2000 1500 1000 500 0 0%

10%

20%

30%

40%

50%

60%

WINDOW SIZE,W

n=100

Average 48 instances

Fig. 5 Computing time of the GRASP procedure as a function of the window size W, for the most complex instances (n=100), and for the 48 instances in the testbed

instances was improved on in all cases (except for two, in which a draw was obtained). It can also be seen that the best solution was obtained with the maximum window size considered, W=0.6, except in seven of the 48 resolved cases (in which the best solution was obtained for the size W=0.5). Figure 4 shows the average ratio of the cost of the best previous solution (González and Adenso-Díaz 2006) and the cost of our GRASP solution. As expected, the greater the size of the window W, the greater the improvement obtained by the GRASP solutions with respect to the best known solutions to date. This relation increases in direct proportion to the size n and thus the complexity of the product. As regards calculation times, logically these increase notably as the size of W increases, said increase once more depending on the complexity of the product to disassemble (Fig. 5). It was decided not to continue trials for W values greater than 0.6, since the calculation times for larger instances became prohibitive within realistic calculation scenarios. Thus, if we concentrate on the solutions obtained with GRASP using W=0.6 (which we will call GR) and in order to statistically validate that the results are significantly better than those obtained with the best algorithm reported to date (González and Adenso-Díaz 2006, which we will represent as SS), we may consider the use of a parametric test, given that the Kolmogorov–Smirnov test Table 2 Results of the paired t-test, for SS and GR algorithms Size n

Average SS – GR

95% interval for SS – GR

t-value

Degrees of freedom

Sign

Correlation

25 50 75 100

45.27 156.69 290.33 518.56

13.89∼76.66 107.72∼205.67 185.21∼395.44 379.69∼657.43

3.175 7.042 6.079 8.219

11 11 11 11

0.009 2.15×10−5 8.0×10−5 5.0×10−6

0.993 0.996 0.983 0.990

B. Adenso-Díaz et al.

546

applied to these data allow us to assume them to be normally distributed. Using the paired t-test segmented according to the size of the instances (Table 2), it can be seen that the GR algorithm is statistically superior the SS algorithm in all cases. It can also be seen in Table 2 that a strikingly high correlation exists between both variables for all the sizes, as confirmed by a scatter diagram of the two variables (Fig. 6). We may use a regression model that allows us not only to confirm the difference in quality of the solutions obtained with the two algorithms, but also calibrate the improvement obtained using GR. Thus, considering a regression model for ‘successive steps’, and establishing as independent variables, in addition to SS, the size and compactness of the products, we find that the latter variables are not included by the model, being GR ¼ 128:72 þ 0:947  SS þ " , with R2=0.999. In this case, it is important to be able to state that the coefficient 0.947 of the variable SS (which obtained a standard error of s1=0.005) is in effect different to 1, which is the same as stating that GR offers an improvement of 5.3% with respect to the solutions obtained with SS. To do so, we establish the null hypothesis H0:β1≥1 (i.e., the coefficient of variable SS in the regression equation is not smaller than 1), against the alternative hypothesis H1:β1