## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

**Vol. 59, No. 4, July–August 2011, pp. 973–985
**

issn0030-364X eissn1526-5463 11 5904 0973

http://dx.doi.org/10.1287/opre.1110.0944

©2011 INFORMS

Robust Optimization Made Easy with ROME

Joel Goh

Stanford Graduate School of Business; NUS Business School, National University of Singapore,

Singapore 119245, Republic of Singapore, joelgoh@stanford.edu

Melvyn Sim

NUS Business School and NUS Risk Management Institute, National University of Singapore,

Singapore 119245, Republic of Singapore, dscsimm@nus.edu.sg

We introduce ROME, an algebraic modeling toolbox for a class of robust optimization problems. ROME serves as an

intermediate layer between the modeler and optimization solver engines, allowing modelers to express robust optimization

problems in a mathematically meaningful way. In this paper, we discuss how ROME can be used to model (1) a service-

constrained robust inventory management problem, (2) a project-crashing problem, and (3) a robust portfolio optimization

problem. Through these modeling examples, we highlight the key features of ROME that allow it to expedite the modeling

and subsequent numerical analysis of robust optimization problems. ROME is freely distributed for academic use at

http://www.robustopt.com.

Subject classiﬁcations: robust optimization; algebraic modeling toolbox; MATLAB; stochastic programming; decision

rules; inventory control; PERT; project management; portfolio optimization.

Area of review: Computing and Information Technologies.

History: Received July 2009; revision received April 2010; accepted August 2010.

1. Introduction

Robust optimization is an approach for modeling optimiza-

tion problems under uncertainty, where the modeler aims

to ﬁnd decisions that are optimal for the worst-case realiza-

tion of the uncertainties within a given set. Typically, the

original uncertain optimization problem is converted into

an equivalent deterministic form (called the robust counter-

part) using strong duality arguments and then solved using

standard optimization algorithms. Soyster (1973), Ben-Tal

and Nemirovski (1998), and Bertsimas and Sim (2004)

describe how to explicitly construct these robust counter-

parts for uncertainty sets of various structures. A signiﬁcant

extension on the scope of robust optimization was made by

Ben-Tal et al. (2004), who considered the problem of robust

decision making in a dynamic environment where uncer-

tainties are progressively revealed. They described how

adjustable robust counterparts (ARCs) can be used to model

recourse decisions, which are decisions made after some

or all of the uncertainties are realized. In the latter part of

the same paper, they also specialized the ARC to afﬁnely

adjustable robust counterparts (also termed linear decision

rules, LDRs), where decision variables are afﬁne functions

of the uncertainties, and showed that solving for such deci-

sion rules under the worst-case realization of uncertainties

is typically computationally tractable.

Classical robust optimization problems are technically a

special case of minimax stochastic programs, the study of

which was pioneered by Žáˇ cková (1966) and subsequently

furthered in other works such as Breton and El Hachem

(1995), Delage and Ye (2010), Dupaˇ cová (1987), Shapiro

and Ahmed (2004), and Shapiro and Kleywegt (2002). In

this setting, uncertainties are modeled as having a distribu-

tion that is not fully characterized, known only to lie in a

family of distributions. Optimal decisions are then sought

for the worst-case distribution within the family. Solutions

are therefore distributionally robust toward ambiguity in the

uncertainty distribution. Distributional families are typically

deﬁned by classical properties such as moments or support,

or more recently introduced distributional properties such as

directional deviations (Chen et al. 2007). Frequent choices

of families of distributions used by researchers are listed in

Dupaˇ cová (2001). Throughout this paper, the term “robust

optimization problem” will be used to refer to a problem in

this generalized distributionally robust setting.

A recent body of research in robust optimization focuses

on adapting the methodology of Ben-Tal et al. (2004) to

obtain suboptimal, but ultimately tractable, approximations

of solutions to such problems by restricting the structure of

recourse decisions to simple ones, such as LDRs. A com-

mon theme in this body of work is a search for techniques

to relax the stringent afﬁne requirement on the recourse

decisions to allow for more ﬂexible, but tractable, deci-

sion rules. Such approaches include the deﬂected and seg-

regated LDRs of Chen et al. (2008), the extended AARC

of Chen and Zhang (2009), the truncated LDR of See and

Sim (2009), and the bideﬂected and (generalized) segre-

gated LDRs of Goh and Sim (2010).

Despite these recent advances in robust optimization the-

ory and techniques, there has been a conspicuous lack of

accompanying technology to aid the transition from theory

973

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

974 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

to practice. Furthermore, as we will illustrate in §2, this

problem is compounded by the fact that the deterministic

forms of many robust optimization models are exceedingly

complex and tedious to model explicitly. We believe that

the development of such technology will ﬁrstly enable

robust optimization models to be applied practically, and

secondly, allow for more extensive computational tests on

theoretical robust optimization models.

We aim to contribute toward the development of such a

technology by introducing an algebraic modeling toolbox

1

for modeling robust optimization problems, named Robust

Optimization Made Easy (ROME), which runs in the MAT-

LAB environment. This paper covers the public release

version of ROME, version 1.0 (beta) and its subversions.

Using ROME, we can readily model and solve a variety of

robust optimization problems. In particular, ROME allows

users to use and manipulate decision rules such as LDRs,

as well as LDR-based decision rules such as bideﬂected or

segregated LDRs within their robust optimization models

with relative ease. Section 5 describes the general class of

problems that ROME is designed to solve, and readers are

referred to Goh and Sim (2010) for a deeper discussion of

the general problem and its theoretical properties.

A related problem class to the generic robust optimiza-

tion problem handled in ROME is the class of multistage

stochastic recourse programs (MSRPs). Both problem

classes involve a progressive revelation of information, and

decision making that depends on the revealed information.

A common technique used to model an MSRP is the use

of scenario trees to exhaustively represent its probabilis-

tic outcomes, and recent work (e.g., by Fourer and Lopes

2009, Kaut et al. 2008, Valente et al. 2009) has focused

on developing modeling tools to enhance existing algebraic

modeling languages with the capability of processing and

manipulating such scenario trees. In contrast, ROME does

not employ scenario generation, but instead uses robust opti-

mization theory to convert uncertain optimization models

(input by a user) into their robust counterparts, which are

then passed to numerical solver packages. In this regard,

ROME parallels the functionality of the deterministic equiv-

alent generator in the management system for stochastic

decompositions described by Fourer and Lopes (2006).

ROME’s core functionality involves translating mod-

eling code, input by the user, into an internal struc-

ture in ROME, which is then marshaled into a solver-

speciﬁc input format for solving. At present, users have a

choice of the following solvers in ROME: ILOG CPLEX

(IBM 2011), MOSEK (MOSEK ApS 2011), and SDPT3

(Toh et al. 1999). ROME calls both MOSEK and SDPT3

solvers through their prepackaged MATLAB interfaces,

and CPLEX through the CPLEXINT interface (Baotic and

Kvasnica 2006). By design, ROME’s core functionality is

essentially independent from the choice of solver used,

allowing users to use whichever solver they are most famil-

iar with, using the same modeling code in ROME. Due to

the internal conversions performed by ROME, for a solver

to be compatible with ROME, it has to at least be able to

solve second-order conic programs (SOCPs).

Because ROME is built in the MATLAB environment,

modelers are able to take advantage of the strength of MAT-

LAB’s numerical computational framework to prepare data,

analyze optimization results, and integrate ROME more

easily into their applications. Moreover, ROME is designed

using similar syntax and constructs as those of MATLAB,

so that users already familiar with MATLAB have a shal-

low learning curve in using ROME. The trade-off is that

ROME’s restriction to the MATLAB environment limits its

ﬂexibility in model building and expression, and lacks the

versatility of specialized algebraic modeling languages such

as AMPL (Fourer et al. 1990, 2002) or GAMS (Brooke

et al. 1997).

ROME is similar to other MATLAB-based algebraic

modeling toolboxes for optimization, such as YALMIP

(Löfberg 2004, 2008), CVX (Grant and Boyd 2008, 2011),

or TOMLAB (Holmström 1999), in that it aims to serve

as an intermediate layer between the modeler and underly-

ing numerical solvers. Our design goal with ROME is also

similar: we aim to make the models in ROME as natural

and intuitive as their algebraic formulations. A fundamen-

tal distinction between ROME and these other toolboxes is

that robust optimization models typically cannot be directly

modeled in these other toolboxes, with the notable excep-

tion of YALMIP, which allows users to model robust coun-

terparts through uncertainty sets. In this respect, ROME’s

key distinction with YALMIP lies in ROME’s compara-

tively richer modeling of uncertainties, not just through

their support, but also through other distributional proper-

ties such as moments and directional deviations. In addi-

tion, decision rules are modeled in ROME very naturally,

and ROME even incorporates more complex piecewise-

linear decision rules based on the bideﬂected linear decision

rule (Goh and Sim 2010). The trade-off is that, compared

to these other toolboxes, ROME is narrower in scope in

terms of the different types of deterministic optimization

problems that it can model.

In this paper, we discuss several detailed modeling exam-

ples of robust optimization problems and describe how

these problems have a natural representation in ROME.

Through these examples, we demonstrate key features that

make ROME amenable to modeling such problems. The

User’s Guide to ROME (Goh and Sim 2009) contains a

comprehensive description of ROME’s functionality and

usage, as well as installation instructions. An electronic

companion to this paper is available as part of the online

version that can be found at http://or.journal.informs.org/.

Notations. We denote a random variable by the tilde

sign, i.e., ˜ x. Bold lower-case letters such as x represent vec-

tors, and the upper-case letters such as A denote matrices.

In addition, x

+

≡ max]x, 0] and x

−

≡ max]−x, 0]. The

same notation can be used on vectors, such as y

+

and z

−

,

indicating that the corresponding operations are performed

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 975

componentwise. Also, we will denote by |N] the set of

positive running indices to N, i.e., |N] = ]1, 2, . . . , N],

for some positive integer N. For completeness, we assume

|0] =∅. We also denote with a superscripted letter “c” the

complement of a set, e.g., I

c

. We denote by e the vector

of all ones, and by e

i

the ith standard basis vector. Matrix/

vector transposes are denoted by the prime (

) symbol,

e.g., x

**y denotes the inner product between two column
**

vectors x and y. The expectation of a random variable ˜ z

with distribution is denoted E

**(˜ z) and its covariance
**

matrix Cov

**(˜ z). Finally, if ˜ z has a distribution , known
**

only to reside in some family , we adopt the convention

that (in)equalities involving ˜ z hold almost surely for all

∈ , i.e., for some constant vector c, ˜ z c ⇔(˜ z c) =

1 ∀ ∈ .

2. Motivation

The motivation for our work can be illustrated by a simple

example. Consider the following simple robust optimization

problem, an uncertain linear program (LP), with decision

variables x and ,, and a scalar uncertainty ˜ z:

max

x, ,

x +2,

s.t. ˜ zx +, 1

x, , 0,

(1)

where the only distributional information we have about the

scalar uncertainty ˜ z is that ˜ z ∈ |−1, 1] almost surely. This

may be interpreted as an LP with some uncertainty in a

coefﬁcient of its constraint matrix. To solve this problem

numerically, we have to convert it into its robust counterpart,

max

r, s, x, ,

x +2,

s.t. r +s +, 1

r −s −x =0

r, s, x, , 0,

(2)

and solve it by standard numerical solvers.

For most readers, the equivalence between (1) and (2)

should not be immediately evident from the algebraic for-

mulations. Indeed, converting from (1) to (2) requires refor-

mulating the uncertain constraint of the original problem

into an embedded LP, and invoking a strong duality argu-

ment (Ben-Tal and Nemirovski 1998, Bertsimas and Sim

2004). Furthermore, (2) has the added auxiliary variables r

and s, which obscures the simplicity and interpretation of

the original model (1).

This simple example exempliﬁes the problem of using

existing deterministic algebraic modeling languages for

robust optimization. To solve a robust optimization problem,

the modeler has to convert the original uncertain optimiza-

tion problem into its deterministic equivalent, which may

be structurally very different from the original problem and

have many unnecessary variables. Furthermore, for more

complex problems, e.g., models that involve recourse, the

conversion involves signiﬁcantly more tedium, and tends to

impede, rather than promote, intuition about the model.

For us, a key design goal in ROME was to build a mod-

eling toolbox where robust optimization problems such as

(1) can be modeled directly, without the modeler having to

manually perform the tedious and error-prone conversion

into its deterministic equivalent (2). This and other related

mechanical conversions are performed internally within the

ROME system to allow the modeler to focus on the core

task of modeling a given problem.

3. Nonanticipative Decision Rules

A distinctive feature in ROME is the use of decision rules

to model recourse decisions. In this section, we describe

general properties of decision rules and the concept of

nonanticipativity. We also introduce linear decision rules,

which are fundamental building blocks in ROME.

We consider decision making in a dynamic system evolv-

ing in discrete time, where uncertainties are progressively

revealed, and decisions, which may affect both system

dynamics and a systemwide objective, are also made at

ﬁxed time epochs. At a given decision epoch, a decision

rule is a prescription of an action, given the full history of

the system’s evolution until the current time. Any meaning-

ful decision rule in practice should therefore be functionally

dependent only the uncertainties that have been revealed by

the current time. Such decision rules are said to be adapted

or non-anticipative.

Assuming throughout this section that we have N model

uncertainties, we may formally let I ⊆ |N] represent the

index set of the uncertainties that are revealed by the cur-

rent time, which we will term an information index set.

A generic

m

-valued nonanticipative decision rule belongs

to the set

(m, N, I)

≡

_

f:

N

→

m

: f

_

z +

_

iI

\

i

e

i

_

=f(z), ∀\ ∈

N

_

, (3)

where the ﬁrst two parameters of ( · ) are dimensional

parameters, and the last parameter I captures the functional

dependence on the revealed uncertainties.

However, searching for a decision rule in ( · ) requires

searching over a space of functions, which, in general,

is computationally difﬁcult. The approach taken by recent

works (Ben-Tal et al. 2006, 2004; Chen and Zhang 2009;

Goh and Sim 2010) has been to restrict the search space

to linear decision rules (LDRs), functions that are afﬁne in

the uncertainties. The LDRs are also required to satisfy the

same nonanticipative requirements. Formally, a

m

-valued

LDR belongs to the set

(m, N, I)

≡

_

f:

N

→

m

: ∃y

0

∈

m

, Y∈

m×N

: f(z) =y

0

+Yz,

Ye

i

=0, ∀i ∈ I

c

_

. (4)

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

976 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

Observe that by construction, (m, N, I) ⊂ (m, N, I).

A generic

m

-valued LDR x(˜ z) can be represented in closed

form as x(˜ z) = x

0

+X˜ z, where x

0

∈

m

, X ∈

m×N

. If, in

addition, x(˜ z) has information index set I, then the columns

of X with indices in the set I

c

must be constrained to be all

zeros. The LDR coefﬁcients x

0

, X correspond to decision

variables in standard mathematical programming, which are

the actual quantities that are optimized in a given model.

Intuitively, one might expect that by restricting deci-

sion rules to LDRs, the modeler may suffer a penalty on

the optimization objective. For a class of multistage robust

optimization problems, Bertsimas et al. (2010) show that

LDRs are, in fact, sufﬁcient for optimality. However, in

general, LDRs can be further improved upon. For exam-

ple, Chen et al. (2008) proposed different piecewise-linear

decision rules to overcome the restrictiveness imposed by

LDRs. This approach was later generalized by Goh and

Sim (2010) to bideﬂected linear decision rules (BDLDRs).

These works showed that by searching over a larger space

(of piecewise-linear functions), and paying a (typically)

minor computational cost, the modeler can potentially

improve the quality of the decision rule.

Although a detailed discussion of the theory of BDLDRs

is beyond the scope of this paper (an in-depth analysis is

provided in Goh and Sim 2010), we will highlight the key

principles involved in their construction and usage, because

BDLDRs are central to ROME’s design and functionality.

A generic

m

-valued BDLDR ˆ x(˜ z) may be expressed as

ˆ x(˜ z) = w

0

+ W˜ z + P

_

y

0

+Y˜ z

_

−

, and comprises a linear

part, w

0

+ W˜ z, and deﬂected part, P

_

y

0

+Y˜ z

_

−

. Similar

to the LDR, w

0

∈

m

and W ∈ R

m×N

are decision vari-

ables in the model. However, P ∈

m×M

is a constant coef-

ﬁcient matrix, that is constructed on the ﬂy, based on the

structure of the model constraints and objective. In turn,

its inner dimension, M, is also dependent on the problem

structure. The construction of P involves solving a series

of secondary linear optimization problems based on the

problem structure (details are given in Goh and Sim 2010).

Finally, y

0

∈

M

and Y∈

M×N

are also decision variables

that are solved for in the model. Notice that if I represents

the information index set of ˆ x(˜ z), the resulting decision

variables (w

0

, W, y

0

, Y) must also obey similar structural

constraints as the LDR. However, in the BDLDR case, we

have an additional layer of complexity, where the algorithm

that constructs P is also dependent on the structure of I.

The beneﬁt of using BDLDRs, (as compared to LDRs),

to model decision rules is twofold. First, the feasible region

is enlarged by searching over a larger space of piecewise-

linear decision rules. Second, when worst-case expectations

are taken over the BDLDR, distributional information on

˜ z leads to good bounds on the nonlinear deﬂected compo-

nent, which improves the optimization objective. The cost

of using BDLDRs is an added computational cost of solv-

ing the secondary linear programs, which is typically quite

minor, and a possible increase in complexity of the ﬁnal

deterministic equivalent (from an LP to a SOCP) when con-

structing bounds on the nonlinear terms.

For a given LDR, although the decision variables from

a numerical solver’s perspective are x

0

and X, the object

that is meaningful from a modeling perspective is the afﬁne

function x(˜ z). In a modeling system catering to robust opti-

mization applications, users should be able to work directly

with x(˜ z) and essentially ignore its internal representation.

For BDLDRs, the case is even stronger. The onerous task

of analyzing the problem structure, solving the secondary

linear programs, and constructing the appropriate bounds,

should be handled internally by the modeling system, and

not by the modeler. Such considerations were fundamental

to ROME’s design. Through the examples presented in §4,

we illustrate the utility of this design choice for modeling

robust optimization problems.

4. Modeling Examples

In this section we discuss several robust optimization prob-

lems and how they can be modeled algebraically, and also

how their algebraic formulations can be naturally expressed

within ROME. Because the emphasis in this section is on

ROME’s utilty as a modeling tool, we will only present the

relevant sections of algebraic formulations and the ROME

models. For reference, we have included full algebraic and

ROME models in the appendices. The line numbers for

the code excerpts in this section correspond to those in the

appendices for ease of reference.

4.1. Service-Constrained Inventory Management

4.1.1. Description. We consider a distributionally ro-

bust version of a single-product, single-echelon, multi-

period inventory management problem. Our model differs

from the classical treatment of inventory management in

the literature (Arrow et al. 1951) in our modeling of short-

ages. We assume that back orders are allowed, but instead

of penalizing stockouts by imposing a linear penalty cost

within the problem objective, we impose constraints on the

extent of backordering within the model constraints. Specif-

ically, we impose a constraint on the inventory ﬁll rate,

which is deﬁned as (Cachon and Terwiesch 2009) the ratio

of ﬁlled orders to the mean demand. Our model can be

interpreted as a form of service guarantee to customers.

Other service-constrained inventory models in the litera-

ture (e.g., Boyaci and Gallego 2001, Shang and Song 2006)

typically use the structural properties of the demand pro-

cess to approximate the service constraint by an appropriate

penalty cost within the objective. Such techniques are not

suitable for our model as the actual demand distribution is

unknown. See and Sim (2009) also study a robust single-

product, single-echelon, multiperiod inventory management

problem, but they also use a penalty cost instead of a ser-

vice constraint.

2

Therefore, in our model, the inventory manager’s prob-

lem is to ﬁnd ordering quantities in each period that

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 977

minimize the worst-case expected total ordering and hold-

ing cost over the ﬁnite horizon, and satisfy the ﬁll rate

constraint in each period, as well as the other standard

inventory constraints. Through this example, we aim to

introduce various modeling constructs in ROME and show

how the ROME code is a natural expression of the model’s

algebraic formulation.

4.1.2. Parameters. We assume a ﬁnite planning hori-

zon of T periods, with an exogenous uncertain demand

in each period, modeled by a primitive uncertainty vector,

˜ z ∈

T

. The exact distribution of ˜ z is unknown, but the

inventory manager has knowledge of some distributional

information that characterizes a family of uncertainty dis-

tributions. In this example, the family contains all distri-

butions that have support on the hypercube |0, z

MAX

]

T

,

have known mean , and known covariance matrix , rep-

resented as =uL(o)L(o)

**for known model parameters
**

u and o. The lower triangular matrix L(o) ∈

T ×T

has

structure

L(o) =

_

_

_

_

_

_

_

1 0 0 · · · 0

o 1 0 · · · 0

o o 1 · · · 0

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

o o o . . . 1

_

¸

¸

¸

¸

¸

_

,

which represents an autoregressive model for demand, sim-

ilar to Johnson and Thompson (1975) and Veinott (1965),

to capture intertemporal demand correlation.

In each period t ∈ |T ], we denote by c

t

the unit order-

ing cost and the maximum order quantity by x

MAX

t

, with no

lead time for ordering. Leftover inventory at the end of each

period can be held over to the next period, with a per-unit

holding (overage) cost of h

t

. We assume no ﬁxed cost com-

ponents to all costs involved. In each period, we denote the

minimum required ﬁll rate by p

t

. Finally, we assume that

the goods have no salvage value at the end of the T peri-

ods, there is no starting inventory, and that the inventory

manager is ambiguity averse.

Table 1 lists several programming variables and the model

parameters that they represent. We assume for the rest of

this discussion that these variables have been declared and

assigned appropriate numerical values, because we will use

them within various code segments later.

4.1.3. Model. We begin by describing how uncertain-

ties are modeled. Formally, the family of distributions

that contains the true distribution of the demand ˜ z can be

characterized as

=

_

:

_

˜ z ∈ |0, z

MAX

]

T

_

=1, E

(˜ z) =, Cov

(˜ z) =

_

.

In ROME, we model this by ﬁrst declaring a programming

variable z that represents the uncertainty, and assigning var-

ious distributional properties to it.

27 newvar z(T) uncertain; % declare an uncertain demand

28 rome_constraint(z >= 0);

29 rome_constraint(z <= zMax); % set the support

30 z.set_mean(mu); % set the mean

31 z.Covar = S; % set the covariance

Code Segment 1: Specifying distributional properties on the

uncertain demand ˜ z.

Notice that the covariance matrix S is a numerical quantity

that can be constructed from alpha and sigma by appropri-

ate matrix operations.

We let x

t

(˜ z) be the decision rule that represents the order

quantity in period t. At the point of this decision, only

the demands in the ﬁrst t −1 periods have been realized.

Hence, x

t

(˜ z) should only be functionally dependent on the

ﬁrst t −1 values of ˜ z, and has corresponding information

index set |t −1]. Recall that by our convention, |0] ≡ ∅.

Further, we let ,

t

(˜ z) be the decision rule that represents the

inventory level at the end of period t. The corresponding

information index set for ,

t

(˜ z) is |t]. When the decision

rules are restricted to LDRs, for each t ∈ |T ], we require

x

t

∈ (1, N, |t −1]) and ,

t

∈ (1, N, |t]).

In Code Segment 2, we show how to use ROME to

model the order quantity decision rule, x(˜ z). The inventory

level can be modeled in an identical way.

34 % allocate an empty variable array

35 newvar x(T) empty;

36 % iterate over each period

37 for t = 1:T

38 % construct the period t decision rule

39 newvar xt(1, z(1:(t-1))) linearrule;

40 x(t) = xt; % assign it to the tth entry of x

41 end

Code Segment 2: Constructing the order quantity decision

rule in ROME.

In MATLAB syntax, the colon “:” operator is used to con-

struct numerical arrays with ﬁxed increments between its

elements. In particular, when a and b are MATLAB vari-

ables with assigned integer values with b not smaller than a,

the expression a : b returns an array with unit increments,

Table 1. List of programming variables and their asso-

ciated model parameters for the inventory

management problem.

Variable Model

name Size parameter Description

T 1 × 1 T Number of periods

zMax T ×1 z

MAX

e Support parameter for ˜ z

mu T×1 Mean of ˜ z

sigma 1 ×1 u Covariance parameter for ˜ z

alpha 1 ×1 o Covariance parameter for ˜ z

S T ×T Covariance matrix of ˜ z

xMax T ×1 x

MAX

Order quantity upper limit

c T ×1 c Unit ordering cost

h T ×1 h Unit holding cost

beta T ×1 Target (minimum) ﬁll rate

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

978 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

starting from a and ending at b. If b is (strictly) smaller

than a, the expression a : b returns an empty array.

The code segment begins declaring x as a size T empty

array, which we will later use to store the constructed deci-

sion rules. In each iteration of the for loop, we construct

a scalar-valued variable xt, which represents the period t

decision rule x

t

(˜ z). When t exceeds 1, the expression

z(1 : (t - 1)) extracts the ﬁrst t - 1 components of z, which

speciﬁes the information index set of xt. When t is exactly

equal to 1, the expression z(1 : (t - 1)) returns an empty

matrix, which indicates to ROME an empty information

index set. The next line stores the constructed decision rule

into the array x for later use.

As in standard inventory models, we have the inventory

balance constraints that describe the system dynamics. The

inventory level in period t +1 is the difference between the

period t inventory level (after ordering) and the period t

demand. The constraints may be written as

,

1

(˜ z) =x

1

(˜ z) − ˜ z

1

,

t

(˜ z) =,

t−1

(˜ z) +x

t

(˜ z) − ˜ z

t

∀t ∈ ]2, . . . T ] .

Assuming that the programming variables x and y have

been previously declared and represent the order quantity

and inventory-level decision rules, respectively, Code Seg-

ment 3 shows how the balance constraints may be modeled

in ROME.

53 % Period 1 inventory balance

54 rome_constraint(y(1) == x(1) - z(1));

55 % iterate over each period

56 for t = 2:T

57 % period t inventory balance

58 rome_constraint(y(t) == y(t-1) + x(t) - z(t));

59 end

Code Segment 3: Modeling the inventory balance

constraints.

Similarly, the upper and lower limits on the order quantities

can be modeled by the constraints

0 x

t

(˜ z) x

MAX

t

∀t ∈ |T ] .

We may express this set of constraints in ROME as

62 rome_constraint(x >= 0); % order qty. lower limit

63 rome_constraint(x <= xMax); % order qty. upper limit

Code Segment 4: Modeling the limits on the order quantity.

Observe that the programming variables are vector val-

ued, and that the code segment imposes the inequality con-

straints component-wise.

The ﬁll rate in a period t is deﬁned (Cachon and Terwi-

esch 2009) as the ratio of expected ﬁlled orders to the mean

demand, where the sales in period t can be computed as the

minimum between the inventory level after ordering and

the demand in the same period. In our model, we desire to

meet the target (minimum) ﬁll rate p

t

for all distributions

∈ . Hence, the distributionally robust ﬁll rate constraint

reads

inf

∈

E

P

(min ],

t−1

(˜ z) +x

t

(˜ z), ˜ z

t

])

j

t

p

t

for each t ∈ |T ]. Together with the inventory balance con-

straints, the ﬁll rate constraints can be simpliﬁed to

sup

∈

E

P

((,

t

(˜ z))

−

) j

t

(1 −p

t

), ∀t ∈ |T ] .

We notice that the right-hand side of the simpliﬁed inequal-

ity can be computed as a function of the model parameters.

On the left-hand side, we have a term that is the expected

positive part of an LDR. In a previous work (Goh and Sim

2010), we showed how such functions could be computed,

or at least bounded from above, given the distributional

properties of ˜ z. The algebraic formulations for these bounds

are typically quite messy, and dependent on the types of

distributional information of ˜ z available. We refer interested

readers to Goh and Sim (2010) for the exact formulations.

In ROME, however, the complexity the bounds are hid-

den from the user, and we can model this constraint in

ROME as

65 % fill rate constraint

66 rome_constraint(mean(neg(y)) <= mu - mu .* beta);

Code Segment 5: Modeling the ﬁll rate constraint.

Notice that the MATLAB operator .* represents an ele-

mentwise (Hadamard) product of two vectors.

Finally, the inventory manager’s objective in this prob-

lem is to minimize the worst-case expected total cost over

all the distributions in the family. In our model, the total

cost comprises the inventory ordering cost and the holding

cost. This can be expressed as

min sup

∈−

E

P

_

T

_

t=1

c

t

x

t

(˜ z) +

T

_

t=1

h

t

,

+

t

(˜ z)

_

,

or more compactly, as min sup

∈

E

P

(c

x(˜ z) +h

y

+

(˜ z)). In

ROME, the objective function is modeled in a similarly

intuitive way. We model this in ROME by the statement

68 % model objective

69 rome_minimize(c’*mean(x) + h’*mean(pos(y)));

Code Segment 6: Modeling the inventory manager’s

objective.

Notice that in MATLAB syntax, the “ ’ ” symbol represents

the transpose of a vector.

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 979

4.1.4. Solutions. After modeling the problem in

ROME, we can issue a call to either solve or solve_

deflected to instruct ROME to, respectively, solve the

problem using standard LDRs or BDLDRs. The computed

solutions can be extracted for further analysis using the

eval function. A sample numerical output (correspond-

ing to the parameter values used in the ROME code in

Appendix A) for the LDR describing the ﬁrst two periods

of the order quantity is

57.000

0.000 + 1.000* z1

An electronic companion containing the appendices to

this paper is available as part of the online version at http://

or.journal.informs.org. Solving via BDLDRs, the sample

output for the ﬁrst two periods of order quantities is

31.833

1.882 + 0.969* z1

+ 1.00(1.882 + 0.969* z1)^-

- 1.00(58.118 - 0.969* z1)^-

The above displays show sample “prettyprints” of how the

decision rules are output to the user and are useful for

human analysis and basic solution understanding. However,

this functionality clearly diminishes in utility for larger

and more complex problems. ROME provide the functions

(linearpart and deflectedpart) for users to extract the rel-

evant coefﬁcients of the decision rules for numerical anal-

ysis, if desired. However, from a modeling perspective, the

numerical quantities of interest are often not the actual

coefﬁcients, but rather the instantiated values of the deci-

sion rules for the realized uncertainties. This is best exem-

pliﬁed in the subsequent project-crashing modeling exam-

ple, and we will defer this discussion until later.

Finally, the optimized objective, which corresponds to

the worst-case total cost over the family of distributions,

can also be read from the ROME by calling the objective

function.

4.1.5. Remarks. Readers who are familiar with the

vectorized programming paradigm of MATLAB may ﬁnd

our ROME model for the inventory management prob-

lem somewhat awkward because of the use of many loops

within the model. Although the model presented in this sec-

tion is less computationally efﬁcient, we feel that it bears

stronger similarity to the algebraic formulation and has

value in its relative ease of understanding and implementa-

tion from a modeling standpoint.

If desired, the ROME modeling code can also be vector-

ized for computational efﬁciency. In particular, the inven-

tory balance constraint can be reformulated into a single

constraint involving a matrix-vector product. The decision

rules with their associated nonanticipative requirements can

be constructed without using loops as well, using the Pat-

tern option within their declaration, which speciﬁes the

dependency pattern on the uncertainty vector using a log-

ical matrix. The User’s Guide to ROME (Goh and Sim

2009) contains a detailed description of how to use the

Pattern option, and Appendix B contains an example of a

vectorized ROME model for this problem.

4.2. Project Crashing

4.2.1. Description. In this example, we consider a dis-

tributionally robust version of the project-crashing prob-

lem. We refer readers to Kerzner (2009) and Klastorin

(2004) for a more complete introduction to the problem.

An activity-on-arc (AOA) project network is a represen-

tation of a project in a directed acyclic graph, with arcs

representing individual activities for the project. The topol-

ogy of the graph represents precedence constraints of the

various activities. We consider a model in which comple-

tion times of the individual activities are uncertain, but can

be expedited or crashed by deterministic amounts by com-

mitting additional resources to the activities. Herroelen and

Leus (2005) provide a comprehensive survey of the vari-

ous techniques for project scheduling for uncertain activity

times. In our model, we assume that the project manager’s

objective is to minimize the expected completion time of

the project, subject to a project budget constraint, which

effectively limits the amount of crashing.

A widely used technique for project analysis in practice

is PERT U.S. Navy (1958). PERT makes several strong

modeling assumptions and has consequently come under

strong criticism (e.g., Roman 1962, van Slyke 1963). An

alternative to PERT that avoids the distributional assump-

tion on the activity times is to formulate the problem as a

robust optimization problem (Cohen et al. 2007, Goh et al.

2010) to ﬁnd the optimal crash amounts and activity start

times. We adopt the robust optimization formulation here

and show how ROME can be used to model and solve the

project-crashing problem.

This example demonstrates how ROME can be used to

model nonanticipative constraints over a network, and how

the optimization results of ROME can be extracted for

numerical analysis. In part, the latter consideration moti-

vated our decision to design ROME within the MATLAB

environment so that users can take advantage of the capa-

bilities of the host MATLAB environment for numerical

analysis and manipulation.

4.2.2. Parameters. Consider a project with N activi-

ties that have uncertain completion times represented by

an uncertainty vector ˜ z ∈

N

. Again, we do not presume

exact knowledge of the actual distribution of ˜ z, but instead

assume that the true distribution belongs to a family of

distributions , characterized by certain distributional prop-

erties. In particular, we assume that we know the mean

activity time vector and covariance matrix of the activ-

ity times. Moreover, we have accurate estimates of the

most optimistic activity times z

L

and the most pessimistic

activity times z

H

. These parameters form lower and upper

bounds of ˜ z, respectively.

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

980 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

Table 2. List of programming variables and their asso-

ciated model parameters for the project-

crashing problem.

Variable Model

name Size parameter Description

N 1 x 1 N Number of activities, number of arcs

in network

M 1 x 1 M Number of nodes in network

zL N x 1 z

L

Optimistic activity completion time

zH N x 1 z

H

Pessimistic activity completion time

mu N x 1 Mean activity time

Sigma N x T Covariance matrix of activity time

c N x 1 c Crashing cost per unit time

u N x 1 u Crashing limit

B 1 x 1 B Project budget

The precedence relations in the network are described

by an AOA project network, with M nodes and N arcs.

We represent the graph topology by an incidence matrix

A∈

M×N

, which has components

A

ik

=

_

¸

_

¸

_

−1 if arc k leaves node i,

1 if arc k enters node i,

0 otherwise.

This representation is more natural for our model instead

of the (V, E) representation or an adjacency matrix repre-

sentation, because it naturally preserves the integer indices

on the activities. In addition, we assume that the nodes are

indexed such that the starting node has index 1 and the

terminal node has index M.

For each activity k ∈ |N], we denote the maximum

amount that it can be crashed by the parameter u

k

, and the

crashing cost per unit time by c

k

. The project budget is

denoted by B. Table 2 lists several programming variables

and the model parameters that they represent. We assume

for the rest of this discussion that these variables have

been declared and assigned appropriate numerical values,

because we will use them within various code segments

later.

4.2.3. Model. We begin by modeling the uncertainty ˜ z.

This follows an identical structure to the inventory man-

agement example. The family of uncertainty distributions

is formally described by

=]: (z

L

˜ z z

H

) =1, E

(˜ z) =, Cov

(˜ z) =] ,

The corresponding code in ROME is also identical in struc-

ture to the inventory management example, and we omit

displaying it here. For reference, we have included the full

algebraic model and ROME code in Appendix B.

Next, we let ,

k

(˜ z) be the decision rule that represents

the crash amount for activity k. At the point of this deci-

sion, only the activities that precede activity k have been

completed. We can recursively construct the corresponding

information index set I

k

,

. For any activity I ∈ |N], deﬁne

the set

(I) =]I

∈ |N] : ∃i ∈ |M] : A

iI

=−1, A

iI

=1] ,

which is the set of activity indices that immediately pre-

cede I. Then, we may recursively evaluate I

k

,

as

I

1

,

=∅ and I

k

,

=(I) ∪

k

∈P(I)

I

k

,

, (5)

which simply recursively includes all predecessors of k

into I

k

,

. The ROME model for constructing the crash

amount LDR is almost identical to how the order quan-

tity LDR was constructed in the previous example, and is

shown below.

39 % y: crash amounts

40 newvar y(N) empty; % allocate an empty variable array

41 % iterate over each activity

42 for k = 1:N

43 % get indices of dependent activities

44 ind = prioractivities(k, A);

45 % construct the decision rule

46 newvar yk(1, z(ind)) linearrule;

47 % assign it to the kth entry of y

48 y(k) = yk;

49 end

Code Segment 7: Constructing the crash amount decision

rule in ROME.

Here, prioractivities is a function that implements

recursion (5) and returns the array ind, which contain the

indices of the dependent activities. The electronic com-

panion details the code for its implementation. The next

line then uses ind to index into the uncertainty vector z to

construct the dependencies of the kth activity, represented

by yk.

The remaining decision rule is x

i

(˜ z), for each node i

of the network, which represents the time of node i, or,

equivalently, the common start time of the activities that

exit node i. Its corresponding information index set, I

i

x

, can

be constructed as

I

i

x

=

_

I

k

,

for any k such that A

ik

=−1 if i =M,

|N] if i =M.

Modeling this in ROME follows directly from the construc-

tion of y above.

The time evolution of the project is represented by the

inequality

x

]

(˜ z)−x

i

(˜ z)(˜ z

k

−,

k

(˜ z))

+

∀k ∈|N], A

ik

=−1, A

]k

=1,

which states that the difference in event times between two

nodes that are joined by an activity must exceed the activ-

ity time after accounting for the crash. The ( · )

+

operation

is a statement that regardless of how much an activity is

crashed, it cannot have negative completion time. In ROME,

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 981

assuming that x and y have been properly constructed, we

can express this as

70 % iterate over each activity

71 for k = 1:N

72 ii = find(A(:, k) == -1); % activity k leaves node

73 jj = find(A(:, k) == 1); % activity k enters node

74 % make constraint

75 rome_constraint(x(jj) - x(ii) >= pos(z(k) - y(k)));

76 end

Code Segment 8: Expressing the project dynamics in

ROME.

The remaining constraints are, ﬁrstly, the limits on the

crash amounts, which are represented by the inequality

0 y(˜ z) u; secondly, the constraint that all times should

be nonnegative, which is represented by x(˜ z) 0; and

ﬁnally, the requirement that the total crashing cost must

be within the budget, which is represented by c

y(˜ z) B.

These inequalities are easily expressed in ROME as

79 rome_box(y, 0, u); % crash limit

80 rome_constraint(x >= 0); % nonnegative time

81 rome_constraint(c’ * y <= B); % budget constraint

Code Segment 9: Project constraints in ROME.

Notice that we have used the contraction rome_box as a

convenient shorthand to express a constraint on a variable

having upper and lower limits.

The project completion time is simply the time of the ter-

minal node, x

M

(˜ z). The project manager aims to minimize

the worst-case expected completion time over the family of

distributions, sup

∈

E

P

(x

M

(˜ z)). This can be expressed in

ROME using the code segment

83 % objective: minimize worst -case mean completion time

84 rome_minimize(mean(x(M)));

Code Segment 10: Minimizing the expected project com-

pletion time.

4.2.4. Solutions. Similar to the inventory management

example, we can use eval to return the optimized LDR

or BDLDR after solving. For example, using the numer-

ical instance of the project-crashing problem described in

Appendix B, the LDR solution that represents the crash

amounts, y(˜ z), has the displayed output

y_sol =

2.000

1.000

1.000

0.381 + 0.262* z1

0.195 - 0.020* z1

1.021 - 0.004* z3

0.289 + 0.033* z1 + 0.054* z4

2.500 - 0.250* z1 + 0.000* z2

- 0.000* z3 + 0.000* z5 - 0.000* z6

0.529 + 0.094* z3

which also can be used to verify that y does indeed satisfy

the nonanticipative constraints, which is more complicated

than the multistage nonanticipativity seen in the inventory

management example.

Recall that in our model we solve for the worst-case dis-

tribution over a family of distributions. A question that is

of both theoretical and practical interest is how the decision

rules perform for speciﬁc distributions. From a theoretical

perspective, if we can ﬁnd a distribution that attains the

worst case, then we know that the bound is tight and cannot

be further improved. From a practical standpoint, if we do

indeed have an accurate estimate of the activity time distri-

bution, we may want to measure how well the worst-case

optimized decision rules perform against this distribution.

In the numerical instance in Appendix B, we have used

mean and covariance parameters such that an independent

uniform distribution on the support of ˜ z is a possible dis-

tribution in . We can then generate these independent uni-

forms and instantiate the decision rules and the objective to

evaluate their performance on this speciﬁc distribution. For

example, if we want to study the statistics of the project

expenditure, we would use the following code segment

93 Nsims = 10000; % number of simulation runs

94 expenditure = zeros(Nsims , 1); % allocate array

95 for ii = 1: Nsims

96 % simulate activity times

97 z_vals = zL + (zH - zL) .* rand(N, 1);

98 % instantiate crash costs

99 expenditure(ii) = c’ * y_sol.insert(z_vals);

100 end

Code Segment 11: Example of instantiating decision rules

with uncertainty realizations.

Notice that MATLAB’s in-built zeros function creates an

array of all zeros, which we use to store the computed

expenditures. The rand function generates an array of N

independent uniform random |0,1] numbers that we shift

and scale to get the simulated activity times.

The key ROME functionality used here is the insert

function, which instantiates the LDR solution with the

uncertainties. The project expenditure in simulation run is

the inner product of the unit cost vector, c, with the result

of the y_sol.insert(z_vals), which is a numerical vector.

The computed expenditure is then stored in the expendi-

ture array and can be used for various numerical analy-

sis. As an example, in this particular instance we can ﬁnd

that using LDRs, the 95% conﬁdence interval of the mean

expenditure is (9.6072, 9.6125), whereas if BDLDRs are

used, the 95% conﬁdence interval of the mean expenditure

is (9.8781, 9.8863).

4.2.5. Remarks. ROME can also model several vari-

ants of the project-crashing model presented here. For

example, we could minimize the expected project-crashing

cost, subject to a constraint on the project completion

deadline. Alternatively, if appropriate linear penalty cost

parameters can be associated with late completion, we

could instead minimize the expected total (crashing and

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

982 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

penalty) cost in the objective. Finally, instead of mini-

mizing expected costs, we could also minimize worst-case

costs, as in the model of Cohen et al. (2007).

4.3. Robust Portfolio Selection

4.3.1. Description. In this section, we consider the

problem of robust portfolio selection. Markowitz (1952,

1959) pioneered the use of optimization to handle the trade-

off between risk and return in portfolio selection, and to

solve this problem, introduced the (now classical) technique

of minimizing portfolio variance, subject to the mean port-

folio return attaining the target. However, various authors

have indicated several problems with using variance as a

measure of risk, namely, that this approach is only appro-

priate if the returns distribution is elliptically symmetric

(Tobin 1958 and Chamberlain 1983).

A risk metric that overcomes many of the shortcom-

ings of variance is the Conditional Value-at-Risk (CVaR)

risk metric popularized by Rockafellar and Uryasev (2000).

CVaR satisﬁes many desirable properties of a risk mea-

sure, qualifying it as a coherent measure of risk (Artzner

et al. 1999). CVaR is a measure of tail risk, measuring the

expected loss within a speciﬁed quantile. In this example,

we will use CVaR as our objective for the portfolio opti-

mization. In addition, we will require that the optimized

portfolio has a mean return above a prespeciﬁed target,

and study how the characteristics of the optimal portfolio

changes as the target return level varies. In particular, we

will investigate how the coefﬁcient of variation (CV) of

the optimized portfolio return varies with the target return

level. We will assume that no short-selling is permitted, and

we also make the standard assumption that the assets are

traded in a frictionless market (i.e., a fully liquid market

with no transaction costs).

In this example, we aim to show how ROME can be used

to study robust optimization problems that do not ostensibly

require decision rules, how ROME models can be devel-

oped in a modular manner by writing custom functions,

and ﬁnally, how a ROME model can be easily embedded

as components of a larger program.

4.3.2. Parameters. We let N denote the total number

of assets available for investment. The drivers of uncer-

tainty in this model are the asset returns, which we denote

by the uncertainty vector ˜ r ∈

N

. We do not presume to

know the precise distribution of ˜ r ∈

N

, but instead, we

assume that we have accurate estimates of the asset return

means and covariance matrix , which characterizes a

family of distributions .

A key exogenous parameter is the CVaR-level, p, which

speciﬁes the quantile over which the conditional expected

loss is computed. Typical values of p are 95%, 98%, or

99%. In addition, we let |t

L

,t

H

] represent the range of tar-

get returns that we search over. For a ﬁxed target return t ∈

|t

L

,t

H

], the portfolio manager’s problem is to ﬁnd a portfo-

lio allocation that has a mean return above t, and minimizes

Table 3. List of programming variables and their associ-

ated model parameters for the inventory man-

agement problem.

Variable Model

name Size parameter Description

N 1 x 1 N Number of assets

mu N x 1 Mean return

Sigma N x T Covariance matrix returns

beta 1 x 1 p CVaR-level

tL 1 x 1 t

L

Lower limit of target return

tH 1 x 1 t

H

Upper limit of target return

the worst p-CVaR over all uncertainty distributions within

. Table 3 lists several programming variables and the model

parameters that they represent. We assume for the rest of

this discussion that these variables have been declared and

assigned appropriate numerical values, because we will use

them within various code segments later.

4.3.3. Model. In this model, the portfolio manager’s

decision is a vector x ∈

N

, with the ith component rep-

resenting the fraction of the net wealth to be invested in

asset i. Because we do not consider any dynamics in this

problem, the primary decision rule x is a standard vector-

valued decision variable in this problem.

For a ﬁxed p, and known distribution , letting the port-

folio loss as a function of the decision be represented by

˜

·(x) =−˜ r

**x, the p-quantile of the loss distribution can be
**

found via

o

p

(x) =min]v ∈ : (

˜

·(x) v) p].

Therefore, 1 − p represents the probability that the loss

exceeds o

p

(x). The p-CVaR is deﬁned as the conditional

loss, given that the loss exceeds o

p

(x). This is in turn

found via

CVaR

p

(x) =Ɛ

(

˜

·(x)

˜

·(x) o

p

(x)).

Rockafellar and Uryasev (2000, Theorem 1) show that the

expression CVaR can be written in a more amenable form

for optimization,

CVaR

p

(x) =min

v∈

_

v +

1

1 −p

Ɛ

_

˜

·(x) −v

_

+

_

.

In our distributionally robust setting, we consider the worst-

case CVaR over all distributions within the family , and

we get

CVaR

p

(x) =min

v∈

_

v +

1

1 −p

sup

∈

E

P

(

_

˜

·(x) −v

_

+

)

_

. (6)

We can encapsulate this within a function:

6 function cvar = CVaR(loss , beta)

7 newvar v; % declare an auxilliary variable v

8 cvar = v + (1 / (1 - beta)) * mean(pos(loss - v));

Code Segment 12: Implementing a custom CVaR function

in ROME.

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 983

Therefore, for a ﬁxed t ∈ |t

L

,t

H

], the p-CVaR minimiz-

ing portfolio, denoted by x

∗

(t), solves

min

x

CVaR

p

(−˜ r

x)

s.t.

x t

e

x =1

x 0.

(7)

The ﬁrst constraint represents the requirement that the opti-

mized portfolio must have a mean return above t. The

second constraint is simply a normalization. Because x

is a vector whose components represents fractions of net

wealth, its components must sum to 1. Finally, the last con-

straint is simply a statement of the modeling assumption

that short sales are not permitted.

This can be modeled in ROME as

9 function x_sol = optimizeportfolio (N, mu, Sigma , ...

10 beta , tau)

11

12 % begin the ROME environment

13 h = rome_begin(’Portfolio Optimization ’);

14

15 newvar r(N) uncertain; % declare r as uncertainty

16 r.set_mean(mu); % set mean

17 r.Covar = Sigma; % set covariance

18

19 % declare a nonnegative variable x

20 newvar x(N) nonneg;

21

22 % objective: minimize CVaR

23 rome_minimize(CVaR(-r’ * x, beta));

24 % mean return must exceed tau

25 rome_constraint(mu’ * x >= tau);

26 % x must sum to 1

27 rome_constraint(sum(x) == 1);

28

29 % solve the model

30 h.solve_deflected;

31

32 % check for infeasibility / unboundedness

33 if(isinf(h.objective))

34 x_sol = []; % assign an empty matrix

35 else

36 x_sol = h.eval(x); % get the optimal solution

37 end

38 rome_end; % end the ROME environment

Code Segment 13: Portfolio optimization example in

ROME.

The CV is a dimensionless measure of variability of the

optimized portfolio return and is deﬁned as the ratio of its

standard deviation to its mean. As a function of t, it is

formally deﬁned as

CV(t) ≡

_

x

∗

(t)

x

∗

(t)

x

∗

(t)

. (8)

To investigate how the CV changes for t ∈ |t

L

,t

H

], we can

simply compute the CV for a uniform sample of t within

this range, and plot the ensuing CV against t. This can be

done by the following code segment.

15 Npts = 200; % number of points in to plot

16 cv = zeros(Npts , 1); % allocate result array

17

18 % array of target means to test

19 tau_arr = linspace(0, tH , Npts);

20

21 for ii = 1:Npts

22 % Find the CVaR -optimal portfolio

23 x_sol = optimizeportfolio(N, mu , Sigma , ...

24 beta , tau_arr(ii));

25

26 % Store the coeffients of variation

27 if(isempty(x_sol))

28 cv(ii) = Inf;

29 else

30 cv(ii) = sqrt(x_sol ’* Sigma*x_sol) / (mu ’*x_sol);

31 end

32 end

33

34 plot(tau_arr , cv); % plot CV against tau

35 xlabel(’\tau’); ylabel(’CV’); % label axes

36 title(’Plot of CV vs \tau’); % label graph

Code Segment 14: Plotting the CV of p-CVaR optimized

portfolio against t.

In the previous code segment, linspace(0, tH, Npts) is a

MATLAB in-built function that returns an array with Npts

elements with equal consecutive differences, starting with

the element 0 and ending with tH.

5. ROME’s Scope

In the previous section, we discussed how ROME can be

used in several example applications in different areas of

operations research. In this section we formally establish

ROME’s scope and the class of problems that it can model

and solve.

We denote by ˜ z an N-dimensional vector of uncertain-

ties, deﬁned on the probability space (D,,). We do

not assume that the uncertainty distribution is precisely

known, but instead, we may have knowledge of certain dis-

tributional properties of ˜ z, namely, its support, mean sup-

port, covariance matrix, and upper bounds on its directional

deviations (introduced by Chen et al. 2007). The presence

of these properties serve to characterize a family of distri-

butions, which we generally denote by , that contains the

actual distribution .

The decision variables in our framework comprise x, an

n-dimensional vector of decisions to be made before the

realization of any of the uncertainties, as well as a set

of K vector-valued decisions rules y

k

( · ), with image in

m

k

for each k ∈ |K]. We assume that we are given as

parameters the information index sets ]I

k

]

K

k=1

, where I

k

⊆

|N] ∀k ∈ |K]. To model the nonanticipative requirements,

we require that the decision rules belong to the sets ,

k

∈

(m

k

, N, I

k

), ∀k ∈ |K], where is the set of nonantici-

pative decision rules as deﬁned in (3).

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

984 Operations Research 59(4), pp. 973–985, ©2011 INFORMS

The general model that we consider is then

Z

∗

GEN

= min

x, ]y

k

(·)]

K

k=1

c

0

x + sup

∈−

E

P

_

K

_

k=1

d

0, k

y

k

(˜ z)

_

s.t.c

I

x + sup

∈−

E

P

_

K

_

k=1

d

I, k

y

k

(˜ z)

_

l

I

∀I ∈ |M] (9)

T(˜ z)x +

K

_

k=1

U

k

y

k

(˜ z) =v(˜ z)

y

k

y

k

(˜ z) ¯ y

k

∀k ∈ |K]

x 0

y

k

∈ (m

k

, N, I

k

) ∀k ∈ |K] . (10)

We note that for each I ∈ ]0] ∪|M] and k ∈ |K], the quan-

tities l

I

, c

I

, d

I, k

, U

k

, and I

k

are model parameters which

are precisely known. Similarly, T(˜ z) and v(˜ z) are model

parameters that are assumed to be afﬁnely dependent on

the underlying uncertainties. The upper and lower bounds

on the recourse variable y

k

( · ), respectively denoted by ¯ y

k

and y

k

, are also model parameters that are possibly inﬁnite

componentwise.

Notice that in ROME we do not solve (9) exactly, but

instead solve for optimized decision rules residing in struc-

tured subsets of , corresponding to a restriction of (9).

This is because although problem (9) is quite general, it

is also unfortunately computationally intractable in most

cases (see Ben-Tal et al. 2004 or Shapiro and Nemirovski

2005 for a more detailed discussion). The set of LDRs, ,

deﬁned in (4), is the default subset of used in ROME. If

desired, at the expense of a typically minor computational

cost, users can also choose to solve for BDLDRs, which

reside in a larger subset of .

6. Conclusion

In this paper, we have introduced ROME, a MATLAB-

based robust optimization modeling toolbox, and

demonstrated its utility in modeling robust optimization

problems. Through the three modeling examples discussed

in this paper, we have introduced ROME’s key features,

and we have demonstrated how ROME allows users to

model otherwise complex problems with relative ease, in a

mathematically intuitive manner. In addition, through the

ﬁnal portfolio optimization example, we have also demon-

strated how ROME might be integrated into a sample

application. We believe that ROME can be a helpful and

valuable tool for further academic and industrial research

in the ﬁeld of robust optimization.

7. Electronic Companion

An electronic companion to this paper is available as part

of the online version that can be found at http://or.journal

.informs.org/.

Endnotes

1. Freely available for academic use from http://www

.robustopt.com

2. ROME code for both their model and ours

can be freely obtained from http://www.robustopt.com/

examples.html

Acknowledgments

The authors thank the associate editor and the anonymous

referees for their comments and critique on the ﬁrst ver-

sion of this paper. They are also especially grateful for the

detailed comments by Area Editor Robert Fourer for his

detailed feedback on the ﬁrst version of this paper. Their

feedback has allowed the authors to signiﬁcantly improve

the structure and quality of this paper.

References

Arrow, K. J., T. Harris, J. Marschak. 1951. Optimal inventory policy.

Econometrica 19(3) 250–272.

Artzner, P., F. Delbaen, J. M. Eber, D. Heath. 1999. Coherent measures

of risk. Math. Finance 9(3) 203–228.

Baotic, M., M. Kvasnica. 2006. CPLEXINT—MATLAB interface for the

CPLEX solver. Accessed August 9, 2011, http://control.ee.ethz.ch/

∼hybrid/cplexint.php.

Ben-Tal, A., A. Nemirovski. 1998. Robust convex optimization. Math.

Oper. Res. 23(4) 769–805.

Ben-Tal, A., S. Boyd, A. Nemirovski. 2006. Extending scope of robust

optimization: Comprehensive robust counterparts of uncertain prob-

lems. Math. Programming Ser. B 107(1–2) 63–89.

Ben-Tal, A., A. Goryashko, E. Guslitzer, A. Nemirovski. 2004. Adjustable

robust solutions of uncertain linear programs. Math. Programming

99(2) 351–376.

Bertsimas, D., M. Sim. 2004. The price of robustness. Oper. Res. 52(1)

35–53.

Bertsimas, D., D. A. Iancu, P. A. Parrilo. 2010. Optimality of afﬁne poli-

cies in multistage robust optimization. Math. Oper. Res. 35(2) 363–

394.

Boyaci, T., G. Gallego. 2001. Serial production/distribution systems under

service constraints. Manufacturing Service Oper. Management 3(1)

43–50.

Breton, M., S. El Hachem. 1995. Algorithms for the solution of stochastic

dynamic minimax problems. Comput. Optim. Appl. 4 317–345.

Brooke, A., D. Kendrick, A. Meeraus, R. Raman. 1997. GAMS Language

Guide. Release 2.25. GAMS Development Corporation, Washington,

DC.

Cachon, G., C. Terwiesch. 2009. Matching Supply with Demand: An Intro-

duction to Operations Management. McGraw-Hill, Boston.

Chamberlain, G. 1983. A characterization of the distributions that imply

mean-variance utility functions. J. Econom. Theory 29(1) 185–201.

Chen, X., Y. Zhang. 2009. Uncertain linear programs: Extended afﬁnely

adjustable robust counterparts. Oper. Res. 57(6) 1469–1482.

Chen, X., M. Sim, P. Sun. 2007. A robust optimization perspective on

stochastic programming. Oper. Res. 55(6) 1058–1071.

Chen, X., M. Sim, P. Sun, J. Zhang. 2008. A linear decision-based

approximation approach to stochastic programming. Oper. Res. 56(2)

344–357.

Cohen, I., B. Golany, A. Shtub. 2007. The stochastic time-cost tradeoff

problem: A robust optimization approach. Networks 49(2) 175–188.

Delage, E., Y. Ye. 2010. Distributionally robust optimization under

moment uncertainty with application to data-driven problems. Oper.

Res. 58(3) 595–612.

Dupaˇ cová, J. 1987. The minimax approach to stochastic programming and

an illustrative application. Stochastics 20(1) 73–88.

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

Goh and Sim: Robust Optimization Made Easy with ROME

Operations Research 59(4), pp. 973–985, ©2011 INFORMS 985

Dupaˇ cová, J. 2001. Stochastic programming: Minimax approach.

C. Floudas, P. Pardalos, eds. Encyclopedia of Optimization, Vol. 5.

Kluwer Academic Publishers, Norwell, MA, 327–330.

Fourer, R., L. Lopes. 2006. A management system for decompositions in

stochastic programming. Ann. Oper. Res. 142 99–118.

Fourer, R., L. Lopes. 2009. StAMPL: A ﬁltration-oriented modeling tool

for multistage stochastic recourse problems. INFORMS J. Comput.

21(2) 242–256.

Fourer, R., D. M. Gay, B. W. Kernighan. 1990. A modeling language for

mathematical programming. Management Sci. 36(5) 519–554.

Fourer, R., D. M. Gay, B. W. Kernighan. 2002. AMPL: A Modeling Lan-

guage for Mathematical Programming. Duxbury Press, Brooks/Cole

Publishing, Paciﬁc Grove, CA.

Goh, J., M. Sim. 2009. User’s Guide to ROME. Accessed August 9, 2011,

http://www.robustopt.com/references/ROME_Guide_1.0.pdf.

Goh, J., M. Sim. 2010. Distributionally robust optimization and its

tractable approximations. Oper. Res. 58(4) 902–917.

Goh, J., N. G. Hall, M. Sim. 2010. Robust optimization strategies for total

cost control in project management. Working paper, NUS Business

School, Singapore.

Grant, M., S. Boyd. 2008. Graph implementations for nonsmooth convex

programs. V. Blondel, S. Boyd, H. Kimura, eds. Recent Advances

in Learning and Control (a Tribute to M. Vidyasagar). Springer,

New York, 95–110.

Grant, M., S. Boyd. 2011. CVX: MATLAB software for disciplined con-

vex programming (Web page, software). Retrieved August 9, 2011,

http://cvxr.com/cvx.

Herroelen, W., R. Leus. 2005. Project scheduling under uncertainty: Sur-

vey and research potentials. Eur. J. Oper. Res. 165 289–306.

Holmström, K. 1999. The TOMLAB optimization environment in MAT-

LAB. Adv. Model. Optim. 1(1) 47–69.

IBM. 2011. IBM ILOG CPLEX. Accessed August 9, 2011, http://www

-01.ibm.com/software/integration/optimization/cplex-optimizer.

Johnson, G. D., H. E. Thompson. 1975. Optimality of myopic inventory

policies for certain dependent demand processes. Management Sci.

21(11) 1303–1307.

Kaut, M., A. King, T. H. Hultberg. 2008. A C++ modelling environment

for stochastic programming. Technical report, IBM, New York.

Kerzner, H. 2009. Project Management: A Systems Approach to Planning,

Scheduling, and Controlling, 10th ed. Wiley, Hoboken, NJ.

Klastorin, T. D. 2004. Project Management: Tools and Trade-Offs, 1st ed.

Wiley, Hoboken, NJ.

Löfberg, J. 2004. YALMIP: A toolbox for modeling and optimization in

MATLAB. IEEE Internat. Sympos. Comput. Aided Control Systems

Design, Taiwan.

Löfberg, J. 2008. Modeling and solving uncertain optimization problems

in YALMIP. Proc. 17th World Congress: The Internat. Federation of

Automatic Control, Seoul, Korea.

Markowitz, H. M. 1952. Portfolio selection. J. Finance 7 77–91.

Markowitz, H. M. 1959. Portfolio Selection: Efﬁcient Diversiﬁcation of

Investments. John Wiley & Sons, New York.

MOSEK ApS. The MOSEK optimization software. Accessed August 9,

2011, http://www.mosek.com.

Rockafellar, R. T., S. Uryasev. 2000. Optimization of conditional value-

at-risk. J. Risk 2 493–517.

Roman, D. D. 1962. The PERT system: An appraisal of program evalua-

tion review technique. J. Acad. Management 5(1) 57–65.

See, C.-T., M. Sim. 2009. Robust approximation to multiperiod inventory

management. Oper. Res. 58(3) 583–594.

Shang, K. H, J. S. Song. 2006. A closed-form approximation for serial

inventory systems and its application to system design. Manufactur-

ing Service Oper. Management 8(4) 394–406.

Shapiro, A., S. Ahmed. 2004. On a class of minimax stochastic programs.

SIAM J. Optim. 14(4) 1237–1249.

Shapiro, A., A. Kleywegt. 2002. Minimax analysis of stochastic programs.

Optim. Methods Software 17(3) 523–542.

Shapiro, A., A. Nemirovski. 2005. On complexity of stochastic program-

ming problems. V. Jeyakumar, A. Rubinov, eds. Continuous Opti-

mization. Springer, New York, 111–146.

Soyster, A. L. 1973. Convex programming with set-inclusive constraints

and applications to inexact linear programming. Oper. Res. 21(5)

1154–1157.

Tobin, J. 1958. Liquidity preference as behavior toward risk. Rev. Econom.

Stud. 25 65–85.

Toh, K., M. Todd, R. Tütüncü. 1999. SDPT3—A MATLAB software

package for semideﬁnite programming. Optim. Methods Software 11

545–581.

U.S. Navy. 1958. PERT summary report, phase I. Technical report, Special

Projects Ofﬁce, Bureau of Naval Weapons, Washington, DC.

Valente, C., G. Mitra, M. Sadki, R. Fourer. 2009. Extending algebraic

modelling languages for stochastic programming. INFORMS J. Com-

put. 21(1) 107–122.

Van Slyke, R. M. 1963. Monte Carlo methods and the PERT problem.

Oper. Res. 11(5) 839–860.

Veinott, A. 1965. Optimal policy for a multi-product, dynamic, nonsta-

tionary inventory problem. Management Sci. 12(3) 206–222.

Žáˇ cková, J. 1966. On minimax solution of stochastic linear programming

problems.

ˇ

Casopis pro Pˇ estování Matematiky 91(4) 423–430.

I

N

F

O

R

M

S

h

o

l

d

s

c

o

p

y

r

i

g

h

t

t

o

t

h

i

s

a

r

t

i

c

l

e

a

n

d

d

i

s

t

r

i

b

u

t

e

d

t

h

i

s

c

o

p

y

a

s

a

c

o

u

r

t

e

s

y

t

o

t

h

e

a

u

t

h

o

r

(

s

)

.

A

d

d

i

t

i

o

n

a

l

i

n

f

o

r

m

a

t

i

o

n

,

i

n

c

l

u

d

i

n

g

r

i

g

h

t

s

a

n

d

p

e

r

m

i

s

s

i

o

n

p

o

l

i

c

i

e

s

,

i

s

a

v

a

i

l

a

b

l

e

a

t

h

t

t

p

:

/

/

j

o

u

r

n

a

l

s

.

i

n

f

o

r

m

s

.

o

r

g

/

.

ROME parallels the functionality of the deterministic equivalent generator in the management system for stochastic decompositions described by Fourer and Lopes (2006). and integrate ROME more easily into their applications. this problem is compounded by the fact that the deterministic forms of many robust optimization models are exceedingly complex and tedious to model explicitly. or TOMLAB (Holmström 1999). Furthermore. Bold lower-case letters such as x represent vec˜ tors. In addition. A related problem class to the generic robust optimization problem handled in ROME is the class of multistage stochastic recourse programs (MSRPs). x. but instead uses robust optimization theory to convert uncertain optimization models (input by a user) into their robust counterparts.journal. and readers are referred to Goh and Sim (2010) for a deeper discussion of the general problem and its theoretical properties. so that users already familiar with MATLAB have a shallow learning curve in using ROME.e. not just through their support.g. x+ ≡ max x 0 and x− ≡ max −x 0 . i. Both problem classes involve a progressive revelation of information. which is then marshaled into a solverspeciﬁc input format for solving. . In this paper. with the notable exception of YALMIP. and ROME even incorporates more complex piecewiselinear decision rules based on the bideﬂected linear decision rule (Goh and Sim 2010). and recent work (e. MOSEK (MOSEK ApS 2011). A fundamental distinction between ROME and these other toolboxes is that robust optimization models typically cannot be directly modeled in these other toolboxes. Our design goal with ROME is also similar: we aim to make the models in ROME as natural and intuitive as their algebraic formulations. allow for more extensive computational tests on theoretical robust optimization models. CVX (Grant and Boyd 2008. In contrast. We denote a random variable by the tilde sign. and SDPT3 (Toh et al. At present. 2008). Section 5 describes the general class of problems that ROME is designed to solve. and lacks the versatility of specialized algebraic modeling languages such as AMPL (Fourer et al. and the upper-case letters such as A denote matrices. input by the user. ROME is narrower in scope in terms of the different types of deterministic optimization problems that it can model.Goh and Sim: Robust Optimization Made Easy with ROME 974 to practice. Notations. Through these examples. for a solver Operations Research 59(4). By design. 2011). pp. and decision making that depends on the revealed information.informs. users have a choice of the following solvers in ROME: ILOG CPLEX (IBM 2011). Additional information. The trade-off is that ROME’s restriction to the MATLAB environment limits its ﬂexibility in model building and expression. using the same modeling code in ROME. as we will illustrate in §2. Using ROME. and secondly. ROME’s core functionality is essentially independent from the choice of solver used. indicating that the corresponding operations are performed INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). We believe that the development of such technology will ﬁrstly enable robust optimization models to be applied practically. ROME’s key distinction with YALMIP lies in ROME’s comparatively richer modeling of uncertainties.0 (beta) and its subversions. which allows users to model robust counterparts through uncertainty sets. The same notation can be used on vectors. such as y+ and z− . ROME’s core functionality involves translating modeling code. We aim to contribute toward the development of such a technology by introducing an algebraic modeling toolbox1 for modeling robust optimization problems. Valente et al. as well as installation instructions. Because ROME is built in the MATLAB environment. ROME allows users to use and manipulate decision rules such as LDRs. version 1. In particular. ROME does not employ scenario generation. 1997). 1990. we can readily model and solve a variety of robust optimization problems. such as YALMIP (Löfberg 2004. ROME is designed using similar syntax and constructs as those of MATLAB. by Fourer and Lopes 2009. and CPLEX through the CPLEXINT interface (Baotic and Kvasnica 2006). into an internal structure in ROME. 1999). 973–985.org/. The trade-off is that. An electronic companion to this paper is available as part of the online version that can be found at http://or. including rights and permission policies.. named Robust Optimization Made Easy (ROME). compared to these other toolboxes. which are then passed to numerical solver packages. it has to at least be able to solve second-order conic programs (SOCPs).informs. In this regard. but also through other distributional properties such as moments and directional deviations. as well as LDR-based decision rules such as bideﬂected or segregated LDRs within their robust optimization models with relative ease. analyze optimization results. ROME is similar to other MATLAB-based algebraic modeling toolboxes for optimization. we discuss several detailed modeling examples of robust optimization problems and describe how these problems have a natural representation in ROME. decision rules are modeled in ROME very naturally. Due to the internal conversions performed by ROME. we demonstrate key features that make ROME amenable to modeling such problems. modelers are able to take advantage of the strength of MATLAB’s numerical computational framework to prepare data. which runs in the MATLAB environment. Moreover. In addition. 2008. The User’s Guide to ROME (Goh and Sim 2009) contains a comprehensive description of ROME’s functionality and usage. In this respect. 2002) or GAMS (Brooke et al. © 2011 INFORMS to be compatible with ROME. allowing users to use whichever solver they are most familiar with. 2009) has focused on developing modeling tools to enhance existing algebraic modeling languages with the capability of processing and manipulating such scenario trees. This paper covers the public release version of ROME. ROME calls both MOSEK and SDPT3 solvers through their prepackaged MATLAB interfaces.org/. A common technique used to model an MSRP is the use of scenario trees to exhaustively represent its probabilistic outcomes. is available at http://journals.. in that it aims to serve as an intermediate layer between the modeler and underlying numerical solvers. Kaut et al.

we may formally let I ⊆ N represent the index set of the uncertainties that are revealed by the current time. rather than promote. This ˜ ˜ may be interpreted as an LP with some uncertainty in a coefﬁcient of its constraint matrix.t. This simple example exempliﬁes the problem of using existing deterministic algebraic modeling languages for robust optimization. We also denote with a superscripted letter “c” the complement of a set. INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). I c . Goh and Sim 2010) has been to restrict the search space to linear decision rules (LDRs). which may be structurally very different from the original problem and have many unnecessary variables. pp. To solve this problem numerically. Also. N = 1 2 N . a m -valued LDR belongs to the set m N I ≡ f N → m ∃y0 ∈ m Y∈ m×N f z = y0 + Yz (4) Yei = 0 ∀ i ∈ I c . The expectation of a random variable z ˜ with distribution is denoted E z and its covariance ˜ ˜ matrix Cov z . and tends to impede. we describe general properties of decision rules and the concept of nonanticipativity. which are fundamental building blocks in ROME. in general. For most readers.. In this section.. Additional information. which we will term an information index set. a key design goal in ROME was to build a modeling toolbox where robust optimization problems such as (1) can be modeled directly. At a given decision epoch.g. We also introduce linear decision rules. © 2011 INFORMS 975 complex problems.. and invoking a strong duality argument (Ben-Tal and Nemirovski 1998.g. intuition about the model. x y denotes the inner product between two column ˜ vectors x and y. we will denote by N the set of positive running indices to N . 2004. (2) has the added auxiliary variables r and s. functions that are afﬁne in the uncertainties. if z has a distribution . the conversion involves signiﬁcantly more tedium. Bertsimas and Sim 2004). Indeed. For us. Formally. e. an uncertain linear program (LP). A generic m -valued nonanticipative decision rule belongs to the set m N I ≡ f N 2. The LDRs are also required to satisfy the same nonanticipative requirements. the modeler has to convert the original uncertain optimization problem into its deterministic equivalent. 2006. for some constant vector c. we adopt the convention ˜ that (in)equalities involving z hold almost surely for all ˜ ˜ ∈ . for more where the ﬁrst two parameters of · are dimensional parameters. Matrix/ vector transposes are denoted by the prime ( ) symbol. including rights and permission policies. which may affect both system dynamics and a systemwide objective. Furthermore.org/. Finally. with decision variables x and y. r s x y max x + 2y s.informs. For completeness. i. We consider decision making in a dynamic system evolving in discrete time.g.t. are also made at ﬁxed time epochs. models that involve recourse. 3. 973–985. given the full history of the system’s evolution until the current time. e.e. zx + y 1 ˜ x y 0 (1) where the only distributional information we have about the scalar uncertainty z is that z ∈ −1 1 almost surely. To solve a robust optimization problem.. is available at http://journals. We denote by e the vector of all ones. z c ⇔ z c = 1∀ ∈ . which obscures the simplicity and interpretation of the original model (1). Chen and Zhang 2009. a decision rule is a prescription of an action. searching for a decision rule in · requires searching over a space of functions. which. Any meaningful decision rule in practice should therefore be functionally dependent only the uncertainties that have been revealed by the current time. e.Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). known only to reside in some family . Assuming throughout this section that we have N model uncertainties. Motivation The motivation for our work can be illustrated by a simple example.e. componentwise. we have to convert it into its robust counterpart. the equivalence between (1) and (2) should not be immediately evident from the algebraic formulations. The approach taken by recent works (Ben-Tal et al. without the modeler having to manually perform the tedious and error-prone conversion into its deterministic equivalent (2). and decisions. This and other related mechanical conversions are performed internally within the ROME system to allow the modeler to focus on the core task of modeling a given problem. However. Nonanticipative Decision Rules A distinctive feature in ROME is the use of decision rules to model recourse decisions. Such decision rules are said to be adapted or non-anticipative. is computationally difﬁcult.. and a scalar uncertainty z: ˜ max x + 2y x y s. i. Consider the following simple robust optimization problem. Furthermore. for some positive integer N . and by ei the ith standard basis vector. r + s + y 1 r −s−x =0 r s x y 0 (2) → m f z+ i I ie i =f z ∀ ∈ N (3) and solve it by standard numerical solvers. converting from (1) to (2) requires reformulating the uncertain constraint of the original problem into an embedded LP. and the last parameter I captures the functional dependence on the revealed uncertainties. we assume 0 = ∅. where uncertainties are progressively revealed.

which is typically quite minor. in z ˜ addition. w0 + W˜ . Such considerations were fundamental to ROME’s design. deterministic equivalent (from an LP to a SOCP) when constructing bounds on the nonlinear terms. ˜ A generic m -valued LDR x z can be represented in closed ˜ form as x z = x0 + X˜ . For a given LDR. The line numbers for the code excerpts in this section correspond to those in the appendices for ease of reference. we impose constraints on the extent of backordering within the model constraints. © 2011 INFORMS INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). Notice that if I represents ˆ ˜ the information index set of x z . is also dependent on the problem structure. single-echelon. then the columns of X with indices in the set I c must be constrained to be all zeros. and also how their algebraic formulations can be naturally expressed within ROME. and constructing the appropriate bounds. we have included full algebraic and ROME models in the appendices. where the algorithm that constructs P is also dependent on the structure of I. pp. P y0 + Y˜ . sufﬁcient for optimality. the case is even stronger. Bertsimas et al. The onerous task of analyzing the problem structure. These works showed that by searching over a larger space (of piecewise-linear functions). users should be able to work directly ˜ with x z and essentially ignore its internal representation. We consider a distributionally robust version of a single-product. and paying a (typically) minor computational cost. we will only present the relevant sections of algebraic formulations and the ROME models. Specifically. to model decision rules is twofold. Shang and Song 2006) typically use the structural properties of the demand process to approximate the service constraint by an appropriate penalty cost within the objective. For reference. which is deﬁned as (Cachon and Terwiesch 2009) the ratio of ﬁlled orders to the mean demand. we illustrate the utility of this design choice for modeling robust optimization problems.informs. Although a detailed discussion of the theory of BDLDRs is beyond the scope of this paper (an in-depth analysis is provided in Goh and Sim 2010). where x0 ∈ m . but they also use a penalty cost instead of a service constraint. The construction of P involves solving a series of secondary linear optimization problems based on the problem structure (details are given in Goh and Sim 2010). multiperiod inventory management problem. For BDLDRs. However. Service-Constrained Inventory Management 4. which improves the optimization objective. one might expect that by restricting decision rules to LDRs. First. The LDR coefﬁcients x0 . For a class of multistage robust optimization problems. x z has information index set I. w0 ∈ m and W ∈ Rm×N are decision variables in the model.Goh and Sim: Robust Optimization Made Easy with ROME 976 Observe that by construction. solving the secondary linear programs. the object that is meaningful from a modeling perspective is the afﬁne ˜ function x z . Boyaci and Gallego 2001. P ∈ m×M is a constant coefﬁcient matrix. the feasible region is enlarged by searching over a larger space of piecewiselinear decision rules. Additional information. the inventory manager’s problem is to ﬁnd ordering quantities in each period that . (as compared to LDRs). that is constructed on the ﬂy. the modeler can potentially improve the quality of the decision rule. (2010) show that LDRs are. (2008) proposed different piecewise-linear decision rules to overcome the restrictiveness imposed by LDRs. because BDLDRs are central to ROME’s design and functionality. Our model can be interpreted as a form of service guarantee to customers. Modeling Examples In this section we discuss several robust optimization problems and how they can be modeled algebraically. based on the structure of the model constraints and objective.org/. single-echelon. However. is available at http://journals. The beneﬁt of using BDLDRs. distributional information on ˜ z leads to good bounds on the nonlinear deﬂected component. Our model differs from the classical treatment of inventory management in the literature (Arrow et al. 4. If. X ∈ m×N . should be handled internally by the modeling system. See and Sim (2009) also study a robust singleproduct. we will highlight the key principles involved in their construction and usage. the resulting decision variables w0 W y0 Y must also obey similar structural constraints as the LDR. and a possible increase in complexity of the ﬁnal Operations Research 59(4). Because the emphasis in this section is on ROME’s utilty as a modeling tool. in the BDLDR case. in general. For example. y0 ∈ M and Y ∈ M×N are also decision variables that are solved for in the model. We assume that back orders are allowed. Through the examples presented in §4. 4. we impose a constraint on the inventory ﬁll rate. although the decision variables from a numerical solver’s perspective are x0 and X. 1951) in our modeling of shortages. Other service-constrained inventory models in the literature (e. its inner dimension. but instead of penalizing stockouts by imposing a linear penalty cost within the problem objective. M.1. and not by the modeler. LDRs can be further improved upon. X correspond to decision variables in standard mathematical programming. multiperiod inventory management problem.1. Chen et al. ˆ ˜ A generic m -valued BDLDR x z may be expressed as − ˆ ˜ x z = w0 + W˜ + P y0 + Y˜ . including rights and permission policies.g. Finally. in our model.1. Similar z z to the LDR. the modeler may suffer a penalty on the optimization objective. Intuitively. The cost of using BDLDRs is an added computational cost of solving the secondary linear programs.2 Therefore. Description. m N I ⊂ m N I . we have an additional layer of complexity. and deﬂected part.. and comprises a linear z z − part. when worst-case expectations are taken over the BDLDR. which are the actual quantities that are optimized in a given model. However. This approach was later generalized by Goh and Sim (2010) to bideﬂected linear decision rules (BDLDRs). In turn. In a modeling system catering to robust optimization applications. Second. 973–985. in fact. Such techniques are not suitable for our model as the actual demand distribution is unknown.

as well as the other standard inventory constraints. We assume no ﬁxed cost components to all costs involved. Recall that by our convention. and known covariance matrix . we denote by ct the unit ordering cost and the maximum order quantity by xtMAX . When the decision rules are restricted to LDRs. Table 1 lists several programming variables and the model parameters that they represent. We assume a ﬁnite planning horizon of T periods. xMAX c h . we model this by ﬁrst declaring a programming variable z that represents the uncertainty. when a and b are MATLAB variables with assigned integer values with b not smaller than a. % assign end array 4. ˜ ˜ z ∈ T . for each t ∈ T .2. set_mean ( mu ) . ˜ Further. In each period t ∈ T . pp. xt z should only be functionally dependent on the ˜ ﬁrst t − 1 values of z. we require xt ∈ 1 N t − 1 and yt ∈ 1 N t . Finally. z (1:( t -1) ) ) x ( t ) = xt . and has corresponding information index set t − 1 . The exact distribution of z is unknown. it to the tth entry of x Code Segment 2: Constructing the order quantity decision rule in ROME. % set an uncertain demand the support the mean the covariance minimize the worst-case expected total ordering and holding cost over the ﬁnite horizon. but the inventory manager has knowledge of some distributional information that characterizes a family of uncertainty distributions. we denote the minimum required ﬁll rate by t . 34 35 36 37 38 39 40 41 % allocate an empty variable newvar x ( T ) empty .Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). 4. At the point of this decision. We begin by describing how uncertainties are modeled. In Code Segment 2. Formally. Additional information. In each period. the expression a : b returns an array with unit increments. Covar = S . represented as = L L for known model parameters and . Parameters. the family of distributions ˜ that contains the true distribution of the demand z can be characterized as = ˜ z ∈ 0 zMAX T decision rule linearrule . Size 1 × 1 T×1 T×1 1×1 1×1 T×T T×1 T×1 T×1 T×1 Model parameter T zMAX e Description Number of periods ˜ Support parameter for z ˜ Mean of z ˜ Covariance parameter for z ˜ Covariance parameter for z ˜ Covariance matrix of z Order quantity upper limit Unit ordering cost Unit holding cost Target (minimum) ﬁll rate Variable name T zMax mu sigma alpha S xMax c h beta =1 E ˜ z = Cov ˜ z = In ROME. including rights and permission policies. % declare rome_constraint ( z >= 0) . have known mean . similar to Johnson and Thompson (1975) and Veinott (1965). The corresponding ˜ information index set for yt z is t .1.informs. ˜ We let xt z be the decision rule that represents the order quantity in period t. Leftover inventory at the end of each period can be held over to the next period. The inventory level can be modeled in an identical way. Model. INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). rome_constraint ( z <= zMax ) .3. We assume for the rest of this discussion that these variables have been declared and assigned appropriate numerical values. we aim to introduce various modeling constructs in ROME and show how the ROME code is a natural expression of the model’s algebraic formulation. 973–985. with no lead time for ordering. % set z . The lower triangular matrix L ∈ T ×T has structure 1 0 0 ··· 0 1 0 ··· 0 1 ··· 0 L = 1 which represents an autoregressive model for demand. and satisfy the ﬁll rate constraint in each period. because we will use them within various code segments later. % set z . In this example. and assigning various distributional properties to it. Notice that the covariance matrix S is a numerical quantity that can be constructed from alpha and sigma by appropriate matrix operations. with an exogenous uncertain demand in each period.1. % iterate over each period for t = 1: T % construct the period t newvar xt (1 . modeled by a primitive uncertainty vector. 0 ≡ ∅. to capture intertemporal demand correlation. we let yt z be the decision rule that represents the inventory level at the end of period t. Table 1. ˜ Hence. only the demands in the ﬁrst t − 1 periods have been realized. with a per-unit holding (overage) cost of ht . the family contains all distributions that have support on the hypercube 0 zMAX T . In MATLAB syntax. © 2011 INFORMS 977 27 28 29 30 31 newvar z ( T ) uncertain . Through this example. is available at http://journals. there is no starting inventory. List of programming variables and their associated model parameters for the inventory management problem. x z . In particular. we assume that the goods have no salvage value at the end of the T periods. we show how to use ROME to ˜ model the order quantity decision rule. and that the inventory manager is ambiguity averse. the colon “:” operator is used to construct numerical arrays with ﬁxed increments between its elements. Code Segment 1: Specifying distributional properties on the ˜ uncertain demand z.org/.

Code Segment 6: Modeling the inventory manager’s objective. Code Segment 5: Modeling the ﬁll rate constraint. including rights and permission policies. When t exceeds 1.1 components of z. In each iteration of the for loop. where the sales in period t can be computed as the minimum between the inventory level after ordering and the demand in the same period. 53 54 55 56 57 58 59 % Period 1 inventory balance rome_constraint (y (1) == x (1) . Additional information. lower limit 63 rome_constraint (x <= xMax ). The constraints may be written as ˜ ˜ y1 z = x1 z − z1 ˜ ˜ ˜ ˜ yt z = yt−1 z + xt z − zt ˜ ∀t ∈ 2 T Operations Research 59(4). the complexity the bounds are hidden from the user. respectively. upper limit min sup EP ∈ − t=1 ˜ ct xt z + t=1 ˜ ht yt+ z Code Segment 4: Modeling the limits on the order quantity. % iterate over each period for t = 2: T % period t inventory balance rome_constraint (y(t) == y(t -1) + x(t) .informs. we have a term that is the expected positive part of an LDR. and we can model this constraint in ROME as 65 % fill rate constraint 66 rome_constraint ( mean ( neg ( y ) ) <= mu .1)) extracts the ﬁrst t . the distributionally robust ﬁll rate constraint reads inf ∈ ˜ ˜ ˜ EP min yt−1 z + xt z zt t t INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). The algebraic formulations for these bounds are typically quite messy. Notice that the MATLAB operator . The code segment begins declaring x as a size T empty array. however. This can be expressed as T T Code Segment 3: Modeling the inventory balance constraints.z( t ) ) . We model this in ROME by the statement 68 % model objective 69 rome_minimize (c ’* mean ( x ) + h ’* mean ( pos ( y ) ) ) . pp.mu . the expression a : b returns an empty array. As in standard inventory models. we construct a scalar-valued variable xt.* beta ) . we showed how such functions could be computed. Similarly. Observe that the programming variables are vector valued.Goh and Sim: Robust Optimization Made Easy with ROME 978 starting from a and ending at b. 973–985. In ROME. When t is exactly equal to 1. % order qty . the total cost comprises the inventory ordering cost and the holding cost.z (1) ). The ﬁll rate in a period t is deﬁned (Cachon and Terwiesch 2009) as the ratio of expected ﬁlled orders to the mean demand. Notice that in MATLAB syntax. Hence. % order qty . In a previous work (Goh and Sim 2010).* represents an elementwise (Hadamard) product of two vectors. the upper and lower limits on the order quantities can be modeled by the constraints 0 ˜ xt z xtMAX ∀t ∈ T We may express this set of constraints in ROME as 62 rome_constraint (x >= 0) . which we will later use to store the constructed decision rules. In our model. given the distributional ˜ properties of z. which represents the period t ˜ decision rule xt z . for each t ∈ T . The next line stores the constructed decision rule into the array x for later use. we have the inventory balance constraints that describe the system dynamics. the “ ’ ” symbol represents the transpose of a vector. Code Segment 3 shows how the balance constraints may be modeled in ROME.org/. as min sup ∈ EP c x z + h y+ z . the expression z(1 : (t . In our model. The inventory level in period t + 1 is the difference between the period t inventory level (after ordering) and the period t demand. we desire to ˜ ˜ or more compactly. which indicates to ROME an empty information index set. end We notice that the right-hand side of the simpliﬁed inequality can be computed as a function of the model parameters. On the left-hand side.1)) returns an empty matrix. and that the code segment imposes the inequality constraints component-wise. the inventory manager’s objective in this problem is to minimize the worst-case expected total cost over all the distributions in the family. is available at http://journals. We refer interested readers to Goh and Sim (2010) for the exact formulations. and dependent on the types of ˜ distributional information of z available. In ROME. If b is (strictly) smaller than a. the expression z(1 : (t . Together with the inventory balance constraints. the ﬁll rate constraints can be simpliﬁed to ˜ sup EP yt z ∈ − t 1− t ∀t ∈ T Assuming that the programming variables x and y have been previously declared and represent the order quantity and inventory-level decision rules. which speciﬁes the information index set of xt. . Finally. or at least bounded from above. the objective function is modeled in a similarly intuitive way. © 2011 INFORMS meet the target (minimum) ﬁll rate t for all distributions ∈ .

1.5. and how the optimization results of ROME can be extracted for numerical analysis. including rights and permission policies.118 . Readers who are familiar with the vectorized programming paradigm of MATLAB may ﬁnd our ROME model for the inventory management problem somewhat awkward because of the use of many loops within the model. pp. we consider a distributionally robust version of the project-crashing problem. and we will defer this discussion until later. The computed solutions can be extracted for further analysis using the eval function. Parameters. with arcs representing individual activities for the project. This example demonstrates how ROME can be used to model nonanticipative constraints over a network. Roman 1962. and Appendix B contains an example of a vectorized ROME model for this problem. we do not presume ˜ exact knowledge of the actual distribution of z. Description. which speciﬁes the dependency pattern on the uncertainty vector using a logical matrix. respectively. In particular. the optimized objective. Finally. However.informs. We adopt the robust optimization formulation here and show how ROME can be used to model and solve the project-crashing problem.969* z1 + 1. 4.org/. the latter consideration motivated our decision to design ROME within the MATLAB environment so that users can take advantage of the capabilities of the host MATLAB environment for numerical analysis and manipulation. Herroelen and Leus (2005) provide a comprehensive survey of the various techniques for project scheduling for uncertain activity times. Solutions.000* z1 An electronic companion containing the appendices to this paper is available as part of the online version at http:// or. solve the problem using standard LDRs or BDLDRs. subject to a project budget constraint. INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). Navy (1958). respectively.4. which corresponds to the worst-case total cost over the family of distributions. Solving via BDLDRs. we assume that the project manager’s objective is to minimize the expected completion time of the project.0. An alternative to PERT that avoids the distributional assumption on the activity times is to formulate the problem as a robust optimization problem (Cohen et al. In particular. Goh et al. van Slyke 1963). Although the model presented in this section is less computationally efﬁcient.S. After modeling the problem in ROME. A widely used technique for project analysis in practice is PERT U.000 + 1. However. can also be read from the ROME by calling the objective function. © 2011 INFORMS 979 2009) contains a detailed description of how to use the Pattern option.informs. Moreover.969* z1 )^. if desired. In this example. this functionality clearly diminishes in utility for larger and more complex problems. Consider a project with N activities that have uncertain completion times represented by ˜ an uncertainty vector z ∈ N .org. from a modeling perspective.2. The topology of the graph represents precedence constraints of the various activities. This is best exempliﬁed in the subsequent project-crashing modeling example. In part. We refer readers to Kerzner (2009) and Klastorin (2004) for a more complete introduction to the problem. These parameters form lower and upper ˜ bounds of z. we feel that it bears stronger similarity to the algebraic formulation and has value in its relative ease of understanding and implementation from a modeling standpoint. Remarks.. If desired.1. 4.000 0. 973–985. A sample numerical output (corresponding to the parameter values used in the ROME code in Appendix A) for the LDR describing the ﬁrst two periods of the order quantity is 57. 4. using the Pattern option within their declaration.2. we can issue a call to either solve or solve_ deflected to instruct ROME to.1.2. 2007. the inventory balance constraint can be reformulated into a single constraint involving a matrix-vector product. ROME provide the functions (linearpart and deflectedpart) for users to extract the relevant coefﬁcients of the decision rules for numerical analysis. 4.2. we have accurate estimates of the most optimistic activity times zL and the most pessimistic activity times zH . Project Crashing 4. Additional information. we assume that we know the mean activity time vector and covariance matrix of the activity times. which effectively limits the amount of crashing.journal. Again.1. An activity-on-arc (AOA) project network is a representation of a project in a directed acyclic graph. the numerical quantities of interest are often not the actual coefﬁcients.969* z1 )^- The above displays show sample “prettyprints” of how the decision rules are output to the user and are useful for human analysis and basic solution understanding.882 + 0.833 1.Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). the ROME modeling code can also be vectorized for computational efﬁciency.00(58. 2010) to ﬁnd the optimal crash amounts and activity start times. PERT makes several strong modeling assumptions and has consequently come under strong criticism (e. the sample output for the ﬁrst two periods of order quantities is 31. but rather the instantiated values of the decision rules for the realized uncertainties. but can be expedited or crashed by deterministic amounts by committing additional resources to the activities.882 + 0. In our model. characterized by certain distributional properties.00(1. is available at http://journals. but instead assume that the true distribution belongs to a family of distributions . The User’s Guide to ROME (Goh and Sim .g. The decision rules with their associated nonanticipative requirements can be constructed without using loops as well. We consider a model in which completion times of the individual activities are uncertain.

© 2011 INFORMS Variable Model name Size parameter N 1 x 1 1 N N N N N N 1 x x x x x x x x 1 1 1 1 T 1 1 1 N M zL zH c u B sion. can be constructed as i Ix = k Iy for any k such that Aik = −1 if i = M if i = M N Modeling this in ROME follows directly from the construction of y above. % assign it to the kth entry of y y ( k ) = yk . The time evolution of the project is represented by the inequality ˜ ˜ xj z −xi z ˜ zk −yk z ˜ + The corresponding code in ROME is also identical in structure to the inventory management example. we have included the full algebraic model and ROME code in Appendix B.3. For reference. it cannot have negative completion time. Additional information. At the point of this deci- ∀k ∈ N Aik = −1 Ajk = 1 which states that the difference in event times between two nodes that are joined by an activity must exceed the activity time after accounting for the crash. we let yk z be the decision rule that represents the crash amount for activity k. prioractivities is a function that implements recursion (5) and returns the array ind. Then. end The precedence relations in the network are described by an AOA project network. . the common start time of the activities that i exit node i. For any activity l ∈ N . We can recursively construct the corresponding k information index set Iy . with M nodes and N arcs. for each node i of the network.informs. we assume that the nodes are indexed such that the starting node has index 1 and the terminal node has index M. % construct the decision rule newvar yk (1 . which contain the indices of the dependent activities. or. The electronic companion details the code for its implementation.org/. including rights and permission policies. ˜ The remaining decision rule is xi z . Model. z ( ind ) ) linearrule .Goh and Sim: Robust Optimization Made Easy with ROME 980 Table 2. Description Number of activities.2. only the activities that precede activity k have been completed. The · + operation is a statement that regardless of how much an activity is crashed. We represent the graph topology by an incidence matrix A ∈ M×N . This representation is more natural for our model instead of the V E representation or an adjacency matrix representation. we denote the maximum amount that it can be crashed by the parameter uk . List of programming variables and their associated model parameters for the projectcrashing problem. We begin by modeling the uncertainty z. The family of uncertainty distributions is formally described by = zL ˜ z ˜ zH = 1 E z = ˜ Cov z = Code Segment 7: Constructing the crash amount decision rule in ROME. deﬁne the set l = l ∈ N ∃i ∈ M Ail = −1 Ail = 1 INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). 39 40 41 42 43 44 45 46 47 48 49 % y : crash amounts newvar y ( N ) empty . and the crashing cost per unit time by ck . Ix . and is shown below. which has components −1 if arc k leaves node i. 1 if arc k enters node i. For each activity k ∈ N . pp. In addition. ˜ 4. In ROME. The next line then uses ind to index into the uncertainty vector z to construct the dependencies of the kth activity. because we will use them within various code segments later. is available at http://journals. A ) . because it naturally preserves the integer indices on the activities. represented by yk. number of arcs in network Number of nodes in network Optimistic activity completion time Pessimistic activity completion time Mean activity time Covariance matrix of activity time Crashing cost per unit time Crashing limit Project budget Operations Research 59(4). Here. % allocate an empty variable array % iterate over each activity for k = 1: N % get indices of dependent activities ind = prioractivities (k . which represents the time of node i. We assume for the rest of this discussion that these variables have been declared and assigned appropriate numerical values. 973–985. Its corresponding information index set. we may recursively evaluate Iy as 1 Iy = ∅ and k Iy = l ∪ k ∈P l k Iy (5) which simply recursively includes all predecessors of k k into Iy . Aik = 0 otherwise. and we omit displaying it here. This follows an identical structure to the inventory management example. Table 2 lists several programming variables and the model parameters that they represent. ˜ Next. M zL zH mu Sigma c u B which is the set of activity indices that immediately prek cede l. The project budget is denoted by B. equivalently. The ROME model for constructing the crash amount LDR is almost identical to how the order quantity LDR was constructed in the previous example.

Recall that in our model we solve for the worst-case distribution over a family of distributions. Remarks. We can then generate these independent uniforms and instantiate the decision rules and the objective to evaluate their performance on this speciﬁc distribution. 1) . whereas if BDLDRs are used. In the numerical instance in Appendix B. we may want to measure how well the worst-case optimized decision rules perform against this distribution. we can express this as 70 % iterate over each activity 71 for k = 1: N 72 ii = find ( A (: . For example. k) == -1) . The project expenditure in simulation run is the inner product of the unit cost vector. As an example. the 95% conﬁdence interval of the mean expenditure is 9 6072 9 6125 . end assuming that x and y have been properly constructed. 76 end INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). if appropriate linear penalty cost parameters can be associated with late completion. which is represented by c y z B.case mean completion time 84 rome_minimize ( mean (x(M))).195 1. % activity k leaves node 73 jj = find ( A (: . we could instead minimize the expected total (crashing and Code Segment 10: Minimizing the expected project completion time.informs. the requirement that the total crashing cost must ˜ be within the budget. % nonnegative time 81 rome_constraint (c ’ * y <= B). This can be expressed in ROME using the code segment 83 % objective : minimize worst .Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). and ﬁnally. sup ∈ EP xM z .000 1. Notice that we have used the contraction rome_box as a convenient shorthand to express a constraint on a variable having upper and lower limits. A question that is of both theoretical and practical interest is how the decision rules perform for speciﬁc distributions.033* z1 + 0. if we can ﬁnd a distribution that attains the worst case. c. For example. we have used mean and covariance parameters such that an independent ˜ uniform distribution on the support of z is a possible distribution in . The remaining constraints are. u). The key ROME functionality used here is the insert function.529 + 0. Code Segment 8: Expressing the project dynamics in ROME. % number of simulation runs expenditure = zeros ( Nsims .4. with the result of the y_sol.021 0. Similar to the inventory management example. 1) .381 + 0.000 0.0. The project manager aims to minimize the worst-case expected completion time over the family of ˜ distributions.x( ii ) >= pos (z(k) .000* z3 + 0. From a practical standpoint.5. which we use to store the computed expenditures. the constraint that all times should ˜ be nonnegative. From a theoretical perspective. which is a numerical vector. The project completion time is simply the time of the ter˜ minal node. % crash limit 80 rome_constraint (x >= 0) . ROME can also model several variants of the project-crashing model presented here. has the displayed output y_sol = 2. % activity k enters node 74 % make constraint 75 rome_constraint (x( jj ) . which is represented by x z 0. insert ( z_vals ) . The computed expenditure is then stored in the expenditure array and can be used for various numerical analysis. which instantiates the LDR solution with the uncertainties.000* z6 0.289 + 2. The rand function generates an array of N independent uniform random 0 1 numbers that we shift and scale to get the simulated activity times. k) == 1) . 973–985.2. % allocate array for ii = 1: Nsims % simulate activity times z_vals = zL + ( zH . which are represented by the inequality ˜ 0 y z u. Additional information. 4. in this particular instance we can ﬁnd that using LDRs.054* z4 0. including rights and permission policies. % budget constraint Code Segment 9: Project constraints in ROME.y ( k ) ) ) .094* z3 which also can be used to verify that y does indeed satisfy the nonanticipative constraints.000* z5 .250* z1 + 0. using the numerical instance of the project-crashing problem described in Appendix B.000 1. Notice that MATLAB’s in-built zeros function creates an array of all zeros.500 0.262* z1 0. the 95% conﬁdence interval of the mean expenditure is 9 8781 9 8863 . Code Segment 11: Example of instantiating decision rules with uncertainty realizations. xM z . © 2011 INFORMS 981 than the multistage nonanticipativity seen in the inventory management example.020* z1 0. % instantiate crash costs expenditure ( ii ) = c ’ * y_sol . the LDR solution that represents the crash ˜ amounts. Alternatively. pp.004* z3 0. if we do indeed have an accurate estimate of the activity time distribution. we can use eval to return the optimized LDR or BDLDR after solving. 4.insert(z_vals). we could minimize the expected project-crashing cost.2. These inequalities are easily expressed in ROME as 79 rome_box (y . ﬁrstly. we would use the following code segment 93 94 95 96 97 98 99 100 Nsims = 10000.org/. secondly. Solutions. if we want to study the statistics of the project expenditure. which is more complicated . subject to a constraint on the project completion deadline.000* z2 0. is available at http://journals. then we know that the bound is tight and cannot be further improved. For example. the limits on the crash amounts. 0 .* rand (N .zL ) . y z .

beta ) 7 newvar v . . we will investigate how the coefﬁcient of variation (CV) of the optimized portfolio return varies with the target return level. and we also make the standard assumption that the assets are traded in a frictionless market (i. Table 3 lists several programming variables and the model parameters that they represent. Code Segment 12: Implementing a custom CVaR function in ROME.org/. Model. L H the worst -CVaR over all uncertainty distributions within . We do not presume to ˜ know the precise distribution of r ∈ N . The -CVaR is deﬁned as the conditional loss. and we get CVaR x = min v + v∈ 1 1− sup EP ∈ ˜ x −v + (6) We can encapsulate this within a function: 6 function cvar = CVaR ( loss . pp. 4. In particular. or 99%. and to solve this problem. how a ROME model can be easily embedded as components of a larger program. We let N denote the total number of assets available for investment. .v ) ) .e.1. A key exogenous parameter is the CVaR-level. given that the loss exceeds x .3. However. is available at http://journals. Theorem 1) show that the expression CVaR can be written in a more amenable form for optimization. This is in turn found via CVaR x = ˜x ˜x x Rockafellar and Uryasev (2000. measuring the expected loss within a speciﬁed quantile. CVaR is a measure of tail risk. subject to the mean portfolio return attaining the target.3. namely. letting the portfolio loss as a function of the decision be represented by ˜ x = −˜ x. we consider the problem of robust portfolio selection. Because we do not consider any dynamics in this problem. we aim to show how ROME can be used to study robust optimization problems that do not ostensibly require decision rules.beta ) ) * mean ( pos ( loss . which characterizes a family of distributions . 4. In addition. CVaR x = min v + v∈ 1 1− ˜ x −v + In our distributionally robust setting. © 2011 INFORMS List of programming variables and their associated model parameters for the inventory management problem. because we will use them within various code segments later. which we denote ˜ by the uncertainty vector r ∈ N . which speciﬁes the quantile over which the conditional expected loss is computed. various authors have indicated several problems with using variance as a measure of risk. including rights and permission policies. we will require that the optimized portfolio has a mean return above a prespeciﬁed target. we let L H represent the range of target returns that we search over. instead of minimizing expected costs. 1 − represents the probability that the loss exceeds x . In addition. For a ﬁxed .Goh and Sim: Robust Optimization Made Easy with ROME 982 penalty) cost in the objective. 1959) pioneered the use of optimization to handle the tradeoff between risk and return in portfolio selection. Finally. Size 1 N N 1 1 1 x x x x x x 1 1 T 1 1 1 Model parameter N Description Number of assets Mean return Covariance matrix returns CVaR-level Lower limit of target return Upper limit of target return Variable name N mu Sigma beta tL tH INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). and study how the characteristics of the optimal portfolio changes as the target return level varies. In this example. In this model. We assume for the rest of this discussion that these variables have been declared and assigned appropriate numerical values. we assume that we have accurate estimates of the asset return means and covariance matrix .3. the portfolio manager’s decision is a vector x ∈ N . Description.informs. Parameters. with the ith component representing the fraction of the net wealth to be invested in asset i. (2007). we will use CVaR as our objective for the portfolio optimization.3. Typical values of are 95%.2. 973–985. The drivers of uncertainty in this model are the asset returns. Operations Research 59(4).3. and minimizes Table 3. Robust Portfolio Selection 4. but instead. 98%. In this section. We will assume that no short-selling is permitted. 1999). qualifying it as a coherent measure of risk (Artzner et al. the -quantile of the loss distribution can be r found via x = min v ∈ ˜x v Therefore. A risk metric that overcomes many of the shortcomings of variance is the Conditional Value-at-Risk (CVaR) risk metric popularized by Rockafellar and Uryasev (2000). that this approach is only appropriate if the returns distribution is elliptically symmetric (Tobin 1958 and Chamberlain 1983). we consider the worstcase CVaR over all distributions within the family . we could also minimize worst-case costs. as in the model of Cohen et al. For a ﬁxed target return ∈ L H . Markowitz (1952. 4. the primary decision rule x is a standard vectorvalued decision variable in this problem. CVaR satisﬁes many desirable properties of a risk measure. a fully liquid market with no transaction costs). Additional information. introduced the (now classical) technique of minimizing portfolio variance. In this example.. and ﬁnally. and known distribution . the portfolio manager’s problem is to ﬁnd a portfolio allocation that has a mean return above . % declare an auxilliary variable v 8 cvar = v + (1 / (1 . how ROME models can be developed in a modular manner by writing custom functions.

covariance matrix. The second constraint is simply a normalization. Because x is a vector whose components represents fractions of net wealth. else cv ( ii ) = sqrt ( x_sol ’* Sigma * x_sol ) / ( mu ’* x_sol ) .optimal portfolio x_sol = optimizeportfolio (N . % label axes title ( ’ Plot of CV vs \ tau ’) . as well as a set of K vector-valued decisions rules yk · . cv = zeros ( Npts . objective )) x_sol = []. mean support. The decision variables in our framework comprise x. the -CVaR minimiz. tau ) % begin the ROME environment h = rome_begin ( ’ Portfolio Optimization ’). an n-dimensional vector of decisions to be made before the realization of any of the uncertainties. end end plot ( tau_arr . % mean return must exceed tau rome_constraint (mu ’ * x >= tau ). Npts ) . Finally. % number of points in to plot % allocate result array Therefore. it is formally deﬁned as CV ≡ x∗ x∗ x∗ (8) To investigate how the CV changes for ∈ L H . where is the set of nonanticipative decision rules as deﬁned in (3). We assume that we are given as parameters the information index sets Ik K . is available at http://journals.. beta )). x ex=1 (7) 0 INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). set_mean ( mu ) . beta . The CV is a dimensionless measure of variability of the optimized portfolio return and is deﬁned as the ratio of its standard deviation to its mean. % set mean r . mu . Npts) is a MATLAB in-built function that returns an array with Npts elements with equal consecutive differences.Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). where Ik ⊆ k=1 N ∀ k ∈ K . which we generally denote by . % label graph s. Sigma . tH. % check for infeasibility / unboundedness if ( isinf ( h . -CVaR optimized In the previous code segment.org/. . . for ii = 1: Npts % Find the CVaR . starting with the element 0 and ending with tH.. % set covariance % declare a nonnegative variable x newvar x ( N ) nonneg . Additional information. newvar r ( N ) uncertain . denoted by x∗ min CVaR −˜ x r x L H . linspace(0. cv ) . we may have knowledge of certain dis˜ tributional properties of z. . % Store the coeffients of variation if ( isempty ( x_sol ) ) cv ( ii ) = Inf . As a function of . namely. Sigma . This can be modeled in ROME as 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 function x_sol = optimizeportfolio (N . pp. We do not assume that the uncertainty distribution is precisely known. © 2011 INFORMS 983 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 Npts = 200. ROME’s Scope In the previous section. 973–985. mu . Covar = Sigma . deﬁned on the probability space . To model the nonanticipative requirements. and plot the ensuing CV against .t. tH . % get the optimal solution end rome_end . eval (x). 2007). we require that the decision rules belong to the sets y k ∈ mk N Ik ∀ k ∈ K . solves % array of target means to test tau_arr = linspace (0 . % assign an empty matrix else x_sol = h . The presence of these properties serve to characterize a family of distributions. its components must sum to 1. % solve the model h . the last constraint is simply a statement of the modeling assumption that short sales are not permitted. ylabel ( ’ CV ’) . 5. with image in mk for each k ∈ K . including rights and permission policies.. solve_deflected . % x must sum to 1 rome_constraint ( sum (x) == 1) . its support. and upper bounds on its directional deviations (introduced by Chen et al. we discussed how ROME can be used in several example applications in different areas of operations research. ˜ We denote by z an N -dimensional vector of uncertainties. % plot CV against tau xlabel ( ’\ tau ’) . x The ﬁrst constraint represents the requirement that the optimized portfolio must have a mean return above . % objective : minimize CVaR rome_minimize ( CVaR (-r ’ * x . % declare r as uncertainty r .. beta . that contains the actual distribution . we can simply compute the CV for a uniform sample of within this range. This can be done by the following code segment. % end the ROME environment Code Segment 14: Plotting the CV of portfolio against .informs. for a ﬁxed ∈ ing portfolio. tau_arr ( ii ) ) . 1) . but instead. In this section we formally establish ROME’s scope and the class of problems that it can model and solve. Code Segment 13: Portfolio optimization example in ROME.

A. T. 23(4) 769–805. E. Math. A linear decision-based approximation approach to stochastic programming. G. Optimal inventory policy. Oper. This is because although problem (9) is quite general.. including rights and permission policies. Manufacturing Service Oper. are also model parameters that are possibly inﬁnite componentwise. Programming Ser. 2004. Nemirovski. Delbaen. Y. Math. A. A. Ben-Tal. If desired. Boyd. Through the three modeling examples discussed in this paper.. Distributionally robust optimization under moment uncertainty with application to data-driven problems. D. Zhang. Optim. 2009.. 1983. El Hachem. T.informs. Breton. A. Uncertain linear programs: Extended afﬁnely adjustable robust counterparts. but instead solve for optimized decision rules residing in structured subsets of . Matching Supply with Demand: An Introduction to Operations Management.ethz. Serial production/distribution systems under service constraints. Eber. 2006. 2006. 1987.. A robust optimization perspective on stochastic programming. F. Terwiesch. X. Raman. . 2011. it is also unfortunately computationally intractable in most cases (see Ben-Tal et al. Release 2. deﬁned in (4). Extending scope of robust optimization: Comprehensive robust counterparts of uncertain problems. P. M. 57(6) 1469–1482. Notice that in ROME we do not solve (9) exactly. Res. 2010. DC. Theory 29(1) 185–201. The price of robustness. P. D. Sim. Kendrick. Oper. 2010. Math.25. ∀l ∈ M K Acknowledgments The authors thank the associate editor and the anonymous referees for their comments and critique on the ﬁrst version of this paper. M. Delage. A. Programming 99(2) 351–376. 1951.com 2. R. 2008. we have introduced ROME. Chen. J. J.. B. Optimality of afﬁne policies in multistage robust optimization.informs. G. Res. In addition. 2001. 52(1) 35–53. B 107(1–2) 63–89. K. GAMS Language Guide. respectively denoted by yk and yk . Dupaˇ ová. The minimax approach to stochastic programming and c an illustrative application. T z and v z are model parameters that are assumed to be afﬁnely dependent on the underlying uncertainties.Goh and Sim: Robust Optimization Made Easy with ROME 984 The general model that we consider is then K ∗ ZGEN = x y · Operations Research 59(4). The stochastic time-cost tradeoff problem: A robust optimization approach.org/. S.... A. M. Bertsimas. Chen. Math. Meeraus. Shtub.t. Y. 1995. Finance 9(3) 203–228. M. McGraw-Hill. GAMS Development Corporation. Accessed August 9. J.robustopt. Algorithms for the solution of stochastic dynamic minimax problems.com/ examples. Sun. Harris... Res. Res. 2009. A. Goryashko. X. Coherent measures of risk. J. is available at http://journals. Management 3(1) 43–50. Oper. X. Adjustable robust solutions of uncertain linear programs. D.robustopt. D. Parrilo. Econom. and demonstrated its utility in modeling robust optimization problems. Ye. A characterization of the distributions that imply mean-variance utility functions. © 2011 INFORMS Endnotes 1. 56(2) 344–357.html (9) min c0 x + sup EP K k k=1 ˜ d0 k yk z k=1 K ∈ − s. Oper. Their feedback has allowed the authors to signiﬁcantly improve the structure and quality of this paper. The set of LDRs. J. which reside in a larger subset of . Artzner. Sim. users can also choose to solve for BDLDRs. P. Sim.. D. M. . Conclusion In this paper. J. a MATLABbased robust optimization modeling toolbox. Oper. Additional information.php. Ben-Tal. 35(2) 363– 394. 55(6) 1058–1071. The upper and lower bounds ¯ on the recourse variable yk · . Brooke. 58(3) 595–612. ˜ T z x+ k=1 ˜ ˜ U y z =v z ¯ yk ∀k ∈ K k k yk x ˜ yk z 0 yk ∈ mk N Ik ∀k ∈ K (10) We note that for each l ∈ 0 ∪ M and k ∈ K . Ben-Tal. 1997. A. Freely available for academic use from http://www . 2004. is the default subset of used in ROME. http://control. References Arrow.. Robust convex optimization. Cachon.cl x + sup EP ∈ − k=1 ˜ dl k yk z bl INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s). 1999. 2004 or Shapiro and Nemirovski 2005 for a more detailed discussion). through the ﬁnal portfolio optimization example.. Kvasnica.ch/ ∼hybrid/cplexint. They are also especially grateful for the detailed comments by Area Editor Robert Fourer for his detailed feedback on the ﬁrst version of this paper. Zhang. Oper. Gallego. Guslitzer. Similarly. Econometrica 19(3) 250–272. 7. C. Stochastics 20(1) 73–88. Res. in a mathematically intuitive manner. Appl... Boyaci. 1998. I.journal . Marschak. Baotic. Nemirovski. Math. the quantities bl cl dl k Uk . Chen. pp.ee. Iancu. S. Bertsimas. and we have demonstrated how ROME allows users to model otherwise complex problems with relative ease. we have also demonstrated how ROME might be integrated into a sample application. 4 317–345.org/. A. CPLEXINT—MATLAB interface for the CPLEX solver. Networks 49(2) 175–188. We believe that ROME can be a helpful and valuable tool for further academic and industrial research in the ﬁeld of robust optimization. ROME code for both their model and ours can be freely obtained from http://www. Chamberlain. Nemirovski. 2007. G. A. 6. Boston. Oper. 2007. Washington. Golany. E. and Ik are model parameters which ˜ ˜ are precisely known. M. P. at the expense of a typically minor computational cost. Comput. A. Res. Sun. Heath. corresponding to a restriction of (9).. A. we have introduced ROME’s key features. Cohen. 973–985. M. Res.. Electronic Companion An electronic companion to this paper is available as part of the online version that can be found at http://or.

Vidyasagar).. Blondel. Taiwan... H. Sympos.. K. MOSEK ApS. Kerzner. YALMIP: A toolbox for modeling and optimization in MATLAB. M. 2009.. J. Fourer. Boyd. 2008. On minimax solution of stochastic linear programming c ˇ problems. e INFORMS holds copyright to this article and distributed this copy as a courtesy to the author(s).. Finance 7 77–91. K. Accessed August 9. M. 1958. 1975. 2002. pp. Holmström. 21(2) 242–256. A. Kimura. Res. Song. J. Comput. R.com/references/ROME_Guide_1. Tütüncü. M. 2009. 1(1) 47–69. Project scheduling under uncertainty: Survey and research potentials. http://cvxr. software). 2011. Goh. DC. S. J. Kernighan. Recent Advances in Learning and Control (a Tribute to M. Management Sci. Floudas. SIAM J. A. Žáˇ ková. Singapore.pdf. J. Shapiro.com/cvx. Goh. M. Distributionally robust optimization and its tractable approximations. .0. Korea. Navy. New York. Monte Carlo methods and the PERT problem. AMPL: A Modeling Language for Mathematical Programming. is available at http://journals. The MOSEK optimization software. Roman. Graph implementations for nonsmooth convex programs. Oper. Model. A. Aided Control Systems Design. Valente. eds. Methods Software 11 545–581. eds. Res. NUS Business School. H. Johnson. Ahmed. D. D. 1990. 1959. 1999.mosek. Mitra. Optim. On a class of minimax stochastic programs. http://www. Optimality of myopic inventory policies for certain dependent demand processes. 1st ed. MA. R. Casopis pro Pˇ stování Matematiky 91(4) 423–430. INFORMS J. Toh. 111–146. © 2011 INFORMS 985 Löfberg. Optim. phase I. Encyclopedia of Optimization. M. M. M. Bureau of Naval Weapons. Kluwer Academic Publishers. Springer. J. StAMPL: A ﬁltration-oriented modeling tool for multistage stochastic recourse problems. 2011. N. PERT summary report.robustopt. Goh. Fourer. eds. L. Fourer. Technical report. 1973. R. Management Sci. A. 1963. http://www. 1966. Oper. Springer. Optim. Sim. Oper. Extending algebraic modelling languages for stochastic programming. Oper. 2000. Kleywegt. 2004. Nemirovski. W. D. Lopes. Working paper. 1962. 2005. J. Eur. Continuous Optimization. Stochastic programming: Minimax approach. Federation of Automatic Control. M. Rubinov. 2009. NJ. R. 1999. John Wiley & Sons. Additional information. The PERT system: An appraisal of program evaluation review technique. R. S. H. Leus. Portfolio Selection: Efﬁcient Diversiﬁcation of Investments. 12(3) 206–222. dynamic. http://www -01. 2001. Portfolio selection. 25 65–85. Optim. Klastorin. M. H. New York. User’s Guide to ROME. 2004. Management 8(4) 394–406. Soyster. IEEE Internat. J. 1952. Pardalos. NJ. On complexity of stochastic programming problems. Tobin. C.Goh and Sim: Robust Optimization Made Easy with ROME Operations Research 59(4). New York. J. 14(4) 1237–1249. D. Löfberg. Gay. Res. 21(11) 1303–1307. Brooks/Cole Publishing. Grant. A C++ modelling environment for stochastic programming. Wiley. New York.. Van Slyke. Paciﬁc Grove. Veinott. 21(1) 107–122. Gay. Comput. Markowitz. IBM ILOG CPLEX. Fourer. A. M. 327–330. See. Accessed August 9. 11(5) 839–860. K. 2011. S. Optimization of conditional valueat-risk. and Controlling.S. Sadki. Shapiro. 95–110. S. D. Accessed August 9. 142 99–118. SDPT3—A MATLAB software package for semideﬁnite programming. 2002. Technical report. Robust optimization strategies for total cost control in project management. L. 2008. The TOMLAB optimization environment in MATLAB. R. Risk 2 493–517. Sim. Res. Seoul. 17th World Congress: The Internat. Hultberg. T. M. W. Boyd. W. 58(3) 583–594. Lopes. 2009. D. Uryasev. Grant. S. 58(4) 902–917. A management system for decompositions in stochastic programming. Ann. Stud. Shapiro.. 973–985. 10th ed. Oper. A closed-form approximation for serial inventory systems and its application to system design. Methods Software 17(3) 523–542. Project Management: Tools and Trade-Offs. R. B. Oper. G. IBM. Sim.com. J. 2010. Sim. 2011. Shang. Thompson. M. including rights and permission policies. R. Proc.org/. Rev. Washington. Vol.. Dupaˇ ová. Management Sci. Norwell. 2010. H. Project Management: A Systems Approach to Planning. 2006. Hoboken. Manufacturing Service Oper. 1965. A modeling language for mathematical programming. Hoboken. Econom. Robust approximation to multiperiod inventory management. R. J. Minimax analysis of stochastic programs.informs. Scheduling. U. Res.. Res. Kaut. J. P. G. Duxbury Press. 2008. H. T. c C.com/software/integration/optimization/cplex-optimizer. J. Management 5(1) 57–65.. H.-T. A. 36(5) 519–554. Retrieved August 9. 2005. Adv. Wiley.. 165 289–306. B.. Todd. 1958. C. nonstationary inventory problem. J. Jeyakumar. King. T. CA. Boyd.. Liquidity preference as behavior toward risk. A. INFORMS J. CVX: MATLAB software for disciplined convex programming (Web page. A. Special Projects Ofﬁce.. 2011. 2011. S. 2009. V. Comput. IBM. L. Modeling and solving uncertain optimization problems in YALMIP. V. Rockafellar. 21(5) 1154–1157. 2004. G. Fourer. Acad. Herroelen. M.. Convex programming with set-inclusive constraints and applications to inexact linear programming.. A. Markowitz. M. 5. Kernighan.ibm. Optimal policy for a multi-product. Hall. 2006.. E..

- Handout 2
- Developing a Two Stage Stochastic Programming Model of the Price and Lead Time Decision Problem in the Multi Class Make to Order Firm 2011 Computers I
- Ivanov 2015
- Linear Prog Graphical Method
- Fundamentals_of_MATLAB.ppt
- Operations Research - Linear Programming Problem of Union Airways
- An Algorithm for the Topology Optimization of Geometrically 2010
- Presentation Newest 3
- Project Paper
- The Dynamic Assignment Problem
- Operations Research Summary
- Optimization in quality
- Applications of Matlab in Optimization of Bridge
- 6180787
- Optimizing Linear Stepping Actuator Using Evolutionary Strategy Method
- ABC Inventory Ng
- Operational Research Assignment
- Optimization Methods (Lecture India)
- Anipla Final[1]
- Structural Sizing and Shape Optimisation of a Load Cell
- Operaciona istraživanja l1
- LowerBound Published
- Airfoil Aerodynamic Optimization
- 00728298 an Evolutionary Algorithm for the Optimal Design of Induction Motors
- SATSP
- [OK] LB1 (PPC)
- A Novel Approach for Light Trail Minimization Using Genetic Alg
- Lecture Notes 02
- Design of Goods and Services
- Q1

Close Dialog## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Loading