Just-in-Time Batch Scheduling Problem with Two-dimensional Bin Packing Constraints

TL;DR

This paper addresses a complex scheduling and packing problem involving rectangular items and bins, proposing heuristics to minimize earliness and tardiness penalties, with CP excelling on small instances and AB on larger ones.

Contribution

It introduces a novel multi-component problem combining bin packing and scheduling, and develops two heuristics, CP and AB, to approximate solutions.

Findings

CP outperforms AB on small instances

AB performs better on larger instances

Heuristics effectively minimize earliness and tardiness penalties

Abstract

This paper introduces and approximately solves a multi-component problem where small rectangular items are produced from large rectangular bins via guillotine cuts. An item is characterized by its width, height, due date, and earliness and tardiness penalties per unit time. Each item induces a cost that is proportional to its earliness and tardiness. Items cut from the same bin form a batch, whose processing and completion times depend on its assigned items. The items of a batch have the completion time of their bin. The objective is to find a cutting plan that minimizes the weighted sum of earliness and tardiness penalties. We address this problem via a constraint programming based heuristic (CP) and an agent based modelling heuristic (AB). CP is an impact-based search strategy, implemented in the general-purpose solver IBM CP Optimizer. AB is constructive. It builds a solution through repeated negotiations between the set of agents representing the items and the set representing the bins. The agents cooperate to minimize the weighted earliness-tardiness penalties. The computational investigation shows that CP outperforms AB on small-sized instances while the opposite prevails for larger instances.

Figures

Tables

Table 1. Table 1: Generation of the widths and heights of items

Density	Class	$\overline{W}=\overline{H}$	$(w_i,h_i))$
$ℒ$	1	10	uniform$[1,10]$
$𝒮$	2	30	uniform$[1,10]$
$ℒ$	3	40	uniform$[1,35]$
$𝒮$	4	100	uniform$[1,35]$
$ℒ$	5	100	uniform$[1,100]$
$𝒮$	6	300	uniform$[1,100]$
$ℒ$	7	100	type 1 with probability 70%; type 2, 3, 4 with probability 10% each
$ℒ$	8	100	type 2 with probability 70%; type 1, 3, 4 with probability 10% each
$ℒ$	9	100	type 3 with probability 70%; type 1, 2, 4 with probability 10% each
$𝒮$	10	100	type 4 with probability 70%; type 1, 2, 3 with probability 10% each

Equations

$$D\left(r_j\right)=\left\{0,\dots ,n\right\},j\in R$$

$$r_j\ne j-n,j\in \left\{n+1,\dots ,2n\right\}$$

$$r_j\ne j-2n,j\in \left\{2n+1,\dots ,3n\right\}$$

$$r_j\ne 0,j\in \left\{1,\dots ,l{b}_{fs}\right\}$$

$$D\left(e_i\right)=\left\{1,\dots ,3n\right\},i\in N$$

$$\left(e_i\ne n+i\right)\wedge \left(e_i\ne 2n+i\right),i\in N$$

$$D\left(W_j\right)=\overline{W},D\left(H_j\right)=\overline{H},j\in \left\{1,\dots ,n\right\}$$

$$D\left(W_j\right)=\left\{w_{j-n},\dots ,\overline{W}\right\},D\left(H_j\right)=\left\{0,\dots ,\overline{H}-h_{j-n}\right\},$$

$$j\in \left\{n+1,\dots ,2n\right\}$$

$$D\left(W_j\right)=\left\{0,\dots ,\overline{W}-w_{j-2n}\right\},D\left(H_j\right)=\left\{h_{j-2n},\dots ,\overline{H}\right\},$$

$$j\in \left\{2n+1,\dots ,3n\right\}$$

$$D\left(x_j\right)=0,D\left(y_j\right)=0,j\in \left\{1,\dots ,n\right\}$$

$$D\left(x_j\right)=\left\{0,\dots ,\overline{W}-w_{j-n}\right\},D\left(y_j\right)=\left\{h_{j-n},\dots ,\overline{H}\right\},$$

$$j\in \left\{n+1,\dots ,2n\right\}$$

$$D\left(x_j\right)=\left\{w_{j-2n},\dots ,W\right\},D\left(x_j\right)=\left\{0,\dots ,\overline{H}-h_{j-2n}\right\},$$

$$j\in \left\{2n+1,\dots ,3n\right\}$$

$$D\left(s_j\right)=\left\{1,\dots ,n\right\},j\in \left\{1,\dots ,3n\right\}$$

$$s_j=j,j\in \left\{1,\dots ,n\right\}$$

$$D\left(v_i\right)=\left\{0,1\right\},i\in N$$

$$D\left(t_k\right)=\left\{0,\dots ,t_{max}\right\},k\in B$$

$$D\left(c_k\right)=\left\{0,\dots ,c_{max}\right\},k\in B$$

$${\sum }_{i\in N}{\sum }_{k\in B}\text{Equals}\left(\text{Element}\left(s,e_i\right),k\right)\cdot$$

$$\left({ϵ}_i\cdot \max \left\{0,d_i-c_k\right\}+{\tau }_i\cdot \max \left\{0,c_k-d_i\right\}\right)$$

$$\text{Element}\left(r,e_i\right)=i$$

$$\text{AllDifferent}\left[e_1,\dots ,e_n\right]$$

$$\text{Count}\left(r,i\right)=1$$

$$w_i\le \text{Element}\left(W,e_i\right)$$

$$h_i\le \text{Element}\left(H,e_i\right)$$

$$W_{n+i}\le \text{Element}\left(W,e_i\right)\cdot \left(1-v_i\right)+w_i{v}_i$$

$$H_{n+i}\le \text{Element}\left(H,e_i\right)-h_i$$

$$W_{2n+i}\le \text{Element}\left(W,e_i\right)-w_i$$

$$H_{2n+i}\le h_i\left(1-v_i\right)+\text{Element}\left(H,e_i\right)\cdot v_i$$

$$x_{n+i}=\text{Element}\left(x,e_i\right)$$

$$y_{n+i}=\text{Element}\left(y,e_i\right)+h_i$$

$$x_{2n+i}=\text{Element}\left(x,e_i\right)+w_i$$

$$y_{2n+i}=\text{Element}\left(y,e_i\right)$$

$$s_{n+i}=\text{Element}\left(s,e_i\right)$$

$$s_{2n+i}=\text{Element}\left(s,e_i\right)$$

$$\text{Equals}\left(r_k,0\right)\to {\sum }_{l=k+1}^n{r}_l=0$$

$$k\in B$$

$$c_k\le c_{k+1}-p_{k+1}$$

$$c_1\ge p_1$$

$${\sum }_{i\in N}\left({ϵ}_i{E}_i+{\tau }_i{T}_i\right)$$

$$T_i-E_i=c_k-d_i$$

$$T_i,E_i\in {\mathbb{R}}_{\ge 0}$$

$$c_k\in {\mathbb{R}}_{\ge 0}$$

$${\varphi }_i^k=\{\begin{array}{ll}{\sum }_{i^{\prime }\in N}\exp \left(-\frac{{|d_i-d_{i^{\prime }}|}^2}{(.5r{)}^2}\right),& \text{mbox}ifk=1\\ {\varphi }_i^{k-1}-{\varphi }_{i_{k-1}^{\ast }}^{k-1}\exp \left(-\frac{{|d_i-d_{i_{k-1}^{\ast }}|}^2}{(.5r{)}^2}\right),& \text{mbox}ifk>1\end{array}$$

Full text

1 Introduction

Multi-component problems are increasingly suscitating the interest of Evolutionary Computation (EC) and Operations Research (OR) communities [12, 4]. Not only do they combine several combinatorial optimisation aspects into a single problem but they also emanate from the compounded complexity of conflicting issues in areas like logistics and supply chain management. Solving them requires a thorough understanding of both their compounded and their individual natures. In practice, solving a multi-component problem is harder than separately tackling its components.

This paper focuses on a relevant multi-component problem occurring in make-to-order industries that adopt a pull production strategy. A production station requests some parts from preceding stages, and specifies when it needs each part. The preceding stages react by producing the parts on time in order to avoid handling, transfer, and temporary storage when parts are completed early and starving of subsequent stations and delays when parts are finished tardy. Synchronizing the production requires that every stage complete its workload on time.

The problem we consider involves the cutting of raw material at one of its production stages. It occurs in furniture, wood, and plastic industries. The cutting stage produces a set $N=\left\{1,\ldots,n\right\}$ of $n$ small rectangular items from a set $B=\left\{1,\ldots,m\right\}$ of large identical rectangular sheets of raw material, referred to hereafter as bins. It uses a single guillotine cutting machine whose cuts are parallel to the edges of the sheets. That is, every item is obtained by a series of edge to edge parallel straight cuts. Item $i\in N$ is characterized by its width $w_{i},$ height $h_{i},$ due date $d_{i},$ which defines when $i$ should be ideally produced, a per time unit earliness cost $\epsilon_{i},$ and a per unit tardiness cost $\tau_{i}.$ Depending on the items’ dimensions, it is possible to cut more than one item from a bin. A bin $k\!\in\!B$ is characterized by its width $\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu$ and height $\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu$. The number of bins $m\!\leq\!n.$ That is, at worst, each item is packed in a single bin. A subset $N_{k}\subseteq N$ of items assigned to a bin $k\in B$ can not overlap and should be completely contained in the bin. The subset forms a batch whose processing time is a function $f\left(N_{k}\right)$ of $N_{k}$ and whose completion time is $c_{k}.$ The completion time $c_{i}$ of item $i\in N_{k}$ equals $c_{k}.$ When produced earlier than $d_{i}$, item $i$ generates earliness $E_{i}=\max\left\{0,d_{i}-c_{i}\right\}$ yielding an earliness penalty $\epsilon_{i}E_{i}.$ On the other hand, it has a tardiness $T_{i}=\max\left\{0,c_{i}-d_{i}\right\}$ and a tardiness cost $\tau_{i}T_{i}$ when produced later than $d_{i}.$ This problem, denoted JIT with BP, searches for (i) a feasible guillotine packing of $N$ into bins of $B$, and (ii) its bin cutting schedule that minimizes the total weighted earliness-tardiness $\textstyle\sum_{i\in N}\left(\epsilon_{i}E_{i}+\tau_{i}T_{i}\right)$.

Applications combining bin packing and scheduling range from steel manufacturing [17, 1] to ship lock scheduling [19] to wood cutting [13]. However, to the best of our knowledge, no research deals with JIT with BP introduced in this paper. The problem is motivated by the specificity of make-to-order industries, which are characterised by low-volume high-mix orders with fixed due dates [2]. To be flexible, such industries don’t produce large batches of identical items. Their production plans are a function of the demands’ due dates and the items’ earliness and tardiness penalties.

JIT with BP is very challenging. It combines/extends two $\mathcal{NP}$-hard combinatorial optimization problems. Its first component is a two-dimensional packing problem that has been extensively addressed via a panoply of techniques varying from OR to Artificial Intelligence (AI) to EC  [9, 5, 15, 18]. Its second component is a just in time single machine batch scheduling problem [7] that has been tackled via different EC approaches with the most prominent ones enumerated in [11]. It incorporates non-overlap, containment, assignment, disjunctive, and sequencing constraints whose simultaneous satisfaction is difficult. In addition, its search space, as for most packing related problems, contains a large number of infeasible and of symmetrical solutions. Optimizing JIT with BP is further complicated by the non-traditional interdependence of its two components. Relaxing the packing density (by assigning a single item per bin) does not reduce earliness-tardiness penalties while a dense production plan that cuts multiple items from a bin gives not only a tighter packing, but also smaller cutting times. In fact, a faster production of the items supports the minimization of the earliness-tardiness. In summary, determining the optimal number of bins is not trivial.

We address JIT with BP via two approximate approaches: CPH and ABH. CPH is a constraint programming (CP) search that explores constraint propagation. CP generates feasible solutions efficiently thanks to its flexible modelling framework, which exploits the structure of a model to direct and accelerate the search. Here, CPH adopts the impact-based search strategy, implemented in the general-purpose solver IBM CP Optimizer [16].

ABH, on the other hand, is a hybrid constructive heuristic that searches the solution space via agent based modelling, identifies a feasible packing via CP techniques and optimally schedules the bins via linear programming. It builds a solution through repeated negotiations between the set of agents representing the items and the set representing the bins. The agents cooperate to minimize the weighted earliness-tardiness penalties. The choice of an agent-based modelling technique is motivated by (i) its success in application to bin packing [15] and just-in-time scheduling [14] problems, (ii) the numerous infeasible and symmetric solutions encountered during the search, and (iii) the reported computational results, which confirm its efficiency in comparison to several enumerative techniques.

Sections 2 and 3 detail CPH and ABH. Section 4 discusses the results. Section 5 is a summary.

2 Constraint Programming Search

Because CP search techniques are prominent for bin packing and scheduling problems, we formulate JIT with BP as a CP model that combines both components and that we approximately solve with a general-purpose commercial solver. In CP, a problem is defined via a set of variables $\mathcal{X}$ and a set of constraints $\mathcal{C}$ given on $\mathcal{X}$ [3, 8]. A variable $x_{i}\!\in\!\mathcal{X}$ can assume any value of its domain $D(x_{i})$. To find an optimum, CP enumerates solutions subject to the constraint store $\mathcal{C}$ using a search tree where every variable $x_{i}\in\mathcal{X}$ is examined within some node. When $x_{i}$ is instantiated, the search inspects those constraints that share $x_{i}$.

In CP, each constraint is viewed as a special-purpose procedure that operates on a solution space. In fact, each procedure is a filtering algorithm that excludes, from the domains of the variables, those values that lead to infeasible solutions. CP relies on constraint propagation. Fixing the value of $x_{i}$ may eliminate some values from the domains of other variables that are connected to $x_{i}$ via one or more constraints of $\mathcal{C}$. That is, constraints sharing some common variables are linked to each other. Subsequently, the results of one filtering procedure are propagated to the others. CP calls the filtering algorithms repeatedly in order to achieve a certain level of consistency. When it yields at some stage $D(x_{i})\!=\!\emptyset$, the filtering signals an infeasible solution (i.e., an inconsistent set of constraints). When $\left|D(x_{i})\right|\!>\!1$, CP branches on $x_{i}$ by partitioning $D(x_{i})$ into unique values, each corresponding to a branch. As the search descends into the tree, constraint propagation reduces the size of the domains of the variables. CP obtains a feasible solution when $|D(x_{i})|=1$ for all $x_{i}$. When emphasis is on optimality, the search continues until either the optimum is found, or the exploration of the whole search tree is unsuccessful.

The performance of a CP model depends on its solver; specifically, on the filtering algorithms and on the search strategies it applies. Here, we resort to IBM ILOG CP Optimizer 12.6.2 with its searching algorithm set to the restart mode. This mode adopts a general purpose search strategy  [16] inspired from integer programming techniques and based on the concept of the impact of a variable. The impact measures the importance of a variable in reducing the search space. The impacts, which are learned from the observation of the domains’ reduction during the search, help the restart mode dramatically improve the performance of the search.

2.1 Decision Variables

The CP model for JIT with BP explores the features of the problem. First, any item $i\!\in\!N$ can be obtained from a bin (or from any region of a bin) via a sequence of horizontal and vertical cuts, as Figure 1 illustrates. When the first applied cut is horizontal, as depicted in Figure 1.a, the bin $\textstyle\left(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right)$ is split into two regions: $R_{i}^{t}$ of size $\left(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\!-\!h_{i}\right)$ at the top of $i,$ and $R_{i}^{r}$ of size $\left(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\!-\!w_{i},h_{i}\right)$ at the right of $i$. Hereafter, we refer to this case as a cutting pattern $a$. When the first cut is vertical, as shown in Figure 1.b, the cutting of the bin produces two regions: $R_{i}^{t}$ of size $\left(w_{i},\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\!-\!h_{i}\right)$ at the top of $i$ and $R_{i}^{r}$ of size $\left(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\!-\!w_{i},\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right)$ at the right of $i$. Herein, we designate this pattern as $b$. Therefore, the extraction of any item always generates two regions: one to the top and one to the right of the item. Clearly, some of the regions may get a zero area if $\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu=w_{i}$ or $\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu=h_{i}.$

Suppose that the number of bins $m\!=\!n.$ The set $R$ of possible regions where the $n$ items may be positioned has $3n$ regions: the first $n$ regions emanate from the $n$ initial empty bins, the second $n$ regions correspond to $R_{1}^{t},\ldots,R_{n}^{t}$, and the last $n$ regions to $R_{1}^{r},\ldots,R_{n}^{r}$. In fact, the last $2n$ regions result from extracting the $n$ items. Thus, $R=\{R_{1},\ldots,R_{n},R_{1}^{t},\ldots,R_{n}^{t},R_{1}^{r},\ldots,R_{n}^{r}\}$, where $R_{1}=\ldots=R_{n}=\left(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right)$. Evidently, this assumes that at most one item can be assigned to a region.

Let $r=\left(r_{1},\ldots,r_{3n}\right)$ be an integer-valued vector variable whose $j$th entry $r_{j},\ j=1,\ldots,3n,$ is the item packed in the $j$th region; i.e., $r_{j}=i$ if region $j$ contains item $i$ and 0 if $j$ contains no item. Its domain is therefore

[TABLE]

When $j\in\left\{1,\ldots,n\right\}$, item $r_{j}$ is the first item in bin $j.$ When $j\in\left\{n+1,\ldots,2n\right\},\ r_{j}$ is placed into $R_{j-n}^{t}$ on top of item $j-n.\ r_{j}\neq\left(j-n\right)$ since $R_{j-n}^{t}$ is the result of cutting off item $\left(j-n\right).$ Thus, the domain $D(r_{j})$ excludes $j-n:$

[TABLE]

Finally, when $j\in\left\{2n+1,\ldots,3n\right\},\ r_{j}$ is placed in $R_{j-2n}^{r};$ that is, at the right of item $\left(j-2n\right)$ and $D(r_{j})$ is free of element $j-2n:$

[TABLE]

We compute $lb_{f\!s},$ the lower bound of Fekete and Schepers [6] on the number of bins required to cut the $n$ items. We force the first $lb_{f\!s}$ regions to have exactly one item. Therefore the domain $D(r_{j})$ of $r_{j},\ j=1,\ldots,lb_{fs},$ excludes $\{0\}$:

[TABLE]

This rule partially excludes symmetrical solutions arising when a filled bin $k$ empties all its items into an empty bin $k^{\prime}$ that precedes or succeeds bin $k$ on the cutting machine. This exchange of items produces a different solution but the same objective function value. An empty bin has a zero processing time.

Similarly, let $e\!=\!\left(e_{1},\ldots,e_{n}\right)$ be an integer-valued vector of variables reflecting the assignment of regions to items such that $e_{i}\!=\!j$ if item $i$ is positioned in region $j$. When $e_{i}\!\in\!\left\{1,\ldots,n\right\},\ i$ is the first packed item into its bin. On the other hand, when $e_{i}\!\in\!\left\{n+1,\ldots,2n\right\}$ or $e_{i}\in\left\{2n+1,\ldots,3n\right\},\ i$ is located in region $R_{e_{i}-n}^{t}$ at the top of item $\left(e_{i}-n\right)$ or in region $R_{e_{i}-2n}^{r}$ at the top of item $e_{i}-2n$, respectively. The domain of variable $e_{i}$ is

[TABLE]

Because item $i$ can not be packed into $R_{n+i}$ and $R_{2n+i}$, which are respectively $R_{i}^{t}$ and $R_{i}^{r}$, the following holds

[TABLE]

Along with the aforementioned variables and constraints, the CP model uses an additional five sets of variables.

The first set has two integer-valued vectors $W\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{3n}$ and $H\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{3n}$ representing the widths and heights of the regions, where $\left(W_{j},H_{j}\right),\ j\!=\!1,\ldots,3n,$ is the size of $R_{j}\!\in\!R$. Because $R_{i}\!=\!(\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu),\ R_{n+i}\!=\!R_{i}^{t},$ and $R_{2n+i}\!=\!R_{i}^{r},$ for $i\!=\!1,\ldots,n,$

[TABLE]

The second set has $x\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{3n}$ and $y\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{3n},$ two integer-valued vectors representing the bottom-left corner coordinates of the regions, where $\left(x_{j},y_{j}\right),\ j=1,\ldots,3n,$ refers to the coordinates of $R_{j}\!\in\!R$. These variables abide to the conditions:

[TABLE]

The third set has an integer-valued vector $s\!\in\!\left\{1,\ldots,n\right\}^{3n}$ where $s_{j}\!=\!k$ when region $R_{j}\!\in\!R$ belongs to bin $k\!\in\!B$. The first $n$ regions correspond to the empty bins:

[TABLE]

The fourth set has $v\!\in\!\left\{0,1\right\}^{n}$ a binary vector defining the cutting pattern used to extract the item: $v_{i}=0$ if the first cut that yields item $i$ is horizontal (cf. Figure 1.a), and 1 otherwise. Thus,

[TABLE]

The fifth set has $t\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{n}$ and $c\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{n},$ two integer-valued vectors that define the processing times and the completion times of the bins. Let $t_{max}$ and $c_{max}$ be upper bounds on the maximal processing and completion time of a bin, respectively. Then

[TABLE]

2.2 CP Model

The CP model uses constraint ${\texttt{AllDifferent}}\!\left[g_{1},\ldots,g_{n}\right],$ which ensures that the variables of $\left[g_{1},\ldots,g_{n}\right]$ take distinct values. Additionally, the model uses three expressions: ${\texttt{Equals}}\!\left(g,h\right),$ which returns $1$ or $true$ if $g=h$ and [math] or $false$ otherwise; ${\texttt{Element}}\!\left(g,h\right),$ which returns the $h$th variable in the list of variables $g$; and ${\texttt{Count}}\!\left(g,h\right),$ which counts the number of variables of $g$ taking the value $h$. The CP model follows.

[TABLE]

Expression (18) calculates the objective value as the weighted sum of earliness-tardiness penalties. Because $e_{i}$ is the region to which item $i$ is assigned, ${\texttt{Element}}\!\left(s,e_{i}\right)$ in Eq. (18) gives the index of the bin where $i$ is packed. When ${\texttt{Equals}}\!\left({{\texttt{Element}}\!\left(s,e_{i}\right)},k\right)$ confirms that $i$ is assigned to bin $k,$ the expression computes the weighted earliness tardiness of $i$ based on $c_{k}$. Constraint (19) establishes a dual notation by forcing region $r_{e_{i}}$ to contain item $i$ when $i$ is assigned to $e_{i}$. Constraint (20) verifies that all the items are assigned to different regions. Constraint (21) ensures that exactly one region contains item $i$. Constraints (22) and (23) guarantee that $e_{i},$ which holds item $i,$ is large enough to fit $i$. Constraints (24) and (25) bound the size of the top residual area $R_{i}^{t}$ obtained when cutting item $i$. When the first cut generating $i$ is horizontal (i.e., $v_{i}\!=\!0$), Eq. (24) limits the width of $R_{i}^{t}$ to the width of region $e_{i}$ where $i$ is positioned. On the other hand, when the first cut generating $i$ is vertical (i.e., $v_{i}\!=\!1$), Eq. (24) limits the width of $R_{i}^{t}$ to the width $w_{i}$. Constraint (25) bounds the height of $R_{i}^{t}$ by the difference between the height of $e_{i}$ and $h_{i}$. Indeed, it does not depend on the cutting pattern. Similarly, constraints (26) and (27) bound the size of $R_{i}^{r}$ with Constraint (26) delimiting the width of $R_{i}^{r}$ by the difference between the width of $e_{i}$ and $w_{i}$ and Constraint (27) limiting the height of $R_{i}^{r}$ to $h_{i}$ when $i$ is extracted with respect to pattern $a$ (i.e., $v_{i}=0$) and to the height of $e_{i}$ when $i$ is positioned and cut according to pattern $b$. Constraint (28) sets the $x$-coordinate of region $R_{i}^{t}$ to $e_{i}$’s $x$-coordinate. Constraint (29) computes the $y$-coordinate of region $R_{i}^{t}$ as the sum of the $y$-coordinate of region $e_{i}$ and $h_{i}$. Constraint (30) computes the $x$-coordinate of region $R_{i}^{r}$ as the sum of the $x$-coordinate of region $e_{i}$ and $x_{i}$. Constraint (31) sets the $y$-coordinate of region $R_{i}^{r}$ to the $y$-coordinate of region $e_{i}$. Constraints (32) and (33) define, respectively, the bin to which regions $R_{i}^{t}$ and $R_{i}^{r}$ belong. Constraint (34) implies that no bin succeeding bin $k$ can hold a region if $k$ is empty. This is a symmetry breaking constraint that prohibits filling a bin $\left(k\!+\!1\right)$ if bin $k$ is not filled. Constraint (35) calculates the processing time of bin $k$. Constraint (36) guarantees the no overlap of the processing windows of two consecutive bins. Finally, constraint (37) ensures that the schedule starts after time zero. This CP model solves JIT with BP exactly even with the restart mode. However, CPH uses it to find an approximate solution as it presets its runtime.

Within the search, items are assigned to regions in the ascending order of their due dates. The solver instantiates $e_{1},\ldots,e_{n};$ then applies its default strategy to the other variables. Our extensive study shows that such an order gives the best results fast.

3 Agent-Based Heuristic

ABH is a constructive heuristic that packs items into bins through negotiation, and schedules the packed bins optimally using a linear program. It uses a packing procedure PACK that searches for a feasible guillotine packing of a set of items into a single bin via a reduced version of CPH. Because it solves a feasibility problem, PACK omits Eq. (18) and drops the $s$, $t$ and $c$ variables along with their related constraints, i.e. Eqs. (13-14,16-17,32-37). PACK is solved via IBM ILOG’s CP Optimizer, which is allocated a preset threshold runtime. It either returns a feasible packing or signals the infeasibility of the grouping of the items in a bin.

Suppose that $m$ is fixed and that an integer-valued vector $x\!\in\!\left\{\mathbb{N}_{\geq 0}\right\}^{n}$ represents an assignment of items to bins such that $x_{i}=k$ if item $i\!\in\!N_{k}$. For a given $x,$ the processing time of bin $k\!\in\!B$ is known. Thus, the completion times that minimize the weighted earliness tardiness of the items is the optimal solution to the linear program ${\texttt{WET}}\!\left(N\right)$ whose decision variables are: $c_{k}\geq 0,\ T_{i}\geq 0$ and $E_{i}\geq 0$ for $k\!\in\!B$ and $i\!\in\!N$. ${\texttt{WET}}\!\left(N\right)$ follows.

[TABLE]

${\texttt{WET}}\!\left(N\right)$ schedules the bins on the single cutter and inserts idle time between successive bins if this decreases the total weighted earliness tardiness, defined by Eq. (38). Eq. (36) determines the completion time of each bin ensuring that the processing periods of two successive bins do not overlap in time. Eq. (37) guarantees that the schedule starts after time zero. Eq. (39) calculates the tardiness $T_{i}$ and the earliness $E_{i}$ of job $i$ when $i$ is assigned to bin $k$. Finally, Eqs. (40-41) declare the variables positive. ${\texttt{WET}}\!\left(N\right)$ is a linear program that can be solved via IBM ILOG’s CPLEX.

3.1 Initial Partial Solution

ABH starts with constructing a partial solution. First, ABH computes the lower bound $lb_{f\!s}$ of Fekete and Schepers [6] on the number of bins required to pack the $n$ items. Then ABH constructs a partial solution with $m\!=\!lb_{f\!s}$ empty bins.

Second, ABH uses a peak clustering algorithm [20] that identifies items with close due dates. These items constitute a bottleneck on the machine. The idea is that a bin groups a set of items such that its completion time lies at the centre of the due dates of the items. Assigning items causing a bottleneck to the same bin reduces the lateness of the items; in particular when the items’ per unit earliness tardiness penalties are symmetric. The clustering algorithm finds the $k$th cluster by evaluating, for $i\!\in\!N,$ a clustering function

[TABLE]

where $r$ is the parameter that governs the width of the peak function. It then selects $i_{k}^{*},$ the item with the largest peak function value: $\phi_{i_{k}^{*}}^{k}=\max_{i\in N}\{{\phi_{i}^{k}}\}$. It removes $i_{k}^{*}$ from $N$ and places it in a list $\mkern 1.5mu\overline{\mkern-1.5muU\mkern-1.5mu}\mkern 1.5mu$ of highly bottleneck items. It updates the modified peak function and iterates the process until it has removed $m$ bottleneck items. The $n-m$ unpacked items constitute the set $U$.

3.2 Completing a Partial Solution

Let ${\texttt{WET}}\!\left(i^{*},k\right)=$

$\displaystyle\sum_{i\in\mkern 1.5mu\overline{\mkern-1.5muU\mkern-1.5mu}\mkern 1.5mu\cup\left\{i^{*}\right\}}\sum_{k^{\prime}\in B:x_{i}=k^{\prime}}\epsilon_{i}\!\cdot\!\max\left\{0,d_{i}\!-\!c_{k^{\prime}}\right\}\!+\!\tau_{i}\!\cdot\!\max\left\{0,c_{k^{\prime}}\!-\!d_{i}\right\}$

denote the objective value of the current partial solution augmented by $\{i^{*}\}$ were $i^{*}$ to leave $U$ and be packed in $k$. ${\texttt{WET}}\!\left(i^{*},k\right)$ is the value of the optimum of ${\texttt{WET}}\!\left(\mkern 1.5mu\overline{\mkern-1.5muU\mkern-1.5mu}\mkern 1.5mu\!\cup\!\{i^{*}\}\right)$.

The items in $U$ and the filled bins act as individual greedy agents that undertake negotiation actions. A bin $k$ seeks to attract the best item $i^{*}\!\in\!U$, defined as the item which minimises ${\texttt{WET}}\!\left(i^{*},k\right)$. Likewise, item $i\!\in\!U$ seeks the best bin $k^{*}$ where $k^{*}$ minimises ${\texttt{WET}}\!\left(i,k^{*}\right)$ should $i$ leave $U$ and join $k^{*}$. The item-attraction and bin-seeking negotiation actions, named as GroupFormation and GroupJoin respectively, continue until all items are assigned to bins $\left(U\!=\!\emptyset\right)$ or none of the remaining items of $U$ are packable into existing bins. At this point, a repacking procedure is triggered.

Every time a bin’s GroupFormation action completes successfully, ABH runs a local search that obtains an optimised partial solution before ABH undertakes its next assignment decision. Differently stated, the local search downsizes the myopia of the greedy actions of the agents and keeps the partial solution balanced during the construction phase. It employs two operators: insertion, which moves an item from bin $k$ to its neighbouring bin $k\!+\!1$ or vice versa, and swap, which exchanges two items, $i\!\in\!N_{k}$ and $i^{\prime}\!\in\!N_{k+1},$ from two neighbouring bins. A move or exchange is adopted when it improves the current solution and maintains its feasibility. The local search applies the operators sequentially until it obtains a better solution. It operates on neighboring bins only in order to have a short run time. However, it may consider a larger neighbourhood when the earliness and tardiness costs are highly asymmetric.

3.2.1 GroupFormation

The GroupFormation action, detailed in Algorithm 1, considers the items in $U$ in ascending order of their $\textstyle\epsilon_{i}E_{i}+\tau_{i}T_{i},$ where $E_{i}$ and $T_{i}$ are computed with respect to the current $c_{k}$ of bin $k$. Evidently, the current $c_{k}$ is an estimate of the true $c_{k},$ which changes as items of $U$ are assigned to $k$. For each of the first $\rho$ items of $U$, the GroupFormation action of bin $k$ computes, using ${\texttt{WET}}\!\left(N\right)$, the true $c_{k}$ were this item to join $k$. It considers the $\rho$ most prominent items first to reduce its run time.

Next, the GroupFormation action of a bin $k$ chooses the candidate $i^{*}$ which induces the smallest ${\texttt{WET}}\!\left(i^{*},k\right)$ were $i^{*}$ to join $k$. It checks whether $k$ can append $i^{*}$. If the $lb_{f\!s}$ lower bound for $N_{k}\!\cup\!\left\{i^{*}\right\}$, denoted as $lb_{f\!s}\left(N_{k}\!\cup\!\left\{i^{*}\right\}\right),$ is less than or equal to 1, $i^{*}$ may be packed in $k$. Therefore, the GroupFormation action triggers PACK, which searches for a feasible guillotine packing of $i^{*}$ and the items already assigned to $k$. When PACK returns a valid packing, $k$ sends a join request to $i^{*}$, which has independently undertaken its own GroupJoin action. When $i^{*}$ accepts the request, the GroupFormation action assigns $i^{*}$ to $k$, and terminates successfully. PACK may fail to find a further packing $i^{*}$ into $k$ either because it runs out of time or it has exhausted all possible packing possibilities. In this case, the GroupFormation action of $k$ removes $i^{*}$ from the list of candidates items and selects the next item, say $i^{**},$ that minimizes ${\texttt{WET}}\!\left(i^{**},k\right)$ were $i^{**}$ to join $k$. When $k$ fails to append any of the $\rho$ candidate items, it iteratively considers the next item of $U$, compute the true $c_{k}$ were this item to join $k$ and checks the feasibility of packing this item into $k$. If it still fails to append any of the items of $U$, the GroupFormation action terminates unsuccessfully. When all available bins fail their GroupFormation actions while $U\!\neq\!\emptyset,$ the repacking procedure of Section 3.2.3 is applied.

3.2.2 GroupJoin

The bin and item agents act individually and greedily. This can result in low-penalty items being attached to bins whose completion times are far from the items’ due dates. This might also be problematic when the per unit penalties of the items assigned to a bin are highly asymmetric. It can quickly lead to a ripple effect, as these low-penalty items may force items with higher penalties not to be in their most proximal bins due to packing constraints. This, in turn, forces more items to be packed into less proximal bins; yielding a large increase of the penalties and an overall degeneration in solution quality. To avoid such a scenario, an item $i$ declines an attachment offer from bin $k$ if it can be packed into bin $k^{\prime}$ and the overlap of $[d_{i}-p_{i},d_{i}]$ with $[c_{k^{\prime}}-p_{k^{\prime}},c_{k^{\prime}}]$ is larger than the overlap of $[d_{i}-p_{i},d_{i}]$ with $[c_{k}-p_{k},c_{k}],$ where $[d_{i}-p_{i},d_{i}]$ is the ideal processing time of $i$ and $p_{i}$ is the processing time of a bin containing only item $i$.

Each item $i\!\in\!U$ is interested in joining a bin whose processing time window overlaps its own ideal processing window. Let $\mathcal{O}_{i}$ denote the set of such bins. The GroupJoin action sorts the bins of $\mathcal{O}_{i}$ in descending order of the overlap, and chooses the bin $k^{\prime}\!\in\!\mathcal{O}_{i}$ with the largest overlap. If $k^{\prime}$ is the bin that sent $i$ the attachment offer, $i$ accepts the joining request. Otherwise, the GroupJoin action checks whether $i$ can be packed in $k^{\prime}$. If $lb_{f\!s}\left(N_{k^{\prime}}\!\cup\!\left\{i\right\}\right)\!\leq\!1$, it calls PACK. If the packing of $i$ in $k^{\prime}$ is feasible, $i$ declines the invitation of $k$; otherwise, the GroupJoin action considers the next bin of $\mathcal{O}_{i}.$ When the GroupJoin action exhausts all bins of $\mathcal{O}_{i}$ without packing $i$, it proceeds to the following alternative plan. For each bin $k^{\prime}\!\in\!B\!\setminus\!\mathcal{O}_{i},$ it computes the penalty ${\texttt{WET}}\!\left(i,k^{\prime}\right)$ were $i$ to join $k^{\prime}$. It first forms the set of bins $B^{\prime}$ such that $WET(i,k^{\prime})\leq WET(i,k)$ and sorts it in ascending order of $WET(i,k^{\prime}).$ Then, it iteratively scans $B^{\prime}\!\subseteq\!B\!\setminus\!\mathcal{O}_{i}$. If $k\!=\!k^{\prime}$, $k^{\prime}\!\in\!B^{\prime}$, $i$ accepts the invitation of $k$ and the GroupJoin action ends successfully. Otherwise, it tests whether $i$ is packable in $k^{\prime}$ with a lower earliness tardiness penalty. If $lb_{f\!s}\left(N_{k^{\prime}}\!\cup\!\left\{i\right\}\right)\!\leq\!1$ and PACK returns a feasible packing, the GroupJoin action declines the invitation of $k$ whereas the GroupJoin action checks the next bin of $B^{\prime}$ when packing is impossible. The GroupJoin action ends successfully when it checks all the bins of $B^{\prime}$ and does not find a bin proposing a placement yielding smaller earliness-tardiness penalties. Algorithm 2 details the GroupJoin action.

3.2.3 Repacking

When there remain unpacked items (i.e., $U\neq\emptyset$) while the GroupFormation actions of all the bins fail, ABH triggers a repacking procedure. It identifies a bin $k^{*}$ whose completion time $c_{k^{*}}$ is the closest to the due date of the first unpacked item $i\!\in\!U$. It empties bin $k^{*}$ along with bins $(k^{*}-1)$ and $(k^{*}+1)$ (if they exist), and inserts their unpacked items into set $U$. It inserts a new bin immediately following bin $k$, increments the number of bins by one, and resumes the GroupFormation actions.

3.2.4 Caching

ABH reduces its runtime by nearly an order of magnitude by caching results from previous objective function calls and packing feasibility checks. Consider bin $k\in B$ sending a join request to item $i\in U$. ABH doesn’t recompute the total scheduling penalty resulting from $i$ joining $k$ if this penalty was computed previously and the schedule has since been unchanged. Similarly, ABH doesn’t rerun PACK for $N_{k}\cup\left\{i\right\}$ if it was obtained at a prior stage and the content of the bin $k$ has since been unchanged. ABH proceeds similarly for the GroupJoin actions when an item requests to join a bin.

Matrix $\Lambda\!\in\!\left\{-1,0,1\right\}^{m\times n}$ stores packing feasibility check results such that its element $\lambda_{ki},\ k\in B,\ i\in N,$ equals 0 if the packing of $i$ into $k$ is infeasible, equals 1 if it is feasible, and -1 if the result is unknown. Every time an item is added to a bin $k\in B$, all the elements of the row associated with $k$ are changed to the default unknown packing state; i.e., to $-1$.

Penalty computation results are stored in matrix $A\in\mathbb{R}_{\geq-1}^{m\times n}$ whose element $\alpha_{ki},\ k\in B,\ i\in N,$ equals the total penalty generated by attaching $i$ to $k$. Unlike the feasibility checks, every entry of $A$ is reset to the unknown state $-1$ when any bin adds a new item as this addition may alter the total scheduling penalty.

4 Computational Results

CPH and ABH are implemented in C#, with CP models solved via IBM’s ILOG Optimisation Studio’s CP solver version 12.6.2. They are run on a personal computer with 4GB of RAM and a 3.06GHz Dual Core processor. Their performances are compared on instances that are randomly generated as follows:

• $\bullet$

$n=$20, 40, 60, 80, and 100;

• $\bullet$

$\epsilon_{i}$ and $\tau_{i}$ following the uniform$[1,5]$;

• $\bullet$

the processing time function of non-empty bin $k$ is $f\left(N_{k}\right)=t^{l}+t^{h}\cdot\left|N_{k}\right|+t^{c}\cdot\textstyle\sum_{i\in N_{k}}\left(w_{i}\!+\!h_{i}\right)$, where bin loading time $t^{l}=100$, the item’s handling time $t^{h}=30$, and the cutting time $t^{c}=0.02$;

• $\bullet$

items’ due dates distributed according to: a normal with mean $\lambda$ and standard deviation $0.1\lambda,$ or a uniform[0, $2\lambda$] where $\lambda=\frac{t^{l}\sum_{i\in N}h_{i}w_{i}}{2\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu}$; and

• $\bullet$

classes of instance as given in Table 1. They are those of the most known benchmark set for two-dimensional bin packing [10]. Classes 7-10 involve four types of items whose dimensions follow uniform distributions whose ranges are respectively:

• $-$

type 1: $\left(\left[\frac{2}{3}\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\!\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\right]\!,\!\left[1,\!\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right]\right)$;

• $-$

type 2: $\left(\left[1,\!\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\right]\!,\!\left[\frac{2}{3}\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu,\!\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right]\right)$;

• $-$

type 3: $\left(\left[\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu,\!\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\right]\!,\!\left[\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu,\!\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right]\right)$; and

• $-$

type 4: $\left(\left[1,\!\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muW\mkern-1.5mu}\mkern 1.5mu\right]\!,\!\left[1,\!\frac{1}{2}\mkern 1.5mu\overline{\mkern-1.5muH\mkern-1.5mu}\mkern 1.5mu\right]\right)$.

The instances are grouped according to their bin to item size ratios, which reflect the average number of items that can be packed into a bin: A low bin density set $\mathcal{L}$ with relatively large items and a high bin density set $\mathcal{S}$ with small items. As in real life furniture manufacturing, a bin’s processing time accounts for its size and that of its items. For each class, problem size, and type of due date distribution, 10 instances are generated. The resulting 1000 problems, which will serve as benchmark instances for future research111The full set of test instances is available at http://cs.adelaide.edu.au/$\sim$optlog/.

ABH is run with $r\!=\!40$ and $\rho\!=\!3$. Both values are set as a result of extensive experiments. $r$ is not very influential but instance-dependent. Setting $r$ should avoid both very large and very small values. When $r$ is too large, the peak function accounts for too many due dates; consequently, the selection of bottlenecks becomes problematic as the clustering algorithm will tend to detect a single cluster rather than bottlenecks. Similarly, when $r$ is too small, the clustering algorithm identifies too many bottlenecks; consequently, finding the bottleneck with the largest impact is hard. On the other hand, the value of $\rho$ is not critical as it slightly speeds up the GroupFormation computations. ABH allocates a 0.5 s runtime to the constraint program PACK that checks for the feasibility of a packing. All statistical inferences are valid at a 5% significance level.

Figure 2 displays the heat map of the performance ratio $\frac{z_{H}}{z_{best}},\ H\!\in\!\mathcal{H}\!=\!\{$CPH${}_{10},$ CPH${}_{30},$ ABH$\},$ where CPH10 and CPH30 denote CPH when allocated 10 and 30 minutes of runtime respectively, $z_{best}=\min_{H\in\mathcal{H}}\{z_{H}\},$ and a dark blue color signals a better objective function value. It suggests that allocating a longer runtime to CPH enhances its mean performance ratio; in particular when $n>20.$ This enhancement occurs in about 80% of instances. The percent of times CPH10 equals CPH30 decreases as $n$ increases, as illustrated by Figure 3. This is further supported by a paired statistical test and by Figure 4.a-b, which displays the mean performance ratios as a function of size and class. It is unlikely that increasing the runtime of CPH beyond 30 minutes for larger instances will induce further improvements shortly because of the large size of the search space.

ABH outperforms CPH for instances with more than 60 items whereas CPH performs better than ABH when the number of items is 20 or 40. For $n=60$, ABH outperforms CPH for set $\mathcal{L}$ while being outperformed by CPH for set $\mathcal{S}.$ CPH investigates a substantially higher portion of the solution space when the search space is small than when the search space is large. As $n$ increases, CPH struggles to reduce the search space (thus, to converge to low-penalty solutions) whereas ABH reaches such solutions for the larger instances progressively thanks to its general rules of thumb that aim at minimizing the incremental weighted earliness tardiness as ABH assigns items to bins.

Analysis of variance tests further show that the mean performance ratio is not sensitive to the distribution of the due dates but is sensitive to both the class and the problem size. For single machine scheduling, problems with normally distributed due dates are harder to solve; however, for the problem at hand, clusters of items with very close due dates can be scheduled in the same bin. On the other hand, processing items with uniformly distributed due dates in a single batch increases the objective function value, and constitutes an additional difficulty to the problem. This is reflected by slightly lower solution quality of CPH and ABH and slightly larger run times.

A hypothesis test infers that there is not enough statistical evidence to claim that the mean runtime of ABH is larger when the due dates are normally distributed than when they are uniformly generated. A one-way analysis of variance further confirms that the runtime of ABH is not sensitive to the distribution of due dates. That is, processing the items in batches desensitizes ABH to the clustering of the due dates. The mean runtime of ABH is on the other hand dependent on the problem size and class as illustrated by Figure 4.c-d, which shows the main interaction of size, class, and distribution of due dates on the mean runtime of ABH. The maximal mean runtime of 203 s of ABH is far less than the allocated 10 minutes of CPH10.

The larger the bin to item size, the larger the run time of ABH is. This is particularly apparent for larger instances of classes 2, 4, 6 and 10, which all have high bin to item size ratios. As the number of items per bin increases, the number of potential arrangements of items increases too; making it harder to determine whether the packing of a given item set to the bin is feasible. Unfortunately, increasing the threshold of the runtime of the constraint program PACK did not enhance the performance of ABH for those classes of instances. Indeed, the feasibility problem remains too hard to solve when solutions lay “on the edge of feasibility”.

Figure 5, which displays the 95% confidence intervals of the mean runtime (s) of ABH as a function of size for sets $\mathcal{L}$ and $\mathcal{S},$ provides further computational proof that ABH runs faster on the instances with relatively large items.

ABH performs consistently better for instances with low bin to item size ratios than for instances with high ratios. This is most likely due to the “ripple effect”, which arises from low-penalty items forcing items with higher penalties away from their most proximal bins. While the search for ideal processing windows favors the assignment of items to their most proximal bins, the asymmetric nature of the per unit penalties $\epsilon$ and $\tau$ does not guarantee low earliness tardiness to all items assigned to a bin. As filled bins near their full capacity, the greedy GroupJoin and GroupFormation actions may result in locally-optimal scenarios where small, low-penalty items prohibit large, high-penalty items from being packed into their proximal bins; thus, force them into bins that are far away from their due dates. This occurs more often in instances with high bin to item ratios because bins can pack more items (which are not necessarily homogeneous).

5 Conclusions

This paper introduces a very pertinent industrial problem that combines two very hard combinatorial optimization problems: a two-dimensional guillotine bin packing / cutting, and a single machine weighted earliness tardiness batch scheduling. It defines the problem, and models it using two different approaches: one based on constraint programming and one based on agent based modeling where items and bins act as cooperating negotiating agents. The computational results on randomly generated instances that will serve as benchmark sets for future research show that the constraint programming approach is more promising when the problem size is small while the agent based model gives better results for larger instances thanks to the common sense rules that govern the negotiations of the agents.

The first heuristic can be enhanced with additional selection / dominance rules that will prune large parts of the search space while the second can be improved with a neighborhood search. In addition to improving these two heuristics, future research can focus on applying and adapting enumerative approaches, such as genetic algorithms, to the specificities of this problem. In fact, it would be interesting to design/adapt a high-performing evolutionary technique that can cope with the large number of infeasible solutions it would encounter during its search. Moreover, the problem can be extended to more complex manufacturing set ups such as flow shops and job shops, to cutting problems with more complex shapes and constraints as in apparel manufacturing, to three dimensional shapes as in transportation, or to the variable-sized variable-cost bin packing problem.

Acknowledgments

This work has been supported by the ARC Discovery Project DP130104395.