This article was downloaded by: [39.47.30.

251] On: 06 January 2025, At: 05:30

Publisher: Institute for Operations Research and the Management Sciences (INFORMS)
INFORMS is located in Maryland, USA

INFORMS Journal on Computing

Publication details, including instructions for authors and subscription information:
http://pubsonline.informs.org

A Numerically Exact Algorithm for the Bin-Packing

Problem
Roberto Baldacci, Stefano Coniglio, Jean-François Cordeau, Fabio Furini

To cite this article:

Roberto Baldacci, Stefano Coniglio, Jean-François Cordeau, Fabio Furini (2024) A Numerically Exact Algorithm for
the Bin-Packing Problem. INFORMS Journal on Computing 36(1):141-162. https://doi.org/10.1287/ijoc.2022.0257

Full terms and conditions of use: https://pubsonline.informs.org/Publications/Librarians-Portal/PubsOnLine-

Terms-and-Conditions

This article may be used only for the purposes of research, teaching, and/or private study. Commercial use or
systematic downloading (by robots or other automatic processes) is prohibited without explicit Publisher approval,
unless otherwise noted. For more information, contact [email protected].

The Publisher does not warrant or guarantee the article’s accuracy, completeness, merchantability, fitness
for a particular purpose, or non-infringement. Descriptions of, or references to, products or publications, or
inclusion of an advertisement in this article, neither constitutes nor implies a guarantee, endorsement, or support
of claims made of that product, publication, or service.

Copyright © 2023, INFORMS

Please scroll down for article—it is on subsequent pages

With 12,500 members from nearly 90 countries, INFORMS is the largest international association of operations
research (O.R.) and analytics professionals and students. INFORMS provides unique networking and learning
opportunities for individual professionals, and organizations of all types and sizes, to better understand and use
O.R. and analytics tools and methods to transform strategic visions and achieve better outcomes.
For more information on INFORMS, its publications, membership, or meetings visit http://www.informs.org
 INFORMS JOURNAL ON COMPUTING
Vol. 36, No. 1, January–February 2024, pp. 141–162
https://pubsonline.informs.org/journal/ijoc ISSN 1091-9856 (print), ISSN 1526-5528 (online)

A Numerically Exact Algorithm for the Bin-Packing Problem

Roberto Baldacci,a Stefano Coniglio,b,* Jean-François Cordeau,c Fabio Furinid
a
Division of Engineering Management and Decision Sciences, College of Science and Engineering, Hamad Bin Khalifa University, Qatar
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

Foundation, Doha, Qatar; b Department of Economics, University of Bergamo, 24127 Bergamo, Italy; c Chair in Logistics and Transportation,
HEC Montréal, Montreal H3T 2A7, Canada; d Department of Computer, Control, and Management Engineering “Antonio Ruberti”, Sapienza
University of Rome, 00185 Rome, Italy
*Corresponding author
Contact: [email protected], https://orcid.org/0000-0003-0938-5798 (RB); [email protected],
https://orcid.org/0000-0001-9568-4385 (SC); [email protected], https://orcid.org/0000-0002-4963-1298 (J-FC);
[email protected], https://orcid.org/0000-0002-1839-5827 (FF)

Received: August 26, 2022 Abstract. We propose a numerically exact algorithm for solving the Bin-Packing Problem
Revised: February 8, 2023; July 17, 2023 (BPP) based on a branch-price-and-cut framework combined with a pattern-enumeration
Accepted: July 18, 2023 method. Key to the algorithm is a novel technique for the computation of numerically safe
Published Online in Articles in Advance: dual bounds for the widely adopted set covering reformulation of the BPP (tightened with
August 24, 2023 additional valid inequalities) with a precision that is higher than the one of general-
purpose floating-point solvers. Our branch-price-and-cut algorithm also relies on an exact
https://doi.org/10.1287/ijoc.2022.0257 integer (fixed-point) label setting algorithm for solving the pricing problem associated with
the tightened set-covering formulation. To the best of our knowledge, ours is the first algo­
Copyright: © 2023 INFORMS
rithm for the BPP that is numerically exact and practical for solving large-scale instances.
Extensive computational results on instances affected by notorious numerical difficulties
(those of the Augmented Non-IRUP class) show that our exact algorithm outperforms all
of the not numerically exact state-of-the-art algorithms based on branch-and-cut-and-price
techniques that rely on a set-covering formulation of the BPP.

History: Accepted by Andrea Lodi, Area Editor for Design & Analysis of Algorithms � Discrete.

Keywords: bin packing • numerical precision • branch-price-and-cut algorithm • dynamic programming

1. Introduction
Given a set N of n items, a positive integer weight wj associated with each item j ∈ N, and an unlimited number
of identical bins of integer capacity W, the Bin-Packing Problem (BPP) asks for finding the minimum number of
bins that are needed to pack all of the items. The BPP is one of the fundamental problems in combinatorial opti­
mization and operations research, and although it has been studied extensively for decades, it is still very chal­
lenging to solve to optimality. The problem occurs in countless areas ranging from job scheduling to logistics
and in very diverse applications such as truck or container loading with weight capacity constraints, digital con­
tent management in cloud storage, and event seating. For more details, we refer the reader to the survey by
Delorme et al. (2016).
Most of the state-of-the-art algorithms for the BPP are based on solving a set-covering (SC) formulation featur­
ing an exponential number ofPvariables associated with subsets of items of total weight no larger than W called
patterns. Letting P � {S ⊆ N : j∈S wj ≤ W} be the collection of all patterns and letting the binary variable ξS be
equal to 1 if and only if pattern S ∈ P is featured in the solution, the SC formulation reads
X
(SC) min ξS (1a)
S∈P
X
s:t: ξS ≥ 1 j∈N (1b)
S∈P(j)

ξS ∈ {0, 1} S ∈ P, (1c)
where P(j) ⊆ P is the collection of patterns containing item j ∈ N.
Let LSC be the linear programming (LP) relaxation of the SC formulation. The problem underlying this relaxa­
tion is usually called the Fractional Bin-Packing Problem (FBPP); see, for example, Karmarkar and Karp (1982),
Eisenbrand et al. (2013), Caprara et al. (2015), Coniglio et al. (2019). Let z(LSC) be the optimal solution value of
LSC, and let z(BPP) be the optimal solution value of the BPP. Any BPP instance such that z(BPP) � ⌈z(LSC)⌉ is
said to enjoy the Integer Round-Up Property (IRUP) (Kartak et al. 2015, Delorme et al. 2016). Although this

141
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
142 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

property holds for many BPP instances, several non-IRUP instances are known in the literature (Caprara et al.
2015). The Modified Integer Round-Up Property (MIRUP) is a weaker version of the IRUP that holds if either
z(BPP) � ⌈z(LSC)⌉ or their difference is no larger than 1 (i.e., z(BPP) � ⌈z(LSC)⌉ ≤ 1). The MIRUP has been proven
to hold when the number of different item sizes is no larger than 7 (see Eisenbrand et al. 2013), and it is conjec­
tured to hold in general (Scheithauer and Terno 1997).
Whereas on the IRUP instances computing z(LSC) suffices to certify (or disprove) the optimality of a given
solution, non-IRUP instances require more sophisticated methods to produce a strong bound to do so.
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

This situation is exacerbated by the fact that classical approaches for solving the SC formulation of the BPP are
known to suffer from numerical errors on certain classes of non-IRUP instances when floating-point solvers are
used. The Augmented Non-IRUP (ANI) instances proposed by Delorme et al. (2016) are one such class. As noted
by Pessoa et al. (2020, 2021), these numerical errors may lead to computing incorrect bounds. Such an event can
be catastrophic for the exactness of the solution algorithm because it may lead to constructing an invalid enumer­
ation tree as a result of the application of invalid pruning operations, which would constitute an invalid proof of
optimality of the solution that was found.
In the majority of the state-of-the-art algorithms for the BPP, the SC formulation is solved with a branch-price-
and-cut (BPC) algorithm, as originally proposed by Vance et al. (1994). At each node of the BPC tree, the LP
relaxation is solved by a column-and-row-generation method, following the original work of Gilmore and Gom­
ory (1961). In it, the patterns are generated by solving a pricing problem that, at the root node of the BPC tree,
coincides with an instance of the Knapsack Problem (KP). With only a few exceptions (see the works of Belov
and Scheithauer 2006 and Pessoa et al. 2020, 2021), branching is carried out following the classical rule proposed
by Ryan and Foster (1981), according to which two items are forced to be packed into the same bin or into differ­
ent ones.
A relatively new addition to the state of the art is strengthening the SC formulation with additional master cuts
such as the subset-row inequalities of cardinality three (SR3s). SR3s are a family of rank-1 Chv´atal-Gomory cuts
introduced into the BPP literature by Wei et al. (2020) and first proposed by Jepsen et al. (2008) that are valid for
set partitioning as well as for set-covering problems such as (1) where Constraints (1b) are tight w.l.o.g. in any
optimal solution.
Another new addition to the state of the art is pattern enumeration. Originally proposed by Baldacci et al. (2008)
for the Vehicle Routing Problem (VRP) and used in the context of the BPP by Pessoa et al. (2021), the technique
coincides with the enumeration of all patterns whose reduced cost is no larger than the gap between the value of
the incumbent and z(LSC) (possibly strengthened by master cuts). Such an enumeration leads to building a
reduced SC problem that can be solved to optimality by a branch-and-bound method without generating any fur­
ther patterns.
For more details on the state-of-the-art BPC methods for the BPP, we refer the reader to Wei et al. (2020) for
the EXM algorithm and to Pessoa et al. (2020, 2021) for the general-purpose BPC algorithm VRPSolver, which
can tackle variants of the VRP (of which the BPP is a special case).
For another family of methods (the most recent one being the NF-F algorithm) we refer the reader to de Lima
et al. (2022). Such methods rely on a network-flow framework designed to solve the integer counterpart to a
Dantzig-Wolfe decomposition via a path-flow and arc-flow model and can be adapted to solve instances of the
BPP. In particular, such methods rely on arc-flow formulations of pseudo-polynomial size that enjoy strong lin­
ear relaxations. Key to the efficiency of NF-F is a novel asymmetric branching scheme where a collection of smal­
ler arc-flow subproblems are solved by a general Mixed Integer Linear Programming (MILP) solver. Branching is
performed by selecting a subset of arcs and either by imposing all of them to be absent from the solution or by
imposing that at least one be contained in it.
Crucially, all of the state-of-the-art algorithms we mentioned (EXM, VRPsolver, and NF-F) rely either on
numerically unsafe bounds computed by a floating-point LP solver combined with a floating-point pricing algo­
rithm (this is the case of EXM) or on the adoption in a key step of the algorithm of a floating-point MILP solver
(this is the case of both VRPsolver and NF-F; in the former, the reduced SC problem is solved as a MILP with
the floating-point solver Cplex, whereas in the latter the left child node generated after a branching operation is
always solved as an arc-flow MILP formulation with the floating-point solver Gurobi). As a consequence, none
of these algorithms is guaranteed to produce numerically exact solutions, that is, solutions whose enumeration
tree constitutes a mathematically exact proof of optimality.

1.1. Review on Numerically Safe Approaches in Mixed Integer Linear Programming

The solution methods presented in the mixed integer linear programming literature to avoid numerical inaccura­
cies inherent to the floating-point computations are based on either a pure rational approach, a safe floating-point
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 143

approach, or a hybrid approach. In addition, the methods can also be classified based on the type of mathematical
formulations they employ: general compact MILP formulations or extended formulations, the latter being char­
acterized by an exponential number of variables.
In the pure rational approach (Wunderling 1996, Applegate et al. 2007, Gleixner et al. 2012, 2016), all arithmetic
operations are performed over rational numbers. This line of research resulted in rational LP solvers such as
QSopt_ex (Applegate et al. 2007) and SoPlex (Wunderling 1996, Gleixner et al. 2012, 2016) for the exact solu­
tion of LP problems.
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

Regarding safe floating-point approaches dealing with compact MILP formulations, Cook et al. (2009), Fuka­
sawa and Goycoolea (2011), and Cornuéjols et al. (2013) addressed numerical safety in the context of cutting
plane generation, whereas Neumaier and Shcherbina (2004) and Steffy and Wolter (2012) tackled the issue of
obtaining safe bounds for MILPs.
The works of Cook et al. (2011, 2013) and Eifler and Gleixner (2022) deal with the design of exact MILP solvers
based on hybrid approaches that combine exact rational LP solvers and safe floating point dual bounds. In partic­
ular, Eifler and Gleixner (2022) recently proposed a revision and extension of the solution framework proposed
by Cook et al. (2013) that integrated symbolic pre-solving, an exact repair step for solutions obtained from primal
heuristics, and a rational LP solver based on LP iterative refinement. Their computational study on the MIPLIB
2017 benchmark showed a significantly improved performance.
To the best of our knowledge, the only two works addressing the computation of safe dual bounds in the con­
text of extended formulations are by Held et al. (2012) and Fukasawa and Poirrier (2017). The work of Held et al.
(2012) introduced numerically safe bounds within a column-generation-based framework in the context of the
graph coloring problem. Fukasawa and Poirrier (2017) proposed five methods to obtain safe dual bounds for the
LP relaxations of the Capacitated VRP (CVRP). The first method was based on the scaling approach proposed by
Held et al. (2012). The next three methods were derived from ideas by Applegate et al. (2007) for the traveling
salesman problem and adapted to accommodate a column-generation scheme for the CVRP. The last method
was based on a Lagrangian relaxation that was specific to the CVRP formulation. Both Held et al. (2012) and
Fukasawa and Poirrier (2017) discussed safe floating-point implementations of the dynamic programming proce­
dure employed in the pricing step to obtain a numerically exact pricing algorithm.
Notably, even if we restricted ourselves to a BPC method designed to employ an adaptation of the scaling
technique of Held et al. (2012) as done by Pessoa et al. (2021) (see Proposition 2 in this paper for a generalization),
we would obtain bounds that are worse than their infinite-precision counterpart by an additive error propor­
tional to the number of variables and the fixed-point precision of the pricing algorithm; see Equation (2) in Held
et al. (2012). In some instances, such an error can be nonnegligible and produce weak bounds that can lead to
prohibitively large search trees. This, in particular, is the case of the ANI instances, where (as we will show in
this paper) having access to a numerically safe dual bound obtained with a precision higher than the one offered
by commercial LP solvers can lead to enormous computational advantages.

1.2. Contributions of this Paper

In this paper, we propose a novel technique for the computation of numerically safe LP bounds obtained with an
extended numerical precision, that is, a precision higher than the one of state-of-the-art commercial solvers. The
contributions of this paper can be summarized as follows:
• We present the first numerically exact algorithm for the BPP that is practical for solving large-scale instances.
• We propose a technique based on the combined adoption of a rational (infinite-precision) LP solver (SoPlex;
Gleixner et al. 2016) with a faster, floating-point one (Gurobi) and on an exact integer (fixed-point) pricing algo­
rithm that we develop ex novo for this work. To the best of our knowledge, rational solvers have never been suc­
cessfully used before in the context of a column-generation method.
• We design a new exact integer (fixed-point) pricing algorithm that relies on, among other features, a new
fathoming rule; the algorithm is designed in such a way that it can also perform pattern enumeration; differently
from not numerically safe approaches such as the one of Pessoa et al. (2021), after the enumeration phase we solve
the reduced SC problem to optimality by a further call to a simplified version of our (numerically exact) BPC algo­
rithm in which the pricing algorithm is disabled, which guarantees the lack of numerical errors.
• Thanks to extensive computational results, we validate the effectiveness of our numerically exact algorithm as
well as the relevance of its components on BPP instances affected by notorious numerical difficulties.
• The framework on which our algorithm is based can be of interest for finding numerically exact solutions to a
large array of combinatorial optimization problems that are typically tackled via a BPC method featuring a set
covering/partitioning problem as the master problem.
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
144 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

The remainder of the paper is structured as follows. In Section 2, we introduce the BPC method that forms the basis of
our algorithm. Section 3 presents the techniques we propose for the computation of extended-precision numerically safe
dual bounds and describes the corresponding algorithm based on column-and-row-generation. Section 4 describes our
exact integer (fixed-point) label-setting algorithm designed to solve the pricing problem and illustrates how it can be tai­
lored to perform pattern enumeration. Section 6 presents and analyzes the results of our algorithm on a set of BPP
instances from the literature. Section 7 concludes the paper and indicates future research directions.
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

2. Branch-Price-and-Cut Method
We outline in this section the BPC method that forms the basis for our numerically exact algorithm.
Let T � {T ⊆ N : |T | � 3} be the collection of all of the triplets of items in N, and for each T ∈ T, let P(T) � {S ∈
P : |S ∩ T | ≥ 2} be the subset of patterns with at least two items in T. The SR3 constraints (Jepsen et al. 2008) read
X
(SR3) ξS ≤ 1, T ∈ T:
S∈P(T)

We refer to the version of the LSC formulation (the LP relaxation of the SC formulation) tightened by these con­
straints as LSCT, where “T” stands for “triplets,” and call z(LSCT) its optimal solution value.
The value of z(LSCT) is computed by a column-and-row-generation method. At each iteration, the restricted
master problem (RMP)—a formulation featuring only a subset of the variables and constraints of LSCT—is
solved with the primal simplex algorithm to obtain a primal and a dual solution. Then, a column-generation step
takes place, and the pricing problem is solved in order to find negative reduced cost columns. If any are found,
they are added to the RMP, and a new column-generation iteration is carried out. If not, a row-generation step
takes place, and SR3 constraints are separated in a cutting plane fashion and added to the RMP. The cutting-
plane algorithm terminates when no violated SR3s are found, after which one or more iterations of the column-
and-row generation method takes place. The computations stop when both the column- and the row-generation
algorithms terminate without new columns or rows being found. Because of the small cardinality of the set T,
the SR3 inequalities can be separated by complete enumeration. The generation of columns requires, on the con­
trary, an efficient ad hoc pricing algorithm, which we describe in Section 4.1.
Let us consider a node of the BPC tree in which Ryan-Foster (RF) (Ryan and Foster 1981) branching is applied.
According to RF branching, a node with a fractional solution is split into two new nodes by imposing that a cho­
sen pair of items (the RF pair) be packed either in the same bin (“same branch”) or into different bins (“different
branch”). In the same-branch case, the pair of items is merged into a super-item with a weight equal to the sum of
the weights of the individual items, and every already-generated pattern that contains only one of the two items
is discarded. In the different-branch case, a conflict is introduced between the two items to prevent the selection
of patterns that contain both of them, and every already-generated pattern that violates such a constraint is dis­
carded. Whereas in the pricing problem the same-branch case is handled by simply considering the super-item
in lieu of the two individual items, in the different-branch case the new conflict constraint must be enforced
explicitly when a new pattern is created (see Section 4.1 for more details).
We denote by MP the master problem associated with the node at hand and by z(MP) its optimal solution
value. Let also RMP be the corresponding restricted master problem. Let T ⊆ T be the set of triplets whose SR3
constraints have been generated so far, and let N � {1, 2, : : : , n} be the set of n items (possibly involving super-
items) with integer weights w j for all j ∈ N corresponding to the node. Let G � (N, E) be a conflict graph whose
edges represent conflicts between the items. Let P be the set of patterns generated so far. For each j ∈ N, let πj ≥
0 be the dual variable corresponding to Constraint (1b) associated with item j, and let ρT ≤ 0 be the dual variable
corresponding to the SR3 constraint associated with a triplet T belonging to T. For each pattern S, let T(S) �
{T ∈ T : |T ∩ S | ≥ 2} be the set of triplets in T with at least two items in S. The LP dual of the RMP reads
X X
(RMPD) max πj + ρT (2a)
j∈N T∈T
X X
s:t: πj + ρT ≤ 1 S∈P (2b)
j∈S T∈T(S)

πj ≥ 0 j∈N (2c)
ρT ≤ 0 T ∈ T: (2d)
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 145

The pricing problem of the RMP coincides with an instance of the Knapsack Problem (KP) with Triplets and Conflicts
(KP-T-C). Its nonempty solutions coincide with the following set of patterns:
8 9
< X =
Pb � S ⊆ N : S ≠ ∅, w j ≤ W, and {j1 , j2 } ∉ E for all j1 , j2 ∈ S :
: j∈S
;

The reduced cost of a pattern S ∈ P b with respect to a dual solution (p, r) and a parameter b (equal to 1 here; dif­
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

ferent values will be used later on in the paper) is

X X
c S (p, r, b) � b � πj � ρT : (3)
j∈S T∈T(S)

The KP-T-C asks for a pattern S ∈ P b of minimum reduced cost. If c S′ (p, r, 1) < 0, the pattern is added to the
′

RMP; otherwise, the solution (p, r) is proven to be a feasible dual solution to the MP.

3. Extended-Precision Numerically Safe Dual Bounds and Two-Phase Column-

Generation Method
One of the main goals of this paper is computing a numerically safe dual bound with a precision that is higher
than the one allowed by floating-point LP solvers by relying on both a floating-point LP solver and an infinite-
precision (rational) one.
To achieve this, we introduce a procedure that extends the dual-variable scaling technique of Held et al. (2012)
(which applies to an RMP with nonnegative dual variables) to the case where the RMP also features dual vari­
ables that are nonpositive. Because floating-point solvers naturally approximate the value of the dual variables
of any LP (including the RMP) by floating-point numbers, a procedure of this nature is necessary because, if not
handled with care, these floating-point numbers may lead to two issues: (i) incorrect calculations within the pric­
ing algorithm and (ii) the generation of a column that would not enter the basis because of its reduced cost being
smaller than the optimality tolerance of the solver. In the algorithm we propose, both issues are circumvented by
relying on the extended scaling procedure described in this section and by combining it with an exact integer
(fixed-point) pricing algorithm (described in Section 4.1).
Our column-and-row-generation method works in two phases. In the first phase, at each iteration the RMP is
reoptimized via the floating-point LP solver, and the scaling procedure is combined with the pricing algorithm
to generate patterns with a reduced cost that lies within the floating-point optimality tolerance of the solver. We
refer to the latter as ɛ0.
The second phase starts as soon as the pricing algorithm finds a pattern S′ whose reduced cost is strictly smal­
ler (in absolute value) than ɛ0. Because, even if we assumed that the floating-point solver worked in infinite preci­
sion, that is, with a tolerance ɛ0 � 0, without incurring any numerical errors, such a small reduced cost would
prevent it from bringing the corresponding ξS′ variable into the basis when reoptimizing the RMP, at the begin­
ning of this phase we switch to the rational (infinite-precision) solver and use it until the column-and-row-
generation procedure halts (halting is guaranteed by Proposition 1 below). The second phase also starts in the
event that, even though the reduced cost is not smaller (in absolute value) than ɛ0, the floating-point solver fails
to bring the newly generated pattern into the basis because of numerical errors incurred within the reduced-cost
calculations.
Such a two-phase method allows us to compensate for the weaker dual bound (illustrated in Proposition 2)
that the scaling procedure inevitably leads to. With it, we achieve a higher numerical precision than the floating-
point solver would allow for while also benefiting for many iterations from its higher efficiency. This way, we
limit the number of calls to the computationally more onerous rational solver and, overall, achieve a good trade-
off between numerical precision and computational efficiency without forsaking numerical exactness.

3.1. Extended Dual Scaling Technique for the Computation of Numerically Safe Dual Bounds
Let (pfloat , rfloat ) be a floating-point dual solution to the RMP of value zfloat computed by a floating-point LP
solver. Because such solvers do not typically provide a bound on the accuracy of their solutions (Held et al.
2012), (pfloat , rfloat ) may be affected by numerical errors (it may be infeasible, suboptimal, or both). This may not
be an issue per se. Indeed, a valid dual bound could be recovered from an infeasible dual solution by, for exam­
ple, manipulating it as is done for set-covering problems by Farley (1990) as well as from a suboptimal dual solu­
tion by, for example, including an additive corrective term in the bound calculations (which should, though, be
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
146 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

done without numerical errors) as done with the Lagrangian bound (Lübbecke and Desrosiers 2005). These proce­
dures, though, require the calculations carried out by the pricer on (pfloat , rfloat ) to be numerically exact.
Because of the floating-point nature of (pfloat , rfloat ), however, cancellation errors may be made in the pricing
algorithm even if the dual solution is perfectly accurate whenever the precision that is available to the pricer is
insufficient to carry out the necessary arithmetic operations on (pfloat , rfloat ) without errors. As a consequence, the
b
pricing algorithm may attest the dual feasibility of (pfloat , rfloat ) (thus declaring c S (pfloat , rfloat , 1) ≥ 0 for all S ∈ P),
even if the solution is not dual feasible and zfloat > z(MP) or is deemed (pfloat , rfloat ) infeasible even if it is not. In
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

the first case, the risk is of computing the invalid lower bound ⌈zfloat ⌉ > z(BPP), whereas in the second case, the
column-and-row-generation algorithm may enter an infinite loop.
To overcome these issues so as to be able to work with dual variables that can be safely manipulated by the
pricing algorithm without incurring cancellation errors, we extend the technique proposed by Held et al. (2012)
to the case where the RMP features nonnegative as well as nonpositive dual variables. We approximate the (pos­
sibly inaccurate) floating-point dual solution (pfloat , rfloat ) by introducing the following scaled integer dual solution
(pint , rint ),
j k j k
πint
j � Kπj
float
, j ∈ N, and ρint T � Kρj
float
, T ∈ T,

where K > 0 is a positive scaling factor and the following diminished dual solution (pdim , rdim ) is
1 int 1 int
πdim
j � π , j ∈ N, and ρdim � ρ , T ∈ T:
K j T
K T
The parameter K affects the numerical precision of the column-and-row-generation algorithm. In Section 6.6, we
describe how to select a suitable value for K and how varying K impacts the algorithm’s efficiency. If K is chosen
as a power of 10, that is, K � 10k for some k ∈ N, then pdim � trunc(pfloat , k) because of pfloat ≥ 0, where trunc(x, k)
is the truncation of the floating-point number x to the k-th decimal figure. Differently, rdim does not coincide
with trunc(rfloat , k) as, because of rfloat ≤ 0, the latter is equal to ⌈K1 rfloat ⌉, whereas rdim is defined as ⌊K1 rfloat ⌋. Thus,
pdim � trunc(pfloat , k) ≤ pfloat , whereas rdim ≤ rfloat ≤ trunc(rfloat , k). By construction, if (pint , rint ) satisfies
X X
πint ρint b
j + T ≤ K, ∀S ∈ P,
j∈S T∈T(S)

dim dim
P
P (pdim , r ) satisfies the dual Constraints (2b).
then Thus, it is dual feasible for the RMP, and zdim � j∈N πdim j +
dim float float
T∈T Tρ is a valid lower bound on z(MP) (i.e., z ≤ z(MP)). Similar considerations apply when p and r
have a binary representation and, as done in our computational experiments, K is chosen so as to satisfy K � 2k
for some k ∈ N.
After computing the scaled integer dual vectors (pint , rint ), we use them for solving the pricing problem in
order to compute one or more patterns by minimizing, rather than the floating-point reduced cost c S (pfloat , rfloat , 1)
(doing so may lead to incorrect calculations because of the fixed-point nature of the pricer), the scaled integer
reduced cost c S (pint , rint , K). Notice that c S (pint , rint , K) is equal to the diminished reduced cost c S (pdim , rdim , 1) multi­
plied by K. This way, the pricing algorithm works solely with fixed-point (integer) numbers. Assuming that
(pint , rint ) and the result of any intermediate calculations that the pricer carries out can be represented by the
integer data type that is used in its implementation, cancellation errors are completely avoided, and the pricer
always produces a numerically exact solution.
From a convergence perspective, the definition of (pdim , rdim ) is motivated by the following proposition:
Proposition 1. Consider a column-and-row-generation method based on a floating-point LP solver whose calculations are
guaranteed to be in an (absolute) additive error no larger than ɛ0, in which at each iteration the pricing problem is solved
with the integer dual variables (pint , rint ) without numerical errors and where the column-and-row-generation method stops
whenever min b {c S (pdim , rdim , 1)} ≥ �ɛ0 . Then, the column-and-row-generation algorithm terminates after finitely many
S∈P
iterations.
Proof. By construction, we have πfloat
j ≥ πdim
j for all j ∈ N and ρfloat
T ≥ ρdim
T for all T ∈ T. Thus,
1 X X
c S (pint , rint , K) � c S (pdim , rdim , 1) � 1 � πdim
j � ρdim
T ≥
K j∈S T∈T(S)
X X
1� πfloat
j � ρfloat
T � c S (pfloat , rfloat , 1) (4)
j∈S T∈T(S)
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 147

holds for each S ∈ P. b Given a dual solution (pfloat , rfloat ) and the corresponding diminished dual solution
dim dim
(p , r ), for each S belonging to the set of patterns P ⊆ P b already contained in the RMP, we have
dim dim float float
c S (p , r , 1) ≥ c S (p , r , 1) ≥ �ɛ0 , and thus, already generated patterns cannot be generated once again.
By assumption, if (pdim , rdim ) violates the dual constraint associated with a pattern S of diminished reduced cost
c S (pdim , rdim , 1) < 0, then c S (pdim , rdim , 1) < �ɛ0 holds. Because of (4), this implies c S (pfloat , rfloat , 1) < �ɛ0 . There­
fore, such a constraint is violated by the floating-point solution (pfloat , rfloat ) returned by the floating-point LP
solver. Because its reduced cost is strictly smaller than �ɛ0 , when the column corresponding to pattern S is
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

added to the RMP, (pfloat , rfloat ) becomes numerically infeasible for the floating-point solver. This guarantees
that, if the reduced costs calculated by the LP solver are guaranteed to be in an absolute error no larger than ɛ0,
the column-and-row-generation method will not enter an infinite loop. Hence, because P b contains only finitely
many patterns, the column-and-row-generation method terminates after finitely many iterations. Q.E.D
Proposition 1 assumes that the LP solver is guaranteed to carry out its calculations in an (absolute) error no
larger than its tolerance ɛ0. This assumption, though, is not guaranteed to hold with state-of-the-art floating-
point (inexact) LP solvers. Such solvers allow the user to set the value of tolerance parameters such as, for exam­
ple, CPXPARAM_Simplex_Tolerances_Optimality and OptimalityTol for, respectively, Cplex and
Gurobi. Such a parameter, though, is used as cutoff value within a termination condition whose computation
may itself be subject to numerical errors. Therefore, such a parameter does not typically coincide with a bound
on the cancellation error that the floating-point solver may be in (this is exacerbated by, among others, the adop­
tion of pre-solve and scaling techniques). Thus, the condition that c S (pdim , rdim , 1) < �ɛ0 implies
c S (pfloat , rfloat , 1) < �ɛ0 may not necessarily hold in practice. If violated, the column-and-row-generation method
may enter an infinite loop where the floating-point dual solution (pfloat , rfloat ) remains unchanged (due to
remaining feasible) regardless of the tolerance that is selected for the solver. We must note, however, that we
have never observed such a phenomenon in our numerical experiments.
To avoid infinite loops and guarantee convergence (albeit to a weaker bound) under a more general setting,
whenever one or more patterns S with c S (pdim , rdim , 1) < �ɛ0 are generated, one can check whether at least one
of such patterns enters the basis in the next RMP solution and, if not, terminate the column-and-row-generation
algorithm and set ɛ0 to the smallest value taken by c S (pdim , rdim , 1) across the new patterns. We remark that, in
the context of the two-phase column-and-row-generation method that we will introduce in the following, if this
situation were to occur, the algorithm would naturally enter phase II, where the infinite-precision LP solver is
used, thus achieving convergence.
In order for the column-and-row-generation algorithm to converge, K must therefore be chosen in accordance with
the data type used for storing integer values in one’s implementation of the pricing algorithm in such a way that inte­
ger overflows are avoided (see Section 6.6 for the related details) as well as with the precision of the floating-point
solver. Note that this also applies to other contexts such as the set-covering formulation of Held et al. (2012).
The column-and-row-generation algorithm is guaranteed to terminate either when working (as assumed in
Proposition 1) with a floating-point LP solver that is guaranteed to be in an absolute error that is sufficiently
small for one’s choice of K or when ɛ0 is chosen as explained before when such an assumption is not guaranteed
to hold. However, working with the diminished dual solution (pdim , rdim ) rather than with (pfloat , rfloat ) can lead
to a bound zdim that is weaker than z(MP). The difference between the two can be bounded according to the fol­
lowing proposition.
Proposition 2. Let (pfloat , rfloat ) be an (error-free) optimal dual feasible solution to the MP of value z(MP), and let
(pdim , rdim ) be the associated diminished solution of value zdim . Then, z(MP) � | N | +K | T | ≤ zdim ≤ z(MP).
Proof. For any α, β ∈ R such that β � ⌊Kα⌋, we have α � K1 β ≤ K1 ; hence, we deduce 0 ≤ πfloat
j � πdim
j ≤ K1 for all j ∈ N
and 0 ≤ ρfloat
T � ρdim
T ≤ K1 for all T ∈ T. Because
X X
zfloat � zdim � (πfloat
j � πdim
j )+ (ρfloat
T � ρdim
T ),
j∈N T∈T

we deduce
|N | + |T |
0 ≤ zfloat � zdim ≤ :
K
The claim follows because zfloat � z(MP). Q.E.D
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
148 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

The proposition shows that K1 should be as small as possible because, if K1 ≥ ɛ0 , the final dual bound obtained
when the scaling procedure is adopted would be unnecessarily weak.
To achieve a higher numerical precision than ɛ10 , one could, in principle, adopt a rational (infinite-precision) LP
solver instead of a floating-point one at each iteration of the column-and-row-generation method. In such a case,
K would be selected based purely on the fixed-point precision of the pricing algorithm. As known, though,
infinite-precision LP solvers suffer from significantly higher running times than their floating-point counterparts,
and their adoption at each stage of the column-and-row-generation method is likely to be impractical (which is
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

indeed confirmed by our preliminary computational experiments).

For this reason, we introduce a two-phase column-and-row-generation algorithm to efficiently handle the dual
bound calculations with a value of K satisfying K1 ≪ ɛ0 . In the first phase, we rely on the more efficient but inaccu­
rate floating-point LP solver. In the second phase, we switch to the rational solver and use it until the MP is
solved. This way, we limit the number of calls to the rational solver and achieve a good efficiency as well as a
high numerical accuracy.

3.2. Two-Phase Column Generation Algorithm

We now describe in more detail the two-phase column-and-row-generation algorithm that we propose to solve
the MP at each node of the enumeration tree. Before doing so, we introduce dual bounds and fathoming rules
that we leverage to improve the overall computational efficiency of the method.

3.2.1. Lower Bounds and Fathoming Rules. To achieve, if possible, an early termination of the column-and-row-
generation algorithm, we rely on an extension to the case with SR3 constraints of the classical bound that holds
for set covering problems that is due to Farley (1990) and also adopt two (classical) fathoming rules (or termina­
tion criteria).
The extension of Farley’s bound is described by the following proposition.
Proposition 3. Let (pdim , rdim ) be a (not necessarily feasible nor optimal) diminished dual solution of value zdim to the
RMP at an iteration of the column-and-row-generation procedure. Let c min � min b {c S (pdim , rdim , 1)}. If c min < 0, the
S∈P
value
zdim
LBF �
1 � c min
is a valid lower bound on the optimal solution value z(MP) of the MP.
Proof. By assumption, we have
X X
c S (pdim , rdim , 1) � 1 � πdim � ρdim ≥ c min , b
∀S ∈ P,
j T
j∈S T∈T(S)

or, equivalently,
X X
πdim + ρdim ≤ 1 � c min , b
∀S ∈ P:
j T
j∈S T∈T(S)

Because 1 � c min > 0, we deduce

X πdim
j
X ρdim
+ T
≤ 1, b
∀S ∈ P:
j∈S
1 � c min 1 � c min
T∈T(S)
� � � �
pdim rdim b Therefore, the dual solution pdim rdim
This is to say that c S 1�c min , 1�c min , 1 ≥ 0 holds for all S ∈ P. 1�c min , 1�c min of value
zdim zdim
1�c min is a feasible solution to the dual of the MP, and thus, 1�c min is a valid lower bound on z(MP). Q.E.D
Interestingly, LBF turns out to be tighter than the classical lower bound on z(MP) known in the literature as the
Lagrangian bound (see Lübbecke and Desrosiers 2005), which reads
LBL � zdim + UB c min ,
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 149

where UB is an upper bound on the optimal solution value of the MP. The validity of LBL follows directly from
the theory of linear programming because the value of zdim cannot be reduced by more than UB times the smal­
lest reduced cost c min . Thus, we have zdim + UB c min ≤ z(MP) ≤ zdim .
The following proposition holds.
Proposition 4. LBF dominates LBL , that is, LBF ≥ LBL .
Proof. We aim to show that
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

zdim
LBL � zdim + UB c min ≤ � LBF :
1 � c min

Because c min < 0, by dividing both sides by c min < 0, the previous inequality is shown to be equivalent to the fol­
lowing one:

zdim zdim
+ UB ≥ :
c min c min (1 � c min )

Grouping by zdim , the previous inequality can be rewritten as follows:

� �
1 1 zdim
UB ≥ zdim � � � LBF :
c min (1 � c min ) c min 1 � c min

Because the latter inequality is always satisfied thanks to Proposition 3, the claim follows. Q.E.D
We remark that this result holds even for set-covering problems where LBF is the classical bound due to Farley.
To the best of our knowledge, this result is new.
In our algorithm, LBF is combined with the following two fathoming rules. The first one leverages the value of
the incumbent upper bound UB to fathom (when the latter is optimal) a node of the enumeration tree:
Fathoming Rule 1. If ⌈LBF ⌉ � UB, then the subproblem associated with the current node of the enumeration tree is
fathomed by the upper bound UB.
The second one leverages the value of the lower bound ⌈zdim ⌉ to achieve (when the latter is optimal) an early-
termination of the column-and-row generation procedure at a node of the enumeration tree:
Fathoming Rule 2. Let zdim be the solution value of the RMP at an iteration of the column-and-row-generation method. If
⌈LBF ⌉ � ⌈zdim ⌉, then the column-and-row-generation procedure is halted, and a valid lower bound ⌈LBF ⌉ at the node is
determined.

3.2.2. Alternative Derivation of the Lagrangian Bound. We provide here an alternative derivation of the
Lagrangian bound that, to the best of our knowledge, is new and could be of independent
P interest. Consider
an extension of the SC formulation obtained by adding to it the redundant constraint S∈P ξS ≤ UB, where
UB ≤ n is an upper bound on the number of bins featured in an optimal solution. The dual of such a problem
reads as follows:
8 9
<X X X X =
max πj + ρT + UBγ : πj + ρT + γ ≤ 1, S ∈ P :
p≥0, r≤0, γ≤0: ;
j∈N T∈T j∈S T∈T(S)

P P
Given a floating-point solution (pfloat , rfloat ), let γfloat � minS∈P {1 � float
j∈S πj � float
T∈T(S) ρT }, where we assume
float float float float
that γ is computed with infinite precision. If γ ≥ 0, (p , r ) is dual feasible (with infinite precision). If
P P
not, the invalid dual bound j∈N πj + T∈T ρT can be corrected by adding to it the (negative) term UB γfloat .
float float

Because, by construction, γfloat � c min , such an updated bound coincides with the Lagrangian bound.
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
150 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

3.3. Outline of the Two-Phase Column-Generation Algorithm

Algorithm 1 (Two-Phase Column Generation Algorithm)
Input: ɛ0, K, P and T, UB
Output: P, T, zint , zdim , (pint , rint ), (pdim , rdim )
begin
//Initialization (phase I starts)
1. ɛ ← ɛ0 , optimality ← false, fathomed ← false;
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

//Main loop
2. while optimality � false and fathomed � false do
//Solve the RMP
3. Solve the RMP using solver LP(ɛ). Let (pfloat , rfloat ) be the RMP dual solution;
//Compute scaled integer and diminshed dual solutions
4. Compute the scaled integer and the diminished dual solutions (pint , rint ) and (pdim , rdim );
//Solve the pricing problem
5. b : c S (pint , rint , K) < 0} (see Section 4.1);
Compute S′ ∈ arg min b {c S (pint , rint , K)}, and let P′ ⊆ {S ∈ P
S∈P
//Computation of c min
6. c min ← c S′ (pdim , rdim , 1);
//Apply Fathoming rule 1
7. if ⌈LBF ⌉ � UB then fathomed ← true, zdim ← +∞; break
//Apply Fathoming rule 2
8. if ⌈LBF ⌉ � ⌈zdim ⌉ then optimality ← true, zdim ← LBF ; break
//Check convergence
9. if c min ≥ 0 then
//SR3 separation
10. Separate SR3 by complete enumeration. Let T′ ⊆ T \ T be the set of generated triplets;
11. if |T′ | � 0 then
12. optimality ← true;
13. else
//Update the set of SR3
14. T ← T ∪ T′ ;
15. end
16. else
//Update the set of patterns
17. P ← P ∪ P′ ∪ {S′ };
//Check LP numerical precision
18. if c min ≥ �ɛ then
//Set precision to infinite-precision (phase II starts)
19. ɛ ← 0;
20. end
21. end
22. end
23. end
The algorithm we use to solve the MP at a node of the enumeration tree is summarized by Algorithm 1. It takes
as input the initial numerical tolerance ɛ0 associated with the LP solver, the value of K, the sets P and T of,
respectively, the patterns and SR3 constraints associated with the current RMP, and the incumbent value UB. It
returns the updated sets P and T, the value of the lower bound zdim and (these values will be used for the pat­
tern enumeration method described below) the value of zint , the integer scaled dual vector (pint , rint ), and the
diminished dual vector (pdim , rdim ). If zdim � +∞, the subproblem associated with the BPC node is fathomed by
Fathoming Rule 1.
The algorithm starts by setting ɛ to the numerical tolerance ɛ0 of the floating-point LP solver (phase I). The var­
iable “optimality” takes value “true” if the current lower bound is proven to be optimal and “false” otherwise,
whereas the variable “fathomed” takes value “true” if the current subproblem is fathomed and “false” otherwise.
At each iteration of the main loop (line 3), the algorithm solves the RMP using the LP solver with tolerance ɛ and
computes the diminished and scaled integer dual vectors (pdim , rdim ) and (pint , rint ) (lines 4 and 5). Then, the
pricing problem is solved using (pint , rint ), followed by the computation of the scaled integer reduced cost c min �
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 151

int int ′
b {c S (p , r , K)} associated with the set of generated patterns P (lines 6 and 7). Fathoming Rules 1 and 2
minS∈ P
are then tested (lines 8 and 9); if Fathoming Rule 2 applies, then the value of the lower bound zdim is set to LBF .
The sign of c min is then checked to verify the convergence of the algorithm (line 10). If c min ≥ 0, SR3 inequalities
are separated (line 11). If none are found, then optimality is proven (line 13); otherwise, the corresponding set of
SR3 inequalities T is updated (line 15). If c min < 0, then the set of patterns P is updated (line 18). The algorithm
then checks whether the current tolerance ɛ of the LP solver is still sufficient to include one or more of the newly
generated patterns in P′ in the basis at the next iteration (line 19). If this is not the case, then the tolerance param­
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

eter ɛ is set to 0, in which case the rational (infinite-precision) solver is adopted from the next main iteration until
convergence is established (phase II).
Because, due to working with fixed-point integer numbers, the maximum nonpositive scaled integer reduced
cost c S (pint , rint , K) that can be computed by the pricing algorithm is equal to �1, the maximum nonpositive
diminished reduced cost c S (pdim , rdim , 1) that can be computed by the pricing algorithm is equal to � K1 . If K is
chosen so as to satisfy K � ɛ10 (where ɛ0 > 0 is the tolerance of the LP solver), then the maximum negative dimin­
ished reduced cost value computed by the pricing algorithm is no larger than � ɛ10 , and therefore, Algorithm 1
works within the tolerance of the LP solver. Dual bounds with an extended numerical precision higher than ɛ10
are obtained for any K > ɛ10 .

4. Pricing Algorithm and Pattern Enumeration

In this section, we provide a description of the exact integer (fixed-point) pricing algorithm that we propose and
of the pattern enumeration method, together with an illustration of how we solve the reduced SC problem to
optimality in a numerically exact way thanks to a simplified version of our BPC algorithm.

4.1. Mathematical Formulation of the Pricing Problem and Pricing Algorithm

As described in Section 2, the pricing problem corresponds to an instance of the KP-T-C and can be mathemati­
cally formulated as follows. We recall that we are given a set N � {1, 2, : : : , n} of n items, with each having an
integer weight w j , j ∈ N. We are also given a conflict graph G � (N, E), where E is a set of edges such that {i, j} ∈ E
when i and j are in conflict.
Let xj be a binary variable equal to 1 if item j ∈ N is selected and 0 otherwise. Furthermore, let zT be a binary
variable equal to 1 if and only if the dual contribution of T ∈ T must be subtracted from the reduced cost of an
optimal pattern. The KP-T-C can be formulated as follows:
X X
min b � πj x j � ρT zT (5a)
j∈N T∈T
X
s:t: w j xj ≤ W (5b)
j∈N

xj1 + xj2 ≤ 1 {j1 , j2 } ∈ E (5c)

xj1 + xj2 ≤ zT + 1 T ∈ T, j1 , j2 ∈ T, j1 ≠ j2 (5d)
xj ∈ {0, 1} j∈N (5e)
zT ∈ {0, 1} T ∈ T: (5f)
The objective function in (5a) corresponds to the reduced cost (see Equation (3)) to be minimized. Constraint (5b)
imposes that the knapsack capacity not be exceeded. Constraints (5c) avoid that pairs of items that are in conflict
be packed together in a solution. Constraints (5d) guarantee that the dual contributions of the set of inequalities
in T are accounted for in zT by imposing zT � 1 for each T ∈ F, j1 , j2 ∈ T, j1 ≠ j2 whenever xj1 � xj2 � 1. Notice that
w.l.o.g. the integrality restrictions on the z variables can be lifted.
Below, we describe an algorithm for the solution of the KP-T-C based on dynamic programming (DP). Accord­
ing to a set of preliminary experiments, our DP algorithm outperforms the direct solution of Formulation (5)
using state-of-the-art MILP solvers. Moreover, our DP algorithm, as required by Algorithm 1, works in exact
integer (fixed-point) precision, a property that is not guaranteed by state-of-the-art MILP solvers.
The pricing algorithm follows the scheme of a classical DP algorithm for the KP (see Martello and Toth 1990)
where |N | stages are considered, and each stage j ∈ N is associated with a subset of the set of feasible patterns P b
involving the first j items. The algorithm takes as input an integer dual solution (p, r) and two user-defined para­
meters zb ∈ Z and ∆ ∈ N. If zb < 0, then the algorithm produces as output the most negative reduced cost pattern
together with up to ∆ � 1 additional negative reduced cost patterns (if any). If zb ≥ 0, then pattern enumeration is
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
152 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

performed (see Section 4.2 for a detailed description), and the algorithm generates at most ∆ patterns with a
reduced cost no larger than zb.
We call a tuple L � (j, X, ω, c, Y, R) representing a partial pattern a label. In it, j is the last item featured in the
PX ⊆ {1, : : : , j} is the set of items contained in the partial pattern; ω is the total weight of X, that is,
label;
ω � h∈X w h ; c is the reduced cost of the partial pattern; Y is the set of items in {j + 1, : : : , n} that can be individu­
ally added to the set X while keeping the pattern feasible; and R is the set of |T | binary resources associated
b → {0, 1} for all σ ∈ R. With a slight abuse of
with the triplets in the set T, namely, R � {σ1 , σ2 , : : : , σ | T | } and σ : P
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

notation, we refer to the attributes j, X, ω, c, Y, and R of a label L by j(L), X(L), ω(L), c(L), Y(L), and R(L).
The algorithm starts from the initial label L0 � (0, ∅, 0, 1, N, {0}σ∈R ). A label L � (j, X, ω, c, Y, R) represents a com­
plete pattern consisting of the set of items in X of reduced cost equal to c if Y � ∅. If Y ≠ ∅, let j∗ � arg min{h : h ∈
Y} be the item of minimum index in Y. Given a label L, a label extension rule is used to create two new labels L1
and L2 by packing j∗ in the former and discarding it in the latter. For a given label L, let P(L) b ⊆P b be the set of all
feasible patterns with items in Y(L) that can be used to complete the partial pattern X(L), that is, P(L) b �
{S′ ∈ N | S′ � S \ X(L) for some S ∈ P,b X(L) ⊂ S}. Given a label L � (j, X, ω, c, Y, R) and a pattern S ∈ P(L), b we
denote by (X(L), S) the pattern (X(L) ∪ S) ∈ P b obtained by joining the partial pattern X(L) with its completion S.
The algorithm relies on fathoming and dominance rules to reduce the number of labels it works with and
accelerate its execution. The following property holds.
b
Property 1. Given a label L � (j, X, ω, c, Y, R), let lb(L) be a lower bound on the reduced cost of any pattern (X(L), S) ∈ P
that can be obtained by completing the partial pattern X(L) with some S ∈ P(L).b If lb(L) ≥ zb, then the label L cannot lead to
any pattern of reduced cost smaller than zb, and therefore, it can be discarded.
Let KP(B, α, b, g) be an instance of the KP (in minimization version) asking for a minimum-profit subset of
items of B � {1, 2, : : : , |B |} that fit into a bin of capacity α ∈ Z+ with profits b ∈ R�| B | and weights g ∈ Z+| B | . Let
z(KP(B, α, b, g)) be its optimal solution value. We define the following fathoming rule (also used by Wei et al.
2020).
DP Fathoming Rule 1. Given a label L � (j, X, ω, c, Y, R), the value lb1 (L) � c(L)+z(KP({j + 1, : : : , n}, c � ω(L), b, g))
with b � (�πj+1 , : : : , � πn ) and g � (w j+1 , : : : , w n ) provides a valid lower bound on the reduced cost of any pattern
b S ∈ P(L).
(X(L), S) ∈ P, b

Let z(KPLP (B, α, b, g)) be the optimal solution value of the LP relaxation of the aforementioned KP problem.
We introduce the following new fathoming rule.
DP Fathoming Rule 2. Given a label L � (j, X, ω, c, Y, R), the value lb2 (L) � c(L) + z(KPLP (B, c � ω(L), b, g)) provides a
valid lower bound on the reduced cost of any pattern (X(L), S) ∈ P, b S ∈ P(L),
b where
• B is equal to Y(L) (we assume that the indices in B are defined consecutively);
• b � (�πν(1) , : : : , � πν( | Y(L) | ) ) and g � (w ν(1) , : : : , w ν( | Y(L) | ) ), where, for each h ∈ B, ν(h) is the original index of the item
of index h in Y(L).
Below, we show how the lower-bounding functions lb1 (:) and lb2 (:) can be computed efficiently.
It is worth noting that, differently from Fathoming Rule 1, Fathoming Rule 2 explicitly considers the conflict
constraints associated with the items in X(L) and the set of remaining items Y(L). Therefore, no dominance rela­
tion exists between the two rules. Clearly, at the root node of the BPC tree where no conflict constraints are pre­
sent, Fathoming Rule 1 dominates Fathoming Rule 2.
To implement the pricing algorithm, we associate with an item j ∈ N a bucket Lj containing all labels
L � (j, X, ω, c, Y, R). The set of buckets is implemented by means of a doubly linked list stored in one contiguous
pre-allocated segment of memory where each node of the list, in addition to the link fields, contains the label
data. Whenever the maximum allocation size is reached by the algorithm, the entire algorithm terminates prema­
turely. In order to reduce the space requirements, the sets X and Y and the resource vector R of a label are
encoded by using a bit-mask representation where every single bit of a computer word is used separately to indi­
cate whether an element is included in the set or not. Classical bit-set operations are used to implement the basic
set operations.
The algorithm returns a set of patterns P′ ⊆ P b containing the most negative reduced cost pattern and up to
∆ � 1 additional patterns with a negative reduced cost.
To speed up the computations, the lower-bounding functions lb1 (:) and lb2 (:) adopted in Fathoming Rules 1
and 2 are efficiently computed in the following way. For the computation of lb1 (:), we precompute the values of
the recursive function g(j, ω) � z(KP({j, : : : , n}, ω, (w j , : : : , w n ), (�πj , : : : , � πn ))) for all j ∈ N, ω � 0, : : : , W, using
dynamic programming (Martello and Toth 1990). This allows for computing the corresponding term in the
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 153

bounding function lb1 (L) as g(j(L) + 1, W � ω(L)) with an overall number of operations equal to O( |I |). For com­
puting lb2 (:), we precompute the component-wise ratio between the profit vector �p and the weight vector w
and sort the corresponding values in nonincreasing order. This allows for computing lb2 (·) within each label
extension in O( | N |) operations.
To further reduce the number of generated labels, we also rely on the following dominance rule, also used by
Wei et al. (2020).
Dominance Rule 1. Let L1 and L2 be two labels with j(L1 ) � j(L2 ) and ω(L1 ) ≤ ω(L2 ). If
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

X X
c(L1 ) � ρ(σ) ≤ c(L2 ) � πj ,
σ∈R: j∈Y(L2 )\Y(L1 )
σ(L1 ) � 1, σ(L2 ) � 0

then label L1 dominates label L2, and thus label L2 can be discarded.
The correctness of this rule follows from the observation that from the feasible extensions of L2 we can con­
struct feasible extensions for L1 and that the reduced cost of L1 cannot exceed that of L2.

4.2. Exact Integer Pattern Enumeration Algorithm

A classical result of integer programming (often called reduced-cost fixing and dating back to the seminal paper
on the Traveling Salesman Problem by Dantzig et al. (1954)) is that, given an upper bound UB and the optimal
solution value LB of the LP relaxation of a binary integer program, any variable with a reduced cost larger than
UB � LB cannot take a positive value in an optimal integer solution. Baldacci et al. (2008) were the first to show
how this result can be leveraged in the context of a column-generation method for the VRP to design a so-called
route enumeration method. The same method was used by Contardo and Martinelli (2014) and Pessoa et al. (2020).
The idea is to run the CG algorithm until convergence and then apply a column enumeration algorithm (a var­
iant of a list-based dynamic programming algorithm such as the one we presented previously) tasked with build­
ing all of the columns with a reduced cost no larger than UB � LB. Such columns are used to populate a Reduced
Master Problem (ReMP) that is then solved as an integer programming problem with a state-of-the-art MILP
solver.
When translating this into the context of the BPP, we obtain a pattern enumeration method. Given a feasible (but
not necessarily optimal) dual solution (pfloat , rfloat ) of value LB of the dual of the LSCT and a valid upper bound
UB, any optimal integer solution to the SC of cost less than UB cannot contain any pattern S ∈ P whose reduced
cost computed with respect to the dual solution (pfloat , rfloat ) is greater than or equal to UB-LB. Let P̃ ⊂ P be the
set of all of the patterns that can be part of a solution that improves on UB (i.e., the set of all patterns of reduced
cost strictly smaller than UB-LB). After building P̃ by enumeration, the BPP can be solved to optimality by for­
mulating as ReMP a reduced SC formulation with explicit integrality constraints featuring a variable per pattern in
P̃ and then solving it with a MILP solver. This way, any optimal solution to the reduced SC formulation is, by
construction, an optimal solution to the BPP.
In the BPP literature, a pattern enumeration method was used implicitly by Pessoa et al. (2021) when casting
the BPP as an instance of the VRP and solving it with the VRPSolver algorithm that the authors proposed. Cru­
cially, though, their method (but also those we mentioned before for the VRP) relies on a floating-point MILP
solver for solving the reduced SC formulation, and thus the optimality of the solutions it finds cannot be certified
because of the floating-point errors that can affect it.
To circumvent such a numerical issue and guarantee the construction of solutions to the reduced SC formula­
tion that are numerically exact, in our algorithm we solve the reduced SC formulation with the very same numer­
ically exact BPC method that we described before in which the pricing problem does not need to be solved.
The ReMP is built by applying the pattern enumeration method at the root node of the BPC tree after the com­
putation of the root lower bound based on Algorithm 1 and then invoking the pricing algorithm with, as input,
the final scaled integer solution (pint , rint ) of value zint to perform pattern enumeration and in which Dominance
Rule 1 is not used so as to be able to construct all of the patterns with a reduced cost within the gap UB-LB.
As a further improvement, rather than just solving the reduced SC formulation, we solve a reduced-and-
restricted SC formulation in order to find solutions of value strictly better than UB. This is motivated by the fact
that, in many instances of the BPP, it is often the case that the UB found at the root node already coincides with
the optimal solution value of the problem (this is the case, e.g., of the ANI instances). The reduced-and-restricted
SC formulation is obtained by imposing an objective cut thanks to which only solutions of value no larger than
UB � 1 are sought. This way, although any optimal solution to such a reduced-and-restricted SC formulation is
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
154 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

an optimal solution to the BPP, the infeasibility of the formulation proves that no such solution exists, thus allow­
ing us to conclude that UB is the optimal solution value of the problem.
When performing pattern enumeration in our BPC algorithm, we set the parameter ∆ of Algorithm 1 to a user-
defined parameter ∆PE whose value is dictated by the amount of memory that is available (∆PE is set to 500,000
for the experiments reported in Section 6) and restrict the size of the reduced set of patterns P̃ to | P̃ | ≤ ∆PE . If
| P̃ | is too large for the amount of memory that is available (i.e., if | P̃ | > ∆PE ), then the reduced-and-restricted SC
formulation is discarded, and we resort to branching. On the contrary, if | P̃ | < ∆PE , then the reduced-and-
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

restricted SC formulation is solved to optimality using a version of our BPC algorithm in which the pricing prob­
lem is disabled, thanks to which the BPC algorithm is turned into a branch-and-cut (BC) algorithm. This has sev­
eral advantages, among which is allowing for the separation of additional cuts such as the SR3 constraints
without impacting the complexity of the pricing algorithm.

5. Root Node Optimality Check, RF Branching Scheme, and Overall Exact Method
In this section, we introduce a fathoming procedure to be applied at the root node of the enumeration tree and
describe the branching procedures that we adopt. The section is concluded with an overview of the exact method
we use to solve the BPP.
Algorithm 2 (BCCF, Numerically Exact Algorithm for the BPP)
Input: BPP instance, K, UB
Output: optimality, UB
begin
//Initialization
1. optimality ← false; config ← BPC;
//Root node solution
2. Execute Algorithm 1 to compute the scaled integer solution (pint , rint ) of cost zdim ;
3. if ⌈zdim ⌉ ≥ UB then optimality ← true; stop;
//Pattern enumeration
4. Execute the pricing algorithm to perform pattern enumeration using the solution (pint , rint ) and let P̃ be
the resulting set of patterns;
//Turn BPC into BC if pattern enumeration is successful
5. if | P̃ | < ∆PE then config ← BC;
//Root node optimality check
6. Execute RNOC based on the value of config (BPC or BC);
7. if RNOC is successful then optimality ← true; stop;
//BPC or BC approach
8. Perform branch and cut or branch and price and cut based on the value of config (BPC or BC) using Algo­
rithm 1 at each node of the enumeration tree and adopting RF branching;
9. end
Our preliminary experiments revealed that, after solving the root node either in the BPC or in the BC algo­
rithms, the adoption of an RF branching scheme is not always very effective because (as it is known for BPP
instances) it may lead to very large enumeration trees. For this reason, before resorting to RF branching, we
apply an additional root node optimality check (RNOC) procedure. The produce aims at computing at the root
node a dual bound strong enough to prove (if this is the case) that the incumbent of value UB is optimal, because
this would allow the algorithm to terminate.
P takes as input a fractional solution ξ
RNOC to the RMP, and for each pair of items i, j ∈ N with i < j it computes
νij � ξS , which coincides with the sum of the values of the ξS variables whose pattern S ∈ P b contains
S∈P b :i, j∈S
both i and j. Starting from νij � 0 for all i, j ∈ N, the value is computed efficiently by iterating over the patterns S ∈
Pb and, for each pair of items i, j ∈ S, letting νij � νij + ξS . These values are used not only within RNOC but also for
RF branching if the former fails to prove the optimality of the instance.
The RNOC procedure operates differently based on whether the algorithm is running in the BPC or BC case.
In the BPC case, the RNOC is used to find (if any) an RF branching pair i, j ∈ N, with νij taking a fractional value
such that the dual bound that is calculated after solving the two subproblems that are obtained by branching
over such a fractional pair (which is equal to the smallest of the bounds calculated with the column-and-row-
generation procedure in each of the two child nodes) is equal to UB. Finding such a pair provides a certificate of
optimality of the current solution, allowing the BPC algorithm to terminate at the root node.
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 155

In the BC case, we use the RNOC to find (if any) an RF pair i, j ∈ N, with νij taking a fractional value leading to
two subproblems, both of which are infeasible. Thanks to the presence of the objective cut in the formulation,
finding such a pair of items guarantees that no solution of value strictly better than UB exists, thus allowing the
BC algorithm to terminate.
The RNOC procedure iterates over all of the pairs with a fractional value of νij until either it manages to prove
the optimality of the current solution or every such pair of items has been considered. In the latter case, RNOC
fails, and RF branching is applied in both the BPC and the BC algorithms by selecting a pair of items that are frac­
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

tionally covered and with νij closer to 0.5. After branching, the columns that are infeasible for the branching con­
straints are removed from the RMP.
As shown in more detail in Section 6, our experiments revealed that the RNOC procedure allows us to solve a
good fraction of instances to proven optimality.
The main steps of our exact algorithm, to which we refer as BCCF (named after the authors of this paper), are
summarized in Algorithm 2. After computing the root node solution, the algorithm performs pattern enumera­
tion and, based on whether the latter was successful or not, selects whether the pricing component should be
switched off (BC option) or not (BPC option) by setting the value of the variable config. Then, the algorithm
executes the RNOC procedure, and if the latter is not successful, the given BPP instance is solved to optimality
using the algorithm that was selected with config (either BPC or BC). In our numerical experiments, we
impose a time limit for solving the root node and for running the BPC and BC algorithms.

6. Computational Experiments
We assess in this section the computational performance of our numerically exact algorithm BCCF based on BPC
and pattern enumeration. The main goal of this computational study is assessing the role that each of the key
components of BCCF plays toward solving BPP instances to optimality in a numerically exact way. For compari­
son purposes, we contrast the computational behavior of BCCF with three state-of-art BPP algorithms from the
literature: EXM, VRPsolver, and NF-F. We remark that, differently from BCCF, none of these algorithms is
numerically exact because of either employing non-safe bounds (EXM) or resorting to an MILP solver to carry out
certain operations (VRPsolver and NF-F). The files needed to run BCCF can be downloaded from the website
https://github.com/stefanoconiglio/A-Numerically-Exact-Algorithm-for-the-Bin-Packing-Problem.

6.1. BPP Benchmark Sets

Among the many instances proposed for the BPP (an extensive description of which is provided by Delorme et al.
(2016)), in this computational study we focus on non-IRUP instances. As mentioned in Section 1, z(BPP) �
⌈z(LSC)⌉ + 1 holds on every non-IRUP instance known in the literature. Therefore, computing z(LSC) with a
column-generation method does not suffice to calculate z(BPP), and more sophisticated techniques (the genera­
tion of SR3 constraints, branching, or pattern enumeration) are needed. In particular, if ⌈z(LSC)⌉ � z(LSC) holds,
then any strictly positive bound improvement over z(LSC) suffices to calculate z(BPP).
In our study, we focus on the instances of the Augmented Non-IRUP (ANI) class (Delorme et al. 2016), which
comprises 250 instances, with a number of items n ranging from 201 to 1,002 and a capacity c ranging from 2,500
to 80,000. These instances enjoy two properties; they satisfy z(BPP) � ⌈z(LSC)⌉ + 1 with z(LSC) � ⌈z(LSC)⌉, and
for each of them, a solution whose value coincides with the optimal solution value can be found by running the
best-fit algorithm. Therefore, the challenge for this class is proving the optimality of the greedy solution.
Crucially (as indicated before), the ANI instances are particularly challenging because of numerical difficulties
that arise when solving the LSC and LSCT (see, e.g., Pessoa et al. 2021). In particular, although z(LSC) �
⌈z(LSC)⌉ � z(BPP) � 1 holds in infinite-precision arithmetic, it is very often the case that when numerically safe
calculations are carried out in floating-point arithmetic, z(LSC) < ⌈z(LSC)⌉ holds, implying that a strictly positive
bound improvement over z(LSC) may not suffice to calculate z(BPP).

6.2. Setup
We rely on two LP solvers in our implementation: Gurobi 9.5.1 (Gurobi Optimization, LLC 2022) and SoPlex
5.0.1 (Wunderling 1996, Gleixner et al. 2012, 2016). Gurobi’s LP solver is used in phase I of Algorithm 1 and in
the enumeration trees associated with the BPC and the BC approaches. SoPlex is used in phase II of Algorithm
1, and it is set to work in infinite precision. At the root node, we found it to be computationally advantageous to
set the initial value of ɛ0 to 10�6 , use Gurobi as long as ɛ > 0, and switch to SoPlex when ɛ � 0. In the enumera­
tion trees associated with the BPC and the BC approaches, phase II of Algorithm 1 is not used, and we set the
value of ɛ0 to 10�9 so that Gurobi works within its smallest optimality tolerance. The parameter ∆ of the pricing
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
156 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

algorithm used to generate negative reduced cost patterns is set to 10 (thus, no more than 10 patterns are gener­
ated per iteration). As a result of a set of preliminary experiments, we set the value of K to 244 ≃ 1013 . Section 6.6
describes how varying K impacts the algorithm’s effectiveness.
At the root note of the BPC tree, we rely on the greedy best-fit algorithm to build an approximate solution in a
very short amount of time (Dósa and Sgall 2014).
By construction, on the ANI instances the LP bound of the classical formulation
P of the BPP featuring O(n(n +
1)) binary variables (which can be computed in closed form in O(n) as 1c j∈N wj ) coincides with z(LSC) (Delorme
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

et al. 2016). Improving on this bound either by branching or by cut generation is therefore key to solving these
instances. In order to obtain a bound as strong as possible, in our experiments we separate the SR3 constraints
not only at the root note but also at every node of the BPC tree. As the computing time needed to separate the
SR3 constraints increases w.r.t. the number of items and the number of generated patterns, in our experiments
we limit their number to no more than 50.
Because, as explained before, the greedy heuristic is always able to find an optimal solution for the ANI
instances, we do not rely on any additional heuristic methods for solving them. We remark, however, that BCCF
is equipped with different heuristics, including (1) a diving heuristic based on a depth-first heuristic search in the
branch-and-price tree that relies on a limited backtracking as a diversification strategy and on a limited discrep­
ancy search method similar to those of Sadykov and Vanderbeck (2013) and Wei et al. (2020), (2) the greedy best-
fit algorithm, and (3) an LP-based heuristic by which the patterns with ξS larger than a given threshold (up to a
certain maximum cardinality) are added to the solution and the yet uncovered items are packed greedily with
the best-fit algorithm.
The experiments with BCCF are run on the IRIDIS 5.0 High Performance Computing Facility of the University
of Southampton, relying on a cluster of compute nodes equipped with dual Intel(R) Xeon(R) Gold 6130 CPUs at
2.10 GHz and 192 GB of DDR2 RAM using a single thread per experiment.1 Our source code is written in C and
C++ and compiled with gcc 11.1.0 with the -O3 optimization flag. In line with the other computational studies in
the literature, all of the experiments are run within a time limit of 3,600 seconds per instance.

6.3. Comparison with State-of-the-Art Not Numerically Exact Algorithms

For comparison purposes, we begin our analysis by contrasting BCCF with the following three state-of-the-art
BPP algorithms (none of which is numerically exact):
• EXM: BPC algorithm proposed by Wei et al. (2020), run sequentially on an Intel Xeon E5-1603 at 3.10 GHz
equipped with 8 GB of RAM. The algorithm is not numerically exact due to its relying on a non-safe Lagrangian
bound and a non-safe floating-point pricing algorithm.
• VRPsolver: BPC algorithm proposed by Pessoa et al. (2021), run in parallel with eight computations at a
time on a 2 Deca-core Ivy-Bridge Haswell Intel Xeon E5-2680 v4 server running at 2.50 GHz equipped with 128 GB
of RAM. The algorithm computes safe dual bounds during the enumeration tree based on a safe bound obtained
with a procedure similar to the one of Held et al. (2012) (whose details, though, are not given in the paper of Pessoa
et al. 2021), but it also adopts a non-safe MILP solver to solve the restricted master problem. As in the paper, no
detailed results are reported to indicate for which instances the MILP solver was used, and it is not possible to ver­
ify how many of the solutions found by VRPsolver are numerically exact.
• NF-F: algorithm based on the network-flow framework proposed by de Lima et al. (2021) to solve the integer
counterpart to a Dantzig-Wolfe decomposition via a path-flow and arc-flow model, which the authors also use to
solve BPP instances; it is run on a computer equipped with an Intel Xeon E3-1245 v5 at 3.50 GHz and 32 GB of
RAM with a single-thread limit. The algorithm computes safe dual bounds based on the scaling technique pro­
posed by Held et al. (2012), but it also uses a non-safe MILP solver as a key ingredient in the branching scheme to
fathom the left child at each level of the enumeration tree and also at each leaf node.
The results obtained on the ANI instances are reported in Table 1, aggregated by the number of items n into
five groups: ANI-201 (201 items), ANI-402 (402 items), ANI-600 (600 items), ANI-801 (801 items), and
ANI-1002 (1,002 items). Each group comprises 50 instances.
The table reports the number of instances solved by BCCF (column “opt”) by constructing an exact proof of
optimality and the average computing time in seconds (column “time [s]”). For the other algorithms, it reports
the number of instances for which each algorithm terminated with a solution that it claimed to be optimal (col­
umn “solved”) and the corresponding average computing time (column “time[s]”). In line with other works in
the BPP literature, the average time is computed across all the instances, including those for which the time limit
of 3,600 seconds is reached. In the table, “tl” indicates a method that reached the time limit for all of the instances
in a group.
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 157

Table 1. Number of Instances Solved Exactly to Optimality by

BCCF and Average Computing Time for the ANI Class
Compared with the Results Obtained with EXM, VRPsolver, and NF-F

BCCF EXM VRPSolver NF-F

Group Inst. Opt Time [s] Solved Time [s] Solved Time [s] Solved Time [s]
ANI-201 50 50 13.6 50 13.9 50 16.7 50 3.0
ANI-402 50 50 308.2 47 436.2 50 96.0 50 24.9
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

ANI-600 50 25 1,931.5 0 tl 3 3,512.5 50 140.7

ANI-801 50 3 3,352.7 0 tl 0 tl 49 393.2
ANI-1002 50 0 tl 0 tl 0 tl 43 1,302.5
Total 250 128 97 103 242

Because the computational environments in which the different algorithms were run are heterogeneous, the
solution times of the algorithms cannot be directly compared with absolute precision. Therefore, our comparison
with respect to the literature will be based on the number of instances solved exactly to optimality by BCCF and
on the number of instances for which the other algorithms terminated with a solution that they deemed to be
optimal.
It is worth noting that, in our preliminary experiments with Algorithm 1 and in line with what was reported
by Pessoa et al. (2020), we observed that, on the instances with 600 items or more and with Gurobi working
within its smallest optimality tolerance (10�9), the pricing problem finds columns with a negative reduced cost
that the LP solver does not include in the basis because of the absolute value of the reduced cost being smaller
than the optimality tolerance that the solver adopts (OptimalityTol). Therefore, the final solution obtained
by the column-and-row-generation algorithm is not dual feasible. Thus, the numerically safe bound obtained by
the scaling procedure can be rather weak. Therefore, we believe that the results of algorithms such as VRPsolver
and NF-F that employ MILP solvers relying on a finite-precision LP algorithm could be heavily affected by
numerical errors when attempting to solve these instances.
As Table 1 shows, BCCF solves 128 instances out of the 250 instances of the ANI class. The algorithm outper­
forms both EXM and VRPsolver in terms of the number of instances solved to optimality, and on the instances
with up to 402 items, it also solves the same instances solved by NF-F. For the larger instances with 600 and 801
items, BCCF largely outperforms EXM and VRPsolver by solving 25 instances with 601 items and three with
802 items, whereas these two methods combined can only solve three with 601 items and none with 802 items.
No instance with 1,002 items is solved by either BCCF, EXM, or VRPsolver. NF-F solves (albeit without a guar­
antee of numerical exactness) almost all the instances with more than 600 items. However, the solutions it pro­
duces are not certified to be optimal within an infinite precision, a property that is enjoyed by the solutions
produced by BCCF.

6.4. Analysis of the Role Played by the Different Components of our Algorithm
Tables 2–4 illustrate the impact of the different components of BCCF. In the tables, the instances are grouped as
in Table 1.
Under the heading “Phase I,” Table 2 reports the average number of columns (“cols”) and the average comput­
ing time in seconds (“time [s]”) of phase I at the root node of the enumeration tree, also factoring in the time
taken by Gurobi to solve the LP relaxations of the RMP, the time taken by the DP algorithm to generate new
columns, and the time taken to separate SR3 inequalities. Under the heading “SR3,” the table indicates how

Table 2. Impact of the Different Components of BCCF (First Part)

Phase I SR3 Phase II Pattern enumeration

Group Inst. Cols Time [s] Opt Time [s] No. Cols Time [s] No. Cols Time [s]
ANI-201 50 279.7 1.6 41 1.1 9 121.7 0.8 1 25,235.0 31.5
ANI-402 50 489.5 21.5 18 20.8 32 324.1 4.8 22 2,219.5 0.5
ANI-600 50 660.1 111.6 0 117.0 47 475.6 13.9 25 2,145.0 0.9
ANI-801 50 827.4 360.2 0 340.1 19 537.0 28.0 3 1,809.3 1.3
ANI-1002 50 1,300.5 848.6 0 775.0 18 786.7 80.1 — — —
Total 250 59 125 51
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
158 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

Table 3. Impact of the Different Components of BCCF (Second Part)

Phase I Phase II

Group Inst. Iters Time LP [s] Time DP [s] Iters Time LP [s] Time DP [s]
ANI-201 50 56.20 0.23 0.49 4.42 0.13 0.01
ANI-402 50 88.52 1.24 1.90 31.18 2.65 0.33
ANI-600 50 127.96 4.23 5.71 63.80 17.94 1.69
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

ANI-801 50 176.50 10.46 24.77 74.10 86.54 4.47

ANI-1002 50 257.72 28.87 78.74 104.96 128.34 14.01

many instances are solved to optimality thanks to the generation of SR3 cuts (“opt”) and the average time spent
by separating them (“time [s]”) throughout the entire enumeration tree. The generation of SR3 constraints is not
carried out in phase II (performed only at the root node) because extensive preliminary computational results
indicated that it was not effective.
Under the heading “Phase II,” Table 2 reports the average number of columns (“cols”), the average computing
time in seconds (“time [s]”), which factors in the time spent by SoPlex to solve the LP relaxations of the RMP
and the time taken by the DP algorithm to generate new columns, and the number of times (“#”) Algorithm 1
enters phase II.
The “Pattern enumeration” section of Table 2 reports the number of instances for which pattern enumeration
was successfully performed (i.e., the number of times the full set of columns within the gap was generated with­
out exceeding any memory limitations) (“#”), the number of patterns it generated (“cols”), and the average com­
puting time spent by the label-setting algorithm. The pattern-enumeration method runs out of memory for eight,
10, 25, 46, and 49 instances with 201, 402, 600, 801 and 1,002 items, respectively.
Overall, Table 2 shows that, although it relies on a much less efficient solver than phase I does, phase II is fairly
fast because it generates a much smaller (by about an order of magnitude) number of columns. It also shows that
the SR3 constraints are useful mostly on the smaller instances, whereas it clearly indicates that the pattern enu­
meration procedure is responsible for solving a large number of instances.
In Table 3, we report additional computational details of the two phases of BCCF collected during their execu­
tion at the root node and focus on the times spent to solve the LP relaxations of the RMP and to execute the DP
algorithm. For both phases, we report the average number of iterations (“iters”), the average time spent to solve
the LP relaxations of the RMP by Gurobi and SoPlex, and the average time spent by the DP algorithm to gen­
erate new columns.
Regarding the number of iterations, Table 3 shows that, starting from instances with 400 items, phase II
requires on average less than half the number of iterations that phase I does. The average computing time taken
by the DP algorithm per execution or iteration is 0.1 seconds for phase I and 0.04 seconds for phase II. As
expected, the average time per iteration taken by SoPlex is larger than the time taken by Gurobi. This result
can be due to two factors: (i) the larger size of the RMP when phase II starts and, as expcted, (ii) the fact that
SoPlex is used as an exact LP solver. Across all of the instances, Gurobi takes on average 0.04 seconds per iter­
ation whereas SoPlex takes 0.55 seconds per iteration, thus being almost an order of magnitude slower.
Table 4 provides details about the effectiveness of adopting the RNOC fathoming procedure within BCCF as
well as on the instances that are solved by solving the reduced SC formulation with regular RF branching opera­
tions and not at the root node thanks to RNOC. More specifically, under the heading “RNOC,” the table reports
the number of instances solved to optimality (“opt”) thanks to RNOC (for both the BPC and BC algorithms), the

Table 4. Impact of the Different Components of BCCF (Third Part)

RNOC RF branching

Group Inst. Opt Time [s] Pairs Branches Opt Nodes Time [s]
ANI-201 50 8 16.8 405.4 44.3 1 40.0 54.7
ANI-402 50 25 232.2 207.2 53.6 7 5,788.0 1,484.4
ANI-600 50 25 1,386.9 83.8 12.7 0
ANI-801 50 3 2,852.7 76.3 11.3 0
ANI-1002 50 — 2,556.1 0
Total 250 61 8
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 159

average number of (fractional) pairs of item contained in the instance at the root node (“pair”), and the average
number of fractional pairs that RNOC considers before either managing to prove the optimality of the incumbent
or failing to do so (thereby considering all the pairs), after which RF branching is started. The RNOC procedure
is applied either at the root node of the BC algorithm used for solving the reduced SC formulation obtained after
applying the pattern enumeration method or at the root node of the BPC algorithm that is run whenever the pat­
tern enumeration procedure fails to build the reduced SC formulation because of memory limitations. Under the
heading “RF branching,” the table reports the number of instances solved to optimality by either the BC or the
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

BPC algorithm with RF branching (“opt”) beyond the root node (i.e., when the RNOC procedure is unsuccess­
ful), the number of nodes (“nodes”), and the computing time (“time [s]”).
Our results indicate that the average number of fractional pairs present in the optimal LP solution of the root
node, although substantial, decreases w.r.t. the number of items and that the actual number of pairs explored by
RNOC when successful is much smaller, ranging from one-fourth to one-tenth of the total number of pairs. Table
4 clearly shows that, although the time RNOC takes can be substantial (taking from 50% to 75% of the overall
computing time on the ANI-600, ANI-801, and ANI-1002 instances), RNOC is very effective because it is respon­
sible for solving 61 instances out of the 128 that BCCF solves to optimality. It also shows that, if RNOC fails, RF
branching is still useful because it is responsible for solving eight instances.
Relying on Tables 2–4, we now analyze the results obtained by BCCF on each individual group of instances.
• ANI-201: BCCF solves 41 of the 50 instances with 201 items at the root node thanks to the separation of the
SR3 inequalities. For all such instances, z(LSCT) takes values between 65.0000007774641 and 65.0000276484105
(with a value of K ≃ 1013 ). Because, with infinite precision, we have z(LSC) � 65 and z(BPP) � 66, such an improve­
ment suffices to prove the optimality of the greedy solution on each of these 41 instances. A total of eight instances
are solved at the root node of either the BC or the BPC tree by RNOC, whereas one instance is solved in 54.7 sec­
onds thanks to RF branching.
• ANI-402: BCCF manages to solve 18 instances with 402 items at the root node thanks to the separation of SR3
inequalities. The pattern enumeration procedure runs successfully on 22 instances. A total of 25 instances are
solved by RNOC, and seven instances are solved by RF branching outside of the root node.
• ANI-600: BCCF solves 25 of the 50 instances with 600 items, all of which are thanks to the pattern enumera­
tion procedure and the RNOC procedure applied at the root node of the BC algorithm.
• ANI-801: BCCF solves three instances of the 50 instances with 801 items, namely, 801_40000_NR_0,
801_40000_NR_11, and 801_40000_NR_27, all of which are thanks to the pattern enumeration and the
RNOC procedure. On them, the pattern enumeration procedure takes less than two seconds, generating approxi­
matively 1,800 columns per instance. For all of these instances, the RNOC procedure proves the infeasibility of the
reduced SC formulation in 2,852 seconds on average without branching.

6.5. Ablative Study of the Effectiveness of the Main Components of our Algorithm
The effectiveness of the main components of BCCF is summarized in Table 5. The results are obtained with three
variants of BCCF where one of the following components is disabled: separation of SR3 cuts (“No SR3”), RNOC
fathoming procedure (“No RNOC”), or pattern enumeration (“No Patt. Enum.”).
The table shows that each component helps to improve the performance of BCCF. In particular, it shows that
the pattern enumeration method combined with the computation of extended-precision safe dual bounds plays
the most important role because it allows for solving 34 more instances than the version of BCCF in which such a
feature is disabled. In particular, this feature is responsible for solving all 25 instances with 600 items that the full
version of BCCF manages to solve. It also shows that SR3 constraints and RNOC play an important albeit smaller

Table 5. Summary of the Performance of Different Versions of BCCF

BCCF No SR3 No RNOC No Patt. Enum.

Group Inst. Opt Time [s] Opt Time [s] Opt Time [s] Opt Time [s]
ANI-201 50 50 13.6 50 112.3 50 16.5 50 7.7
ANI-402 50 50 308.2 45 494.2 47 427.0 44 695.3
ANI-600 50 25 1,931.5 25 1,851.5 19 2,347.7 0 tl
ANI-801 50 3 3,352.7 3 3,392.4 3 3,358.7 0 tl
ANI-1002 50 0 tl 0 tl 0 tl 0 tl
Total 128 123 119 94
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
160 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

role because five fewer instances are solved when the SR3 constraints are not separated, and nine fewer instances
are solved when RNOC is disabled.

6.6. Analysis of the Impact of the Scaling Factor K

In this section, we describe how the scaling factor K can be determined. We also analyze the impact of varying K
on the numerical precision of the dual bounds calculated within BCCF (see Proposition 2) and its impact on the
effectiveness of the main components of the algorithm.
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

Let Imin < 0 and Imax > 0 be the minimum and maximum integer values, respectively, that can be represented
by the data type used for storing integer values. Standard implementations (including ours) rely on 64-bit signed
integers, for which Imin � �9, 223, 372, 036, 854, 775, 808 and Imax � 9, 223, 372, 036, 854, 775, 807 (inclusive). For an
error-free computation of the scaled integer reduced cost c S (pint , rint , K), we need to ensure
X X
Imin ≤ πint
j + ρint
T ≤ Imax :
j∈S T∈T(S)

For this to hold, we must guarantee that the largest scaled integer reduced cost value that can be computed be
less than or equal to Imax and that the smallest value be greater than or equal to Imin . Because pint ≥ 0 and rint ≤ 0,
we can restrict ourselves to the following sufficient condition:
X X
πint
j ≤ Imax and ρint
T ≥ Imin :
j∈S T∈T(S)

Let pb and qb be two upper bounds on, respectively, the number of super-items and the number of SR3 inequalities
associated with the RMP (i.e., pb ≥ n and qb ≥ | T̄ |) and assume (pfloat , | rfloat | ) ∈ [0, 1]n × [0, 1] | T̄ | (we observed that
this is always the case in our numerical experiments).
By construction, this implies that no entry of (pint , rint ) is larger (in absolute value) than K. To avoid integer
overflows during the solution of the pricing problem, K must therefore be chosen in such a way that the follow­
ing holds:
� �
Imax Imin
K ≤ min ,� :
pb qb
The occurrence of integer overflows is explicitly checked in our code. In case of their occurrence, the algorithm is
terminated without returning a solution. In our experiments, such a case was never witnessed.
The impact of varying the scaling factor K on the performance of BCCF is reported in Table 6. The table reports
the number of instances solved to optimality (“opt”) as a function of the value of the precision parameter K. It
also focuses on the pattern enumeration method, indicating the number of instances for which the method was
run successfully without exceeding the memory limitations (“#”) and the average number of patterns (“cols”)
and labels (“labels”) that it generates for different values of the scaling factor K.
Table 6 clearly shows the positive impact of increasing K. With the largest K, BCCF solves 36 more instances
than with the smallest K. With a higher K, improved dual bounds can be computed, and the pattern enumeration
procedure, whose effectiveness relies on the value of the restricted gap, becomes more effective. This is testified
by the average number of patterns that are generated when varying the value of K.
It must be noted, though, that the performance in terms of number of labels generated by the DP algorithm
used to enumerate the patterns depends not only on the restricted gap but also on the values of the dual vari­
ables associated with the dual bound. In practice, we observe that the distribution of the dual variables strongly
affects the number of labels generated by the DP algorithm and that enumerating patterns based on a smaller
restricted gap do not necessarily result in a smaller number of DP labels. Moreover, we observe that SoPlex
may suffer from numerical instabilities with higher values of K, leading to an abnormal termination of phase II
(this happens when, after building an “optimal” floating-point solution, SoPlex tries to build an optimal

Table 6. Impact of Varying the Scaling Factor K

Pattern enumeration
Phase II
K Opt Time [s] No. Time [s] Cols Labels
44 13
2 ≃ 10 128 12.3 51 1.3 2,610.1 321,763.8
237 ≃ 1011 123 11.8 50 6.0 32,495.8 1,023,669.1
230 ≃ 1009 92 5.4 16 12.4 116,741.4 2,656,733.9
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS 161

rational one by a rational implementation of the simplex method in which the floating-point solution is used to
provide a starting basic solution). For these reasons, in our experiments, a few instances that are solved with a
lower value of K cannot be solved with a larger value.
Overall, Table 6 illustrates how crucial the calculation of (safe) dual bounds with a precision (1013) higher than
what commercial solvers allow for (109) is in validating the relevance of the two-phase column-and-row genera­
tion method we proposed.
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

6.7. Optimal Rational Solutions to the FBPP

As a byproduct of our work, we computed the first (to our knowledge) optimal rational dual solutions to the LP
relaxation of the SC formulation of the BPP (the FBPP) for 189 instances of the ANI class.
The solutions are certified to be exact by a rational implementation of the pricing algorithm (in its lookup-table
version, which suffices for solving the pricing problem when no SR3 constraints have been generated and no
branching operations have taken place). Such a version, although computationally inefficient due to operating in
rational arithmetic, allows for manipulating the dual variables with no restrictions on their precision (i.e., with
K � ∞). As such, whenever an optimal dual solution is given as input to the algorithm, the latter can certify its
optimality with infinite precision.
The solutions can be found at https://github.com/stefanoconiglio/A-Numerically-Exact-Algorithm-for-the-
Bin-Packing-Problem. The repository contains solutions to 50/50 instances with 201 items, 50/50 instances with
402 items, 50/50 instances with 600 items, 24/50 instances with 801 items, and 15/50 instances with 1,002 items.

7. Conclusions
We proposed the first numerically exact algorithm for the bin-packing problem (BPP). Key to the method is the
calculation of extended-precision, numerically safe dual bounds with a two-phase column-and-row generation
method based on a dual-variable scaling technique that combines a floating-point (finite precision) linear pro­
gramming solver with a rational (infinite precision) one. To the best of our knowledge, rational solvers had never
been successfully used before in the context of a column-generation method. The method relies on a suitably
designed exact integer (fixed-point) pricing algorithm that is designed to also perform pattern enumeration, that
is, to build a reduced master (set-covering) problem containing a superset of the columns (patterns) that are fea­
tured in an optimal integer solution to the BPP.
Our numerically exact algorithm was tested on the class of Augmented Non-IRUP (ANI) instances (which are
affected by notorious numerical difficulties) and its performance compared with state-of-the-art not numerically
exact algorithms for the BPP. The results we obtained show that our exact algorithm solves more instances than
the state-of-the-art, not numerically exact algorithms based on branch-and-cut-and-price that rely on a set-
covering formulation of the BPP. Thanks to the extended precision in which our algorithm works, all of the solu­
tions it produces on the instances we tested are certified to be optimal within an infinite precision, a property
that is not enjoyed by the solutions produced by the other algorithms.
The framework we introduced with our algorithm can be of interest for the design of numerically exact algo­
rithms of a similar nature to solve a large array of combinatorial optimization problems that are typically tackled
via branch-price-and-cut techniques that feature a set covering/partitioning problem as the master problem.
Among many interesting possibilities, future works include the design of a family of modified master pro­
blems designed to generate a set of dual variables with a distribution that is conducive to generating a small
number of patterns within the pattern-enumeration method, possibly at the cost of worsening the dual bound by
a small additive term.
Acknowledgments
The authors thank the anonymous reviewers for their helpful suggestions and very thorough review of the paper. The
authors are also thankful to the University of Southampton and, in particular, to the School of Mathematical Sciences and
the Operational Research Group for kindly allowing them to use the university’s high-performance computing facilities.

Endnote
1
See https://en.wikichip.org/wiki/intel/xeon_gold/6130.

References
Applegate DL, Cook W, Dash S, Espinoza DG (2007) Exact solutions to linear programming problems. Oper. Res. Lett. 35(6):693–699.
Baldacci R, Christofides N, Mingozzi A (2008) An exact algorithm for the vehicle routing problem based on the set partitioning formulation
with additional cuts. Math. Program. 115:351–385.
 Baldacci et al.: A Numerically Exact Algorithm for the Bin-Packing Problem
162 INFORMS Journal on Computing, 2024, vol. 36, no. 1, pp. 141–162, © 2023 INFORMS

Belov G, Scheithauer G (2006) A branch-and-cut-and-price algorithm for one-dimensional stock cutting and two-dimensional two-stage cut­
ting. European J. Oper. Res. 171(1):85–106.
Caprara A, Dell’Amico M, Dı́az-Dı́az JC, Iori M, Rizzi R (2015) Friendly bin packing instances without integer round-up property. Math. Pro­
gramming 150(1):5–17.
Coniglio S, D’Andreagiovanni F, Furini F (2019) A lexicographic pricer for the fractional bin packing problem. Oper. Res. Lett. 47(6):622–628.
Contardo C, Martinelli R (2014) A new exact algorithm for the multi-depot vehicle routing problem under capacity and route length con­
straints. Discrete Optim. 12:129–146.
Cook W, Dash S, Fukasawa R, Goycoolea M (2009) Numerically safe Gomory mixed-integer cuts. INFORMS J. Comput. 21(4):641–649.
Cook W, Koch T, Steffy D, Wolter K (2011) An Exact Rational Mixed-Integer Programming Solver, Lecture Notes in Computer Science, vol. 6655
Downloaded from informs.org by [39.47.30.251] on 06 January 2025, at 05:30 . For personal use only, all rights reserved.

(Springer, New York).

Cook W, Koch T, Steffy DE, Wolter K (2013) A hybrid branch-and-bound approach for exact rational mixed-integer programming. Math. Pro­
gramming Comput. 5(3):305–344.
Cornuéjols G, Margot F, Nannicini G (2013) On the safety of Gomory cut generators. Math. Programming Comput. 5(4):345–395.
Dantzig G, Fulkerson R, Johnson S (1954) Solution of a large-scale traveling-salesman problem. J. Oper. Res. Soc. Amer. 2(4):393–410.
de Lima VL, Iori M, Miyazawa FK (2021) New exact techniques applied to a class of network flow formulations. Singh M, Williamson DP,
eds. Integer Programming and Combinatorial Optimization (Springer International Publishing, Cham, Switzerland), 178–192.
de Lima VL, Iori M, Miyazawa FK (2022) Exact solution of network flow models with strong relaxations. Math. Programming 197(2):813–846.
Delorme M, Iori M, Martello S (2016) Bin packing and cutting stock problems: Mathematical models and exact algorithms. European J. Oper.
Res. 255(1):1–20.
Dósa G, Sgall J (2014) Optimal analysis of best fit bin packing. International Colloquium on Automata, Languages, and Programming (Springer,
New York), 429–441.
Eifler L, Gleixner A (2022) A computational status update for exact rational mixed integer programming. Math. Programming 197(2):793–812.
Eisenbrand F, Pálvölgyi D, Rothvoß T (2013) Bin packing via discrepancy of permutations. ACM Trans. Algorithms 9(3):1–15.
Farley AA (1990) A note on bounding a class of linear programming problems, including cutting stock problems. Oper. Res. 38(5):922–923.
Fukasawa R, Goycoolea M (2011) On the exact separation of mixed integer knapsack cuts. Math. Programming 128(1):19–41.
Fukasawa R, Poirrier L (2017) Numerically safe lower bounds for the capacitated vehicle routing problem. INFORMS J. Comput. 29(3):544–557.
Gilmore PC, Gomory RE (1961) A linear programming approach to the cutting-stock problem. Oper. Res. 9(6):849–859.
Gleixner AM, Steffy DE, Wolter K (2012) Improving the accuracy of linear programming solvers with iterative refinement. Proc. 37th Internat.
Sympos. Symbolic and Algebraic Computation (ACM, New York), 187–194.
Gleixner AM, Steffy DE, Wolter K (2016) Iterative refinement for linear programming. INFORMS J. Comput. 28(3):449–464.
Gurobi Optimization LLC (2022) Gurobi Optimizer Reference Manual. https://www.gurobi.com.
Held S, Cook WJ, Sewell EC (2012) Maximum-weight stable sets and safe lower bounds for graph coloring. Math. Programming Comput.
4(4):363–381.
Jepsen M, Petersen B, Spoorendonk S, Pisinger D (2008) Subset-row inequalities applied to the vehicle-routing problem with time windows.
Oper. Res. 56(2):497–511.
Karmarkar N, Karp RM (1982) An efficient approximation scheme for the one-dimensional bin-packing problem. 23rd Annual Symposium on
Foundations of Computer Science (SFCS 1982), 312–320.
Kartak VM, Ripatti AV, Scheithauer G, Kurz S (2015) Minimal proper non-IRUP instances of the one-dimensional cutting stock problem. Dis­
crete Appl. Math. 187:120–129.
Lübbecke M, Desrosiers J (2005) Selected topics in column generation. Oper. Res. 53(6):1007–1023.
Martello S, Toth P (1990) Knapsack Problems: Algorithms and Computer Implementations (John Wiley & Sons, New York).
Neumaier A, Shcherbina O (2004) Safe bounds in linear and mixed-integer linear programming. Math. Programming 99(2):283–296.
Pessoa A, Sadykov R, Uchoa E (2021) Solving bin packing problems using VRPSolver models, SN Operations Research Forum 2, 20.
Pessoa AA, Sadykov R, Uchoa E, Vanderbeck F (2020) A generic exact solver for vehicle routing and related problems. Math. Programming
183(1):483–523.
Ryan D, Foster B (1981) An integer programming approach to scheduling. Wren A, ed. Computer Scheduling of Public Transport: Urban Passen­
ger Vehicle and Crew Scheduling (North-Holland, Amsterdam).
Sadykov R, Vanderbeck F (2013) Bin packing with conflicts: A generic branch-and-price algorithm. INFORMS J. Comput. 25(2):244–255.
Scheithauer G, Terno J (1997) Theoretical investigations on the modified integer round-up property for the one-dimensional cutting stock
problem. Oper. Res. Lett. 20(2):93–100.
Steffy DE, Wolter K (2012) Valid linear programming bounds for exact mixed-integer programming. INFORMS J. Comput. 25(2):271–284.
Vance PH, Barnhart C, Johnson EL, Nemhauser GL (1994) Solving binary cutting stock problems by column generation and branch-and-
bound. Comput. Optim. Appl. 3(2):111–130.
Wei L, Luo Z, Baldacci R, Lim A (2020) A new branch-and-price-and-cut algorithm for one-dimensional bin-packing problems. INFORMS J.
Comput. 32(2):428–443.
Wunderling R (1996) Paralleler und Objektorientierter Simplex-Algorithmus, PhD thesis, Technische Universität Berlin, Berlin.