Robust solutions to an uncertain storage loading problem

HANOI PEDAGOGICAL UNIVERSITY DEPARTMENT OF MATHEMATICS ——————–o0o——————— Tran Khanh Huyen Robust solutions to an uncertain storage loading problem BACHELOR THESIS Major: Applied Mathematics Hanoi, May 2019 HANOI PEDAGOGICAL UNIVERSITY DEPARTMENT OF MATHEMATICS ——————–o0o——————— Tran Khanh Huyen Robust solutions to an uncertain storage loading problem BACHELOR THESIS Major: Applied Mathematics Advisor: Dr Le Xuan Thanh Hanoi, May 2019 Confirmation I hereby confirm that this thesis is my original work completed under the guidance of Dr Le Xuan Thanh The presented results are accurate and correctly cited Author Acknowledgements By the occasion of presenting this thesis, I would like to express my sincere gratitude to the teachers of Hanoi Pedagogical University 2, especially the teachers in the Department of Mathematics The lecturers have imparted valuable knowledge and facilitated for me to complete the courses and the thesis In particular, I would like to express my deep respect and gratitude to Dr Le Xuan Thanh (Institute of Mathematics, Vietnam Academy of Science and Technology) who has direct guidance and helps me to complete this thesis Professionalism, seriousness and his right orientations are important prerequisites for me to get the results in this thesis Due to my limited capacity and knowledges, my thesis cannot avoid errors I look forward to receiving valuable comments from readers Author Contents Introduction 1.1 Motivation 1.2 Robustness concepts 1.3 Mixed integer linear programming 1.4 Thesis outline 6 11 12 Problem formulation 13 2.1 Deterministic setting 13 2.2 Interval uncertainty 15 2.3 Robust problems 16 IP-based approach 18 3.1 An IP formulation for deterministic problem 18 3.2 An IP formulation for strictly robust problem 20 3.3 An IP formulation for adjustable robust problem 21 Numerical experiments 26 4.1 ZIMPL codes 26 4.2 Numerical results 34 Conclusions 36 Chapter Introduction Storage loading problems are active topics in operational research because of their practical applications in the context of container terminals, container ships, warehouses or steel yards (see [5] and references therein) Such problems appear when incoming items arrive at a storage area and one has to temporarily assign them to positions in a convenient way for handling afterwards This thesis studies a storage loading problem in which the input data are subjected to interval uncertainty In Section 1.1 we will shortly introduce our considered problem and its motivation Then in Section 1.2 we present the principles of some robustness concepts that can be applied to our considered problem Section 1.3 shortly introduce about mixed integer programming which is our tool in solving the considered problem numerically The outline of this thesis will be sketched in Section 1.4 1.1 Motivation To describe our studied storage loading problem, we need to specify configuration of storage areas, how the items are specified, constraints on stacking the items, and objectives of the storage loading process In term of storage loading problems, storage areas are places for storing items such as containers, load units like carton boxes, trams or buses The storage area is often arranged in parallel stacks In this thesis we not matter the positions of stacks in the area, while it is important to decide which stack for putting each item As we usually see in practical contexts, within each stack, items are stockpiled on top of each other (i.e., each item must be either located on the ground or stacked directly on top of another item), and they are stored and retrieved in the last-in-first-out order Normally, each item occupies one level in its stack In this setting, each stack is devided into levels, and the number of levels in each stack is limited by technical issues Our consideration is restricted to the case that the stacks have the same number of levels In which order the items are stored is also an important aspect of storage loading problems This thesis studies a specific case of storage precedence of incoming items In details, our case study deals with a sequence of sets of incoming items The precise context is that practitioners have to store one set of items into a partly filled storage area, taking into account that another set of items will be stored later Within each of the item sets, it does not matter that which item is stored earlier or later than the others This context appears in practice where several trains or vessels consecutively arrive at a container terminal, each one containing a set of containers that have to be loaded into the storage area Regarding the order of arrival, we need to completely store all items of one set before any item of the successive set Each item may have an associated value representing its weight (or its length, its time to be retrieved, etc.) It is often the case that we are certain about the data of the items currently at hand but uncertain about the data of the items arrive later In this thesis we follow the idea that we know exactly the associated values of the items that are already in the storage area and the ones just come and have to be loaded now, while for each item coming later its associated value may vary in a compact interval specified in advance The associated value of each item may make some restriction on the possibility of stacking the item on top of the others Such restriction (so-called stacking constraint) reflects the fact that in practice lighter items are often put on top of heavier ones, shorter items are often put on top of longer ones, or items of less retrieving priority are often put under the ones of higher priority Often practitioners would like to use as few stacks as possible to store the items in order to keep more flexible space for items arriving in the future Therefore, we focus on the objective of minimizing the number of stacks used to store all the items, subjected to the stacking sequence and stacking constraints mentioned above 1.2 Robustness concepts We are considering an optimization storage loading problem under uncertainty of items’ data Since the storage activities are often time consuming, practitioners often would like to have a “robust” stacking solution that somehow immunes to the affect of data uncertainty This motivation leads to the application of robust optimization theory to the context of our studying problem In this section we recall the principles and formal descriptions of two well-known robust optimization concepts: strict robustness and adjustable robustness A comprehensive study on these concepts is given in [2] An uncertain optimization problem is a family (Pξ )ξ∈U of optimization problems (Pξ ) f (x) s.t F (x, ξ) ≤ 0, x ∈ X, in which • ξ is the parameter vector representing data elements of the problem (Pξ ), each value of ξ is called scenario; • U ⊂ Rp (for some p ∈ N) is called uncertainty set, which consists of considered values of parameter ξ; • x is the decision vector and X ⊂ Rn (for some n ∈ N) is the variable space; • f : Rn → R is the objective function, while F (·, ξ) : Rn → Rm (for some m ∈ N) is the function describing the constraints of (Pξ ) for any fixed ξ ∈ U For convenience of the description, we denote F(ξ) := {x ∈ X | F (x, ξ) ≤ 0}, i.e., F(ξ) is the feasible set of (Pξ ) The key principle of strict robustness concept is that all decision variables represent here-and-now decisions, i.e., the solution to the uncertain optimization problem must be decided before the actual data becomes known Once the solution is decided, we are sticked with the solution, i.e., nothing changes in the solution when the actual data is realized More precisely, a solution x ∈ X to the uncertain optimization problem (Pξ )ξ∈U is called strictly robust feasible if it is feasible for all scenarios in the uncertainty set, i.e., if x ∈ F(ξ) for all ξ ∈ U The strictly robust counterpart of the uncertain optimization problem is given as (SR) s.t x ∈ SR(U), f (x) in which SR(U) is the set consisting of all strictly robust feasible solutions with respect to the uncertainty set U, i.e., F(ξ) SR(U) = ξ∈U An optimal solution to (SR) is called a strictly robust optimal solution to the uncertain optimization problem (Pξ )ξ∈U The concept adjustable robustness is applied to the contexts in which some decision variables must be set before knowing the actual data (here-and-now variables), while the other decision variables can be adjusted when the actual data is realized (wait-and-see variables) To be precise, the decision vector x can be split as x = (y, z) with y ∈ Y ⊂ Rn1 and z ∈ Z ⊂ Rn−n1 for some n1 ∈ {1, , n − 1}, where the variables y need to be determined before knowing the actual value of ξ ∈ U, while the variables z may be determined after the actual realization of ξ We can rewrite the problem (Pξ ) as follows (Pξ ) f (y, z) s.t F (y, z, ξ) ≤ 0, (y, z) ∈ Y × Z Naturally, when making a decision on here-and-now variables y, one has to make sure that the optimization problem (Pξ ) is feasible once the actual data ξ ∈ U is realized Such a value of a here-and-now decision vector y is called an adjustable robust feasible solution to the uncertain optimization problem (Pξ )ξ∈U The set of the adjustable robust feasible solutions therefore can be given by AR(U) = {y ∈ Y | ∀ξ ∈ U ∃z ∈ Z : (y, z) ∈ F(ξ)} = P rY (F(ξ)), ξ∈U where P rY (F(ξ)) denotes the projection of F(ξ) on Y, i.e., P rY (F(ξ)) := {y ∈ Y | ∃z ∈ Z : (y, z) ∈ F(ξ)} The strategy when using the adjustable robustness concept is: when in doubt, assume the worst Mathematically speaking, given an adjustable robust feasible solution y ∈ AR(U), the worst-case objective value of the uncertain optimization problem over all considered data scenarios is far (y) := sup inf f (y, z) ξ∈U z:(y,z)∈F(ξ) The adjustable robust counterpart of (Pξ )ξ∈U is then defined by (AR) far (y) s.t y ∈ AR(U) An optimal solution to (AR) is called an adjustable robust optimal solution to the uncertain optimization problem (Pξ )ξ∈U 10 By this construction, the new stacking configuration satisfies the given stacking constraints Furthermore, ya has the same number of used stacks as yxmax Thus, ya is a feasible stacking configuration in F(x, a) The optimal stacking configuration of I -items in the setting of scenario a therefore does not use more stacks than ya That means fSt (x, y) ≤ fSt (x, ya ) = fSt (x, yamax ) y∈F(x,a) ∀a ∈ UI Since amax ∈ UI , it follows that max fSt (x, y) = fSt (x, yxmax ) a∈UI y∈F(x,a) The following example illustrates the construction of ya based on yamax Example 3.2 Consider a storage area with m = stacks of height b = 3, and n = items I f = {1, 2}, I = {3}, I = {4, 5, 6} We assume a1 = 110, a2 = 95, a3 = 100, the -intervals for items i = 4, 5, are [80, 100], [78, 94], [81, 93] In scenario amax , the -values of the = 93 For this scenario, a = 94, amax = 100, amax I -items are amax feasible stacking solution is given in Figure 3.1a Figure 3.1b presents a stacking solution for scenario a where the -values of the I -items are a4 = 95, a5 = 90, a6 = 91 The locations of the items in I f ∪ I are the same in both solutions Furthermore, both solutions have item in the first stack and items 5, in the second stack However, in the second solution, the positions of the I -items are changed in comparison with the former solution to adapt the order of these items in the setting of scenario a 23 100 93 95 90 100 94 100 91 110 95 110 95 a) b) Figure 3.1: Two stacking solutions for Example 3.2 Thanks to Lemma 3.1, we have max fSt (x, y) = fSt (x, yxmax ) x∈Ff ea a∈UI y∈F(x,a) x∈Ff ea (3.17) The left hand side of (3.17) is the optimal objective value of (arPI ) The right hand side of (3.17) can be computed by finding an optimal stacking solution of all items in the setting of scenario amax Such a solution can be found in the similar way as finding strictly robust stacking solution More precisely, we compute the stacking matrix max The explicit formula of the (smax ij ) in the context of scenario a matrix is as follows   if i, j ∈ I f and i is stacked on top of j,     f   if i ∈ I , j ∈ I ∪ I , and ≤ aj , smax = ≤ aj , if i ∈ I , j ∈ I f ∪ I , and amax ij i    , if i, j ∈ I and amax ≤ amax  j i    otherwise Then, replacing the stacking matrix (sij ) in formulation (Bin − P ) by the stacking matrix (smax ij ), we obtain an IP formulation for (arPI ) as follows (Bin − arPI ) zq (3.18) q∈Q s.t ∀(i, q) ∈ Fbin xiq = 24 (3.19) xiq ≤ bzq ∀q ∈ Q (3.20) xiq = ∀i ∈ I (3.21) xjq ≤ b(1 − xiq ) ∀(i, q) ∈ (I ∪ I ) × (Q\Q ) i∈I q∈Q j∈I ∪I \{i} max smax ij =sji =0 (3.22) xjq ≤ (b − bq )(1 − xiq ) top ∪ (I ∪ I ) × Q ∀(i, q) ∈ Fbin j∈I ∪I \{i} max smax ij =sji =0 xiq ∈ {0, 1} zq ∈ {0, 1} ∀i ∈ I, q ∈ Q ∀q ∈ Q 25 (3.23) (3.24) (3.25) Chapter Numerical experiments In this chapter, we first present how we implement and test the IP formulations introduced in Chapter Then we present numerical results obtained by testing the formulations on some tested instances 4.1 ZIMPL codes We use mathematical modeling language ZIMPL [3] to implement the introduced IP formulations The data of each tested instance are saved in a separated file In Code we give an example of such the data file Code 1: An example of data file 10 11 12 13 # m = number of stacks 10 # b = common height of stacks # n = number of items 10 # Name and the status of occurance of each item # (0 stands for I ^{ fix } , # stands for I ^1 , # stands for I ^2) 001 002 003 26 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 004 005 006 007 008 009 010 # Positions of items in I ^{ fix } # ( in the format ( item , stack , level ) ) 001 1 002 003 # RANGE OF DATA VALUE OF ITEMS # Item - ActualData / LowerBound - UpperBound 001 80 002 23 003 26 004 005 15 006 87 007 79 008 62 82 009 64 79 010 16 72 In the data file presented in Code 1, the lines started with symbol # are the comments lines The first three numbers in the file are the number of stacks, the number of levels per stack, and the number of items, respectively Then, each line from line 11 to line 20 describes an item and the set it belongs to For example, line 13 means that item 003 belongs to I f Each line from line 23 to line 25 tells us the position of each I f -item For instance, line 24 tells us that item 002 is already at level of stack The lines from line 28 to line 37 give the associated data of the items For example, line 32 means that item 005 has the associated data = 15 Line 37 means that item 010 has the associated data ranging from 16 to 72 In the following we respectively give the ZIMPL codes for the formulations introduced in Chapter Code 2: ZIMPL code for IP formulation (Bin − srPI ) 27 # This ZIMPL model file corresponds to # the formulation ( Bin - srP_I ) # GET DATA FROM INPUT FILES # Number of stacks param m := read file as "1 n " use comment " # "; 10 # Set of stacks s e t Q := {1 m }; 11 12 13 # Common height of stacks param b := read file as "1 n " skip use comment " # "; 14 15 16 # Set of levels s e t L := {1 b }; 17 18 19 # Number of items param n := read file as "1 n " skip use comment " # "; 20 21 22 # Sets of items together with their status of occurance s e t ItemsAndOccurance := { read file as " " skip use n comment " # "}; 23 24 25 26 27 28 # Sets of items s e t I := proj ( ItemsAndOccurance , ) ; s e t If := { in I with in ItemsAndOccurance }; s e t I1 := { in I with in ItemsAndOccurance }; s e t I2 := { in I with in ItemsAndOccurance }; 29 30 31 # Set of pairs of items satisfying stacking sequence s e t StackingSequence := I * If + I1 * I1 + I2 * I1 + I2 * I2 ; 32 33 34 35 36 37 # Infomation about items in I ^{ fix } # a Triples ( I ^{ fix } - item , stack , level ) tells the position of each I ^{ fix } - item s e t IfixWithPosition := { read file as " " skip 3+ n use card ( If ) comment " # "}; # b Pairs ( I ^{ fix } - item , stack ) tells which I ^{ fix } - item is contained in which stack s e t IfixInStack := proj ( IfixWithPosition , ) ; 28 38 39 40 41 42 43 44 45 46 # c Recognize I ^{ fix } - items in the ground level s e t IfixBottomInStack := { in If * Q with in IfixWithPosition }; # d Recognize stacks containing I ^{ fix } - item s e t StacksContainIfix := proj ( IfixBottomInStack , ) ; # e Number of I ^{ fix } - items in each stack param Level [ IfixInStack ] := read file as " n " skip 3+ n use card ( If ) comment " # "; param NumberOfIfixItemsInStack [ in StacksContainIfix ] := max in IfixInStack with q1 == q : Level [ i1 , q1 ]; # f Find the topmost I ^{ fix } - item in each stack s e t IfixTopInStack := { in IfixInStack with Level [i , q ] == NumberOfIfixItemsInStack [ q ]}; 47 48 49 50 51 52 53 54 55 56 57 58 59 60 # Get data about strict hard stacking matrix # a Read the associated values of items param aDataHaN [ If + I1 ] := read file as " n " skip 3+ n + card ( If ) use card ( If ) + card ( I1 ) comment " # "; param aDataWaSmin [ I2 ] := read file as " n " skip 3+ n + card ( If ) + card ( If ) + card ( I1 ) use card ( I2 ) comment " # "; param aDataWaSmax [ I2 ] := read file as " n " skip 3+ n + card ( If ) + card ( If ) + card ( I1 ) use card ( I2 ) comment " # "; # b Compute strict hard stacking matrix s e t IndicesEqualToOneA := { in If * If with aDataHaN [ i ]