This CRAN task view contains a list of packages which offer
facilities for solving optimization problems.
Although every regression model in statistics solves an optimization
problem they are not part of this view. If you are looking for regression
methods, the following views will contain useful starting points:
Multivariate,
SocialSciences,
Robust
among others. The focus of this task view is on
Optimization Infrastructure
Packages
,
General Purpose Continuous
Solvers
,
Mathematical
Programming Solvers
, and
Specific Applications in
Optimization
. Packages are categorized in these sections.
Many packages provide functionality for more than one
of the subjects listed at the end of this task view. E.g., mixed
integer linear programming solvers typically offer standard linear
programming routines like the simplex algorithm. Therefore following each
package description a list of abbreviations describes the typical features
of the optimizer (i.e., the problems which can be solved). The
full names of the abbreviations given in square brackets can be
found at the end of this task view under
Classification According to
Subject
.
If you think that some package is missing from the list, please
let us know.

The
optimx
package provides a replacement and extension of
the
optim()
function in Base R with a call to several
function minimization codes in R in a single statement. These methods
handle smooth, possibly box constrained functions of several or many
parameters. Function
optimr()
in this package extends the
optim()
function with the same syntax but more 'method'
choices. Function
opm()
applies several solvers to a selected
optimization task and returns a dataframe of results for easy comparison.
The earlier
optimx()
function which has similar functionality
but a slightly different syntax and output is included for compatibility.

The R Optimization Infrastructure (ROI) package
provides a framework for handling optimization problems in R.
It uses an objectoriented approach to define and solve various
optimization tasks in R which can be from different problem classes
(e.g., linear, quadratic, nonlinear programming problems). This makes
optimization transparent for the R user as the corresponding workflow
is completely abstracted from the underlying solver. The approach allows
for easy switching between solvers and thus enhances comparability.
More information can be found at the
ROI home page
.

The package
CVXR
provides an objectoriented modeling
language for Disciplined Convex Programming (DCP). It allows the user
to formulate convex optimization problems in a natural way following
mathematical convention and DCP rules. The system analyzes the problem,
verifies its convexity, converts it into a canonical form, and hands it
off to an appropriate solver such as ECOS or SCS to obtain the solution.
(CVXR is derived from the MATLAB toolbox CVX, developed at Stanford
University, cf.
CVXR home page
.)
Package stats offers several general purpose optimization routines.
For onedimensional unconstrained function optimization there is
optimize()
which searches an interval for a minimum
or maximum.
Function
optim()
provides an implementation of the
BroydenFletcherGoldfarbShanno (BFGS) method, bounded BFGS,
conjugate gradient (CG), NelderMead, and simulated annealing (SANN)
optimization methods. It utilizes gradients, if provided, for faster
convergence. Typically it is used for unconstrained optimization
but includes an option for boxconstrained optimization.
Additionally, for minimizing a function subject to
linear inequality constraints, stats contains the routine
constrOptim(). Then there is
nlm
which
is used for solving nonlinear unconstrained minimization problems.
nlminb()
offers boxconstrained optimization using the
PORT routines. [RGA, QN]

Package
lbfgs
wraps the libBFGS C library by Okazaki and
Morales (converted from Nocedal's LBFGSB 3.0 Fortran code), interfacing
both the LBFGS and the OWLQN algorithm, the latter being particularly
suited for higherdimensional problems.

lbfgsb3
and
lbfgsb3c
both interface J.Nocedal's
LBFGSB 3.0 Fortran code, a limited memory BFGS minimizer, allowing bound
constraints and being applicable to higherdimensional problems.
('lbfgsb3c' has an 'optim'like interface based on 'Rcpp'.)

RcppNumerical
is a collection of open source libraries
for numerical computing and their integration with 'Rcpp'. It provides
a wrapper for the LBFGS algorithm, based on the LBFGS++ library
(based on code of N. Okazaki).

Package
ucminf
implements an algorithm of quasiNewton
type for nonlinear unconstrained optimization, combining a trust region
with line search approaches. The interface of
ucminf()
is
designed for easy interchange with
optim().[QN]

The following packages implement optimization routines in pure R,
for nonlinear functions with bounds constraints:
Rcgmin: gradient function minimization similar to GC;
Rvmmin: variable metric function minimization;
Rtnmin: truncated Newton function minimization.

mize
implements optimization algorithms in pure R,
including conjugate gradient (CG), BroydenFletcherGoldfarbShanno (BFGS)
and limited memory BFGS (LBFGS) methods. Most internal parameters
can be set through the calling interface.

Package
dfoptim, for derivativefree optimization
procedures, contains quite efficient R implementations of the
NelderMead and HookeJeeves algorithms (unconstrained and with
bounds constraints). [DF]

Package
nloptr
provides access to NLopt, an LGPL licensed
library of various nonlinear optimization algorithms. It includes local
derivativefree (COBYLA, NelderMead, Subplex) and gradientbased
(e.g., BFGS) methods, and also the augmented Lagrangian approach for
nonlinear constraints. [DF, GO, QN]

Package
alabama
provides an implementations of the
Augmented Lagrange Barrier minimization algorithm for optimizing smooth
nonlinear objective functions with (nonlinear) equality and inequality
constraints.

Package
Rsolnp
provides an implementation of the Augmented
Lagrange Multiplier method for solving nonlinear optimization problems
with equality and inequality constraints (based on code by Y. Ye).

NlcOptim
solves nonlinear optimization problems with
linear and nonlinear equality and inequality constraints, implementing
a Sequential Quadratic Programming (SQP) method; accepts the input
parameters as a constrained matrix.

In package Rdonlp2 (see the
rmetrics
project)
function
donlp2(), a wrapper for the DONLP2
solver, offers the minimization of smooth nonlinear functions and
constraints. DONLP2 can be used freely for any kind of research
purposes, otherwise it requires licensing. [GO, NLP]

clue
contains the function
sumt()
for
solving constrained optimization problems via the sequential
unconstrained minimization technique (SUMT).

BB
contains the function
spg()
providing a
spectral projected gradient method for large scale optimization with
simple constraints. It takes a nonlinear objective function as an
argument as well as basic constraints. Furthermore,
BB
contains two functions (
dfsane()
and
sane()) for using the spectral gradient method
for solving a nonlinear system of equations.

GrassmannOptim
is a package for Grassmann manifold
optimization. The implementation uses gradientbased algorithms
and embeds a stochastic gradient method for global search.

ManifoldOptim
is an R interface to the 'ROPTLIB'
optimization library. It optimizes realvalued functions over manifolds
such as Stiefel, Grassmann, and Symmetric Positive Definite matrices.

Package
gsl
provides BFGS, conjugate gradient,
steepest descent, and NelderMead algorithms. It uses a "line
search" approach via the function
multimin(). It is
based on the GNU Scientific Library (GSL). [RGA, QN]

An R port of the Scilab neldermead module is packaged in
neldermead
offering several direct search algorithms based
on the simplex approach. And
n1qn1
provides an R port of the
n1qn1
optimization procedure in Scilab, a quasiNewton BFGS
method without constraints.

optimsimplex
provides building blocks for simplexbased
optimization algorithms such as the NelderMead, Spendley, Box method,
or multidimensional search by Torczon, etc.

Several derivativefree optimization algorithms are provided with
package
minqa; e.g., the functions
bobyqa(),
newuoa(), and
uobyqa()
allow to minimize a
function of many variables by a trust region method that forms quadratic
models by interpolation.
bobyqa()
additionally permits box
constraints (bounds) on the parameters. [DF]

Package
powell
optimizes functions using Powell's
UObyQA algorithm (Unconstrained Optimization by Quadratic
Approximation).

subplex
provides unconstrained function
optimization based on a subspace searching simplex method.

In package
trust, a routine with the same name offers
local optimization based on the "trust region" approach.

trustOptim
implements a "trust region" algorithm for
unconstrained nonlinear optimization. The algorithm is optimized for
objective functions with sparse Hessians. This makes the algorithm highly
scalable and efficient, in terms of both time and memory footprint.

Package
quantreg
contains variations of simplex and
of interior point routines (
nlrq(),
crq()). It provides an interface to L1 regression
in the R code of function
rq(). [SPLP, LP, IPM]

In package
quadprog
solve.QP()
solves
quadratic programming problems with linear equality and inequality
constraints. (The matrix has to be positive definite.)
quadprogXT
extends this with absolute value constraints and
absolute values in the objective function. [QP]

kernlab
contains the function
ipop
for
solving quadratic programming problems using interior point
methods. (The matrix can be positive semidefinite.) [IPM, QP]

Dykstra
solves quadratic programming problems using
R. L. Dykstra's cyclic projection algorithm for positive definite and
semidefinite matrices. The routine allows for a combination of equality
and inequality constraints. [QP]

osqp
provides bindings to
OSQP
, the 'Operator Splitting QP' solver
from the University of Oxford Control Group; it solves sparse convex
quadratic programming problems with optional equality and inequality
constraints efficiently. [QP]

coneproj
contains routines for cone projection and
quadratic programming, estimation and inference for constrained parametric
regression, and shaperestricted regression problems. [QP]

LowRankQP
primal/dual interior point method solving
quadratic programming problems (especially for semidefinite quadratic
forms). [IPM, QP]

The COINOR project 'qpOASES' implements a reliable QP solver, even
when tackling semidefinite or degenerated QP problems; it is particularly
suited for model predictive control (MPC) applications; the ROI plugin
ROI.plugin.qpoases
makes it accessible for R users. [QP]

limSolve
offers to solve linear or quadratic optimization
functions, subject to equality and/or inequality constraints. [LP, QP]

Objective functions for benchmarking the performance of global
optimization algorithms can be found in
globalOptTests.

smoof
has generators for a number of both single and
multiobjective test functions that are frequently used for benchmarking
optimization algorithms; offers a set of convenient functions to generate,
plot, and work with objective functions.

flacco
contains tools and features used for an Exploratory
Landscape Analysis (ELA) of continuous optimization problems, capable of
quantifying rather complex properties, such as the global structure,
separability, etc., of the optimization problems.

cec2013
and
cec2005benchmark
contain many test
functions for global optimization from the 2005 and 2013 special sessions
on realparameter optimization at the IEEE CEC congresses on evolutionary
computation.

Package
funconstrain
(on Github)
implements 35 of the test functions by More, Garbow, and Hillstom, useful
for testing unconstrained optimization methods.
Function
solve.qr()
(resp.
qr.solve())
handles over and underdetermined systems of linear equations, returning
leastsquares solutions if possible. And package stats provides
nls()
to determine leastsquares estimates of the parameters
of a nonlinear model.
nls2
enhances function
nls()
with brute force or gridbased searches, to avoid being dependent on
starting parameters or getting stuck in local solutions.

Package
nlsr
provides tools for working with nonlinear
leastsquares problems. Functions
nlfb
and
nlxb
are intended to eventually supersede the 'nls()' function in Base R, by
applying a variant of the Marquardt procedure for nonlinear leastsquares,
with bounds constraints and optionally Jacobian described as R functions.
(It is based on the nowdeprecated package
nlmrt.)

Package
minpack.lm
provides a function
nls.lm()
for solving nonlinear leastsquares problems by a modification of the
LevenbergMarquardt algorithm, with support for lower and upper parameter
bounds, as found in MINPACK.

Package
lsei
contains functions that solve leastsquares
linear regression problems under linear equality/inequality constraints.
Functions for solving quadratic programming problems are also available,
which transform such problems into least squares ones first. (Based on
Fortran programs of Lawson and Hanson.)

Package
nnls
interfaces the LawsonHanson implementation of
an algorithm for nonnegative leastsquares, allowing the combination of
nonnegative and nonpositive constraints.

Package
bvls
interfaces the StarkParker implementation of
an algorithm for leastsquares with upper and lower bounded variables.

Package
onls
implements orthogonal nonlinear leastsquares
regression (ONLS, a.k.a. Orthogonal Distance Regression, ODR) using a
LevenbergMarquardttype minimization algorithm based on the ODRPACK
Fortran library.

colf
performs least squares constrained optimization on a
linear objective function. It contains a number of algorithms to choose
from and offers a formula syntax similar to
lm().

Package
ECOSolveR
provides an interface to the Embedded
COnic Solver (ECOS), a wellknown, efficient, and robust C library for
convex problems. Conic and equality constraints can be specified in
addition to integer and boolean variable constraints for mixedinteger
problems.

Package
scs
applies operator splitting to solve linear
programs (LPs), secondorder cone programs (SOCP), semidefinite programs,
(SDPs), exponential cone programs (ECPs), and power cone programs (PCPs),
or problems with any combination of those cones.

sdpt3r
solves general semidefinite Linear Programming
problems, using an R implementation of the MATLAB toolbox SDPT3. Includes
problems such as the nearest correlation matrix, Doptimal experimental
design, Distance Weighted Discrimination, or the maximum cut problem.

cccp
contains routines for solving cone constrained
convex problems by means of interiorpoint methods. The implemented
algorithms are partially ported from CVXOPT, a Python module for convex
optimization

The
CLSOCP
package provides an implementation of a onestep
smoothing Newton method for the solution of second order cone programming
(SOCP) problems.

CSDP is a library of routines that implements a primaldual barrier
method for solving semidefinite programming problems; it is interfaced in
the
Rcsdp
package. [SDP]

The DSDP library implements an interiorpoint method for semidefinite
programming with primal and dual solutions; it is interfaced in package
Rdsdp. [SDP]

Package
Rmosek
provides an interface to the (commercial)
MOSEK optimization library for largescale LP, QP, and MIP problems, with
emphasis on (nonlinear) conic, semidefinite, and convex tasks; academic
licenses are available. (An article on Rmosek appeared in the JSS special
issue on Optimization with R, see below.) [SDP, CP]

Package
DEoptim
provides a global optimizer based on the
Differential Evolution algorithm.
RcppDE
provides a C++
implementation (using Rcpp) of the same
DEoptim()
function.

DEoptimR
provides an implementation of the jDE variant of
the differential evolution stochastic algorithm for nonlinear programming
problems (It allows to handle constraints in a flexible manner.)

The
CEoptim
package implements a crossentropy optimization
technique that can be applied to continuous, discrete, mixed, and
constrained optimization problems. [COP]

GenSA
is a package providing a function for generalized
Simulated Annealing which can be used to search for the global minimum of
a quite complex nonlinear objective function with a large number of
optima.

GA
provides functions for optimization using Genetic
Algorithms in both, the continuous and discrete case. This package allows
to run corresponding optimization tasks in parallel.

Package
genalg
contains
rbga(), an
implementation of a genetic algorithm for multidimensional function
optimization.

Package
rgenoud
offers
genoud(), a routine
which is capable of solving complex function minimization/maximization
problems by combining evolutionary algorithms with a derivativebased
(quasiNewtonian) approach.

Machine coded genetic algorithm (MCGA) provided by package
mcga
is a tool which solves optimization problems based
on byte representation of variables.

A particle swarm optimizer (PSO) is implemented in package
pso, and also in
psoptim.
Another (parallelized) implementation of the PSO algorithm can be found
in package
ppso
available from
rforge.net/ppso
.

Package
hydroPSO
implements the latest Standard Particle
Swarm Optimization algorithm (SPSO2011); it is parallelcapable, and
includes several finetuning options and postprocessing functions.

hydromad
(on Github) contains the
SCEoptim
function for Shuffled Compex Evolution (SCE)
optimization, an evolutionary algorithm, combined with a simplex
method.

Package
ABCoptim
implements the Artificial Bee Colony
(ABC) optimization approach.

Package
metaheuristicOpt
contains implementations of
several evolutionary optimization algorithms, such as particle swarm,
dragonfly and firefly, sine cosine algorithms and many others.

Package
ecr
provides a framework for building evolutionary
algorithms for single and multiobjective continuous or discrete
optimization problems.

CMAES by N. Hansen, global optimization procedure using a covariance
matrix adapting evolutionary strategy, is implemented in several packages:
In packages
cmaes
and
cmaesr, in
parma
as
cmaes, in
adagio
as
pureCMAES, and in
rCMA
as
cmaOptimDP, interfacing Hansen's own Java
implementation.

Package
Rmalschains
implements an algorithm family for
continuous optimization called memetic algorithms with local search chains
(MALSChains).

An R implementation of the SelfOrganising Migrating Algorithm
(SOMA) is available in package
soma. This stochastic
optimization method is somewhat similar to genetic algorithms.

nloptr
supports several global optimization routines,
such as DIRECT, controlled random search (CRS), multilevel
singlelinkage (MLSL), improved stochastic ranking (ISRES), or
stochastic global optimization (StoGO).

The
NMOF
package provides implementations of differential
evolution, particle swarm optimization, local search and threshold
accepting (a variant of simulated annealing). The latter two methods also
work for discrete optimization problems, as does the implementation of a
genetic algorithm that is included in the package.

SACOBRA
is a package for numeric constrained optimization
of expensive blackbox functions under severely limited budgets;
it implements an extension of the COBRA algorithm with initial design
generation and selfadjusting random restarts.

RCEIM
implements a stochastic heuristic method for
performing multidimensional function optimization.
This section provides an overview of open source as well as commercial
optimizers. Which type of mathematical programming problem can be solved
by a certain package or function can be seen from the abbreviations in
square brackets.
For a
Classification
According to Subject
see the list at the end of this task view.

Package
ompr
is an optimization modeling package to model
and solve Mixed Integer Linear Programs in an algebraic way directly in R.
The models are solverindependent and thus offer the possibility to solve
models with different solvers. (Inspired by Julia's JuMP project.)

linprog
solves linear programming problems using the
function
solveLP()
(the solver is based on
lpSolve)
and can read model files in MPS format. [LP]

In the
boot
package there is a routine called
simplex()
which realizes the twophase tableau simplex
method for (relatively small) linear programming problems. [LP]

rcdd
offers the function
lpcdd()
for solving linear programs with exact arithmetic using the
GNU Multiple Precision (GMP)
library. [LP]

Package
clpAPI
provides high level access from R to
lowlevel API routines of the
COIN OR Clp
solver
library. [LP]

Package
lpSolve
contains the routine
lp()
to solve LPs and MILPs by calling the freely
available solver
lp_solve
. This solver is
based on the revised simplex method and a branchandbound (B&B)
approach. It supports semicontinuous variables and Special Ordered
Sets (SOS). Furthermore
lp.assign()
and
lp.transport()
are aimed at solving assignment problems
and transportation problems, respectively. Additionally, there is the
package
lpSolveAPI
which provides an R interface to the
low level API routines of lp_solve (see also project
lpsolve
on RForge).
lpSolveAPI
supports reading linear programs from files in lp
and MPS format. [BP, IP, LP, MILP, SPLP]

Packages
glpkAPI
as well as
package
Rglpk
provide an interface to the
GNU Linear Programming
Kit
(GLPK). Whereas the former provides high level access
to low level routines the latter offers a high level routine
Rglpk_solve_LP()
to solve MILPs using GLPK. Both
packages offer the possibility to use models formulated in the MPS
format. [BP, IP, IPM, LP, MILP]

Rsymphony
has the routine
Rsymphony_solve_LP()
that interfaces the SYMPHONY solver for mixedinteger linear programs.
(SYMPHONY is part of the
Computational
Infrastructure for Operations Research
(COINOR) project.)
Package
lsymphony
in Bioconductor provides a similar
interface to SYMPHONY that is easier to install. [LP, IP, MILP]

The NOMAD solver is implemented in the
crs
package
for solving mixed integer programming problems. This algorithm is
accessible via the
snomadr()
function and is
primarily designed for constrained optimization of blackbox
functions. [MILP]

'Clp' and 'Cbc' are open source solvers from the COINOR suite.
'Clp' solves linear programs with continuous objective variables and is
available through
ROI.plugin.clp. 'Cbc' is a powerful mixed
integer linear programming solver (based on 'Clp'); package 'rcbc' can
be installed from:
rcbc
(on Github).
[LP, MILP]
This section surveys interfaces to commercial solvers. Typically, the
corresponding libraries have to be installed separately.

Packages
cplexAPI
and
Rcplex
provide interfaces
to the IBM
CPLEX Optimizer
.
CPLEX provides dual/primal simplex optimizers as well as a barrier
optimizer for solving large scale linear and quadratic programs.
It offers a mixed integer optimizer to solve difficult mixed integer
programs including (possibly nonconvex) MIQCP. Note that CPLEX is
not free
and you have to get a license. Academics will receive a
free licence upon request. [LP, IP, BP, QP, MILP, MIQP, IPM]

The API of the commercial solver LINDO can be accessed in R
via package
rLindo.
The
LINDO API
allows for solving
linear, integer, quadratic, conic, general nonlinear, global and
stochastic programming problems. [LP, IP, BP, QP,MILP, MIQP, SP]

Package
Rmosek
offers an interface to the commercial
optimizer from
MOSEK
. It provides
dual/primal simplex optimizers as well as a barrier optimizer.
In addition to solving LP and QP problems this solver can handle SOCP
and quadratically constrained programming (QPQC) tasks. Furthermore,
it offers a mixed integer optimizer to solve difficult mixed integer
programs (MILP, MISOCP, etc.). You have to get a license, but Academic
licenses are free of charge. [LP, IP, BP, QP, MILP, MIQP, IPM]

Gurobi Optimization ships an R binding since their 5.0 release
that allows to solve LP, MIP, QP, MIQP, SOCP, and MISOCP models
from within R. See the
R with
Gurobi
website for more details. [LP, QP, MILP, MIQP]

The
localsolver
package provides an interface to the hybrid
mathematical programming software
LocalSolver
from Innovation 24.
LocalSolver is a commercial product, academic licenses are available on
request. [LP, MIP, QP, NLP, HEUR]

Package
adagio
provides R functions for single and multiple
knapsack problems, and solves subset sum and assignment tasks.

In package
clue
solve_LSAP()
enables
the user to solve the linear sum assignment problem (LSAP) using an
efficient C implementation of the Hungarian algorithm. [SPLP]

FLSSS
provides multithreaded solvers for
fixedsize single and multi dimensional subset sum problems with optional
constraints on target sum and element range,
fixedsize single and multi dimensional knapsack problems,
binary knapsack problems and generalized assignment problems via exact
algorithms or metaheuristics.

Package
qap
solves Quadratic Assignment Problems (QAP)
applying a simulated annealing heuristics (other approaches will
follow).

igraph, a package for graph and network analysis,
uses the very fast igraph C library. It can be used to calculate
shortest paths, maximal network flows, minimum spanning trees, etc.
[GRAPH]

mknapsack
solves multiple knapsack problems, based on LP
solvers such as 'lpSolve' or 'CBC'; will assign items to knapsacks in a
way that the value of the top knapsacks is as large as possible.

Package 'knapsack' (see RForge project
optimist)
provides routines from the book `Knapsack Problems' by Martello and Toth.
There are functions for (multiple) knapsack, subset sum and binpacking
problems. (Use of Fortran codes is restricted to personal research and
academic purposes only.)

nilde
provides routines for enumerating all integer
solutions of linear Diophantine equations, resp. all solutions of knapsack,
subset sum, and additive partitioning problems (based on a generating
functions approach).

matchingR
and
matchingMarkets
implement the
GaleShapley algorithm for the stable marriage and the college admissions
problem, the stable roommates and the house allocation problem.
[COP, MM]

Package
optmatch
provides routines for solving
matching problems by translating them into minimumcost flow problems
and then solved optimaly by the RELAXIV codes of Bertsekas and Tseng
(free for research). [SPLP]

Package
TSP
provides basic infrastructure for handling
and solving the traveling salesperson problem (TSP). The main routine
solve_TSP()
solves the TSP through several heuristics.
In addition, it provides an interface to the
Concorde TSP
Solver
, which has to be downloaded separately. [SPLP]

Function
caRamel
in package
caRamel
is a
multiobjective optimizer, applying a combination of the multiobjective
evolutionary annealingsimplex (MEAS) method and the nondominated sorting
genetic algorithm (NGSAII); it was initially developed for the
calibration of hydrological models.

Multicriteria optimization problems can be solved using package
mco
which implements genetic algorithms. [MOP]

The data cloning algorithm is a global optimization approach
and a variant of simulated annealing which has been implemented
in package
dclone. The package provides low level
functions for implementing maximum likelihood estimating
procedures for complex models using data cloning and Bayesian
Markov chain Monte Carlo methods.

irace
contains an optimization algorithm for optimizing the
parameters of other optimization algorithms. This problem is called
"(offline) algorithm configuration". [GO]

Package
kofnGA
uses a genetic algorithm to choose a
subset of a fixed size k from the integers 1:n, such that a user
supplied objective function is minimized at that subset.

copulaedas
provides a platform where 'estimation of
distribution algorithms' (EDA) based on copulas can be implemented and
studied; the package offers various EDAs, and newly developed EDAs can be
integrated by extending an S4 class.

tabuSearch
implements a tabu search algorithm for
optimizing binary strings, maximizing a user defined target function, and
returns the best (i.e. maximizing) binary configuration found.

Besides functionality for solving general isotone regression problems,
package
isotone
provides a framework of active set methods for
isotone optimization problems with arbitrary order restrictions.

mlrMBO
is a flexible and comprehensive R toolbox for
modelbased optimization ('MBO'), also known as Bayesian optimization.
And
rBayesianOptimization
is an implementation of Bayesian
global optimization with Gaussian Processes, for parameter tuning and
optimization of hyperparameters.

The
desirability
package contains S3 classes for
multivariate optimization using the desirability function approach
of Harrington (1965) using functional forms described by
Derringer and Suich (1980).

Package
sna
contains the function
lab.optim()
which is the frontend to a series of heuristic routines for optimizing
some bivariate graph statistic. [GRAPH]

maxLik
adds a likelihoodspecific layer on top of a number
of maximization routines like BrendtHallHallHausman (BHHH) and
NewtonRaphson among others. It includes summary and print methods which
extract the standard errors based on the Hessian matrix and allows easy
swapping of maximization algorithms. It also provides a function to check
whether an analytic derivative is computed directly.
What follows is an attempt to provide a bysubject overview of
packages. The full name of the subject as well as the corresponding
MSC 2010
code (if available) are given in brackets.

LP (Linear programming, 90C05):
boot,
clpAPI,
cplexAPI,
glpkAPI,
limSolve,
linprog,
lpSolve,
lpSolveAPI,
quantreg,
rcdd,
Rcplex,
Rglpk,
rLindo,
Rmosek,
Rsymphony

GO (Global Optimization):
DEoptim,
DEoptimR,
GenSA,
GA,
pso,
hydroPSO,
cmaes,
nloptr,
NMOF

SPLP (Special problems of linear programming like transportation,
multiindex, etc., 90C08):
clue,
lpSolve,
lpSolveAPI,
quantreg,
TSP

BP (Boolean programming, 90C09):
cplexAPI,
glpkAPI,
lpSolve,
lpSolveAPI,
Rcplex,
Rglpk

IP (Integer programming, 90C10):
cplexAPI,
glpkAPI,
lpSolve,
lpSolveAPI,
Rcplex,
Rglpk,
rLindo
Rmosek,
Rsymphony

MIP (Mixed integer programming and its variants MILP for LP
and MIQP for QP, 90C11):
cplexAPI,
glpkAPI,
lpSolve,
lpSolveAPI,
Rcplex,
Rglpk,
rLindo,
Rmosek,
Rsymphony

SP (Stochastic programming, 90C15):
rLindo

QP (Quadratic programming, 90C20):
cplexAPI,
kernlab,
limSolve,
LowRankQP,
quadprog,
Rcplex,
Rmosek

SDP (Semidefinite programming, 90C22):
Rcsdp,
Rdsdp

CP (Convex programming, 90C25):
cccp,
CLSOCP

COP (Combinatorial optimization, 90C27):
adagio,
CEoptim,
TSP,
matchingR

MOP (Multiobjective and goal programming, 90C29):
mco

NLP (Nonlinear programming, 90C30):
nloptr,
alabama,
Rsolnp, Rdonlp2,
rLindo

GRAPH (Programming involving graphs or networks, 90C35):
igraph,
sna

IPM (Interiorpoint methods, 90C51):
cplexAPI,
kernlab,
glpkAPI,
LowRankQP,
quantreg,
Rcplex

RGA (Methods of reduced gradient type, 90C52): stats
(
optim()),
gsl

QN (Methods of quasiNewton type, 90C53): stats
(
optim()),
gsl,
lbfgs,
lbfgsb3,
nloptr,
ucminf

DF (Derivativefree methods, 90C56):
dfoptim,
minqa,
nloptr

HEUR (Approximation methods and heuristics, 90C59):
irace